ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xenia-canary/xenia-build.py

507 lines
12 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python
# Copyright 2013 Ben Vanik. All Rights Reserved.
"""
"""
__author__ = 'ben.vanik@gmail.com (Ben Vanik)'
import os
import shutil
import subprocess
import sys
def main():
# Add self to the root search path.
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
# Check python version.
if sys.version_info < (2, 7):
print 'ERROR: python 2.7+ required'
sys.exit(1)
return
# Grab all commands.
commands = discover_commands()
# Parse command name and dispatch.
try:
if len(sys.argv) < 2:
raise ValueError('No command given')
command_name = sys.argv[1]
if not commands.has_key(command_name):
raise ValueError('Command "%s" not found' % (command_name))
command = commands[command_name]
return_code = run_command(command=command,
args=sys.argv[2:],
cwd=os.getcwd())
except ValueError:
print usage(commands)
return_code = 1
except Exception as e:
#print e
raise
return_code = 1
sys.exit(return_code)
def discover_commands():
"""Looks for all commands and returns a dictionary of them.
In the future commands could be discovered on disk.
Returns:
A dictionary containing name-to-Command mappings.
"""
commands = {
'setup': SetupCommand(),
'pull': PullCommand(),
'gyp': GypCommand(),
'build': BuildCommand(),
'test': TestCommand(),
'xethunk': XethunkCommand(),
'clean': CleanCommand(),
'nuke': NukeCommand(),
}
return commands
def usage(commands):
"""Gets usage info that can be displayed to the user.
Args:
commands: A command dictionary from discover_commands.
Returns:
A string containing usage info and a command listing.
"""
s = 'xenia-build.py command [--help]\n'
s += '\n'
s += 'Commands:\n'
command_names = commands.keys()
command_names.sort()
for command_name in command_names:
s += ' %s\n' % (command_name)
command_help = commands[command_name].help_short
if command_help:
s += ' %s\n' % (command_help)
return s
def run_command(command, args, cwd):
"""Runs a command with the given context.
Args:
command: Command to run.
args: Arguments, with the app and command name stripped.
cwd: Current working directory.
Returns:
0 if the command succeeded and non-zero otherwise.
Raises:
ValueError: The command could not be found or was not specified.
"""
# TODO(benvanik): parse arguments/etc.
return command.execute(args, cwd)
def has_bin(bin):
"""Checks whether the given binary is present.
"""
DEVNULL = open(os.devnull, 'wb')
return True if subprocess.call(
'which %s' % (bin), shell=True, stdout=DEVNULL) == 0 else False
def shell_call(command, throw_on_error=True):
"""Executes a shell command.
Args:
command: Command to execute.
throw_on_error: Whether to throw an error or return the status code.
Returns:
If throw_on_error is False the status code of the call will be returned.
"""
if throw_on_error:
subprocess.check_call(command, shell=True)
return 0
else:
return subprocess.call(command, shell=True)
class Command(object):
"""Base type for commands.
"""
def __init__(self, name, help_short=None, help_long=None, *args, **kwargs):
"""Initializes a command.
Args:
name: The name of the command exposed to the management script.
help_short: Help text printed alongside the command when queried.
help_long: Extended help text when viewing command help.
"""
self.name = name
self.help_short = help_short
self.help_long = help_long
def execute(self, args, cwd):
"""Executes the command.
Args:
args: Arguments list.
cwd: Current working directory.
Returns:
Return code of the command.
"""
return 1
def post_update_deps(config):
"""Runs common tasks that should be executed after any deps are changed.
Args:
config: 'debug' or 'release'.
"""
print '- building llvm...'
shell_call('third_party/ninja/ninja -C build/llvm/%s-obj/ install' % (config))
print ''
class SetupCommand(Command):
"""'setup' command."""
def __init__(self, *args, **kwargs):
super(SetupCommand, self).__init__(
name='setup',
help_short='Setup the build environment.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Setting up the build environment...'
print ''
# Setup submodules.
print '- git submodule init / update...'
shell_call('git submodule init')
shell_call('git submodule update')
print ''
# LLVM needs to pull with --rebase.
# TODO(benvanik): any way to do this to just the submodule?
#shell_call('git config branch.master.rebase true')
# Disable core.filemode on Windows to prevent weird file mode diffs in git.
# TODO(benvanik): check cygwin test - may be wrong when using Windows python
if os.path.exists('/Cygwin.bat'):
print '- setting filemode off on cygwin...'
shell_call('git config core.filemode false')
shell_call('git submodule foreach git config core.filemode false')
print ''
# Run the ninja bootstrap to build it, if it's missing.
if not os.path.exists('third_party/ninja/ninja'):
print '- preparing ninja...'
shell_call('python third_party/ninja/bootstrap.py')
print ''
# Ensure cmake is present.
if not has_bin('cmake'):
print '- installing cmake...'
if has_bin('brew'):
shell_call('brew install cmake')
elif has_bin('apt-get'):
shell_call('sudo apt-get install cmake')
else:
print 'ERROR: need to install cmake, use:'
print 'http://www.cmake.org/cmake/resources/software.html'
return 1
print ''
# Binutils.
# TODO(benvanik): disable on Windows
print '- binutils...'
if not os.path.exists('build/binutils'):
os.makedirs('build/binutils')
os.chdir('build/binutils')
shell_call(' '.join([
'../../third_party/binutils/configure',
'--disable-debug',
'--disable-dependency-tracking',
'--disable-werror',
'--enable-interwork',
'--enable-multilib',
'--target=powerpc-none-elf',
'--with-gnu-ld',
'--with-gnu-as',
]))
shell_call('make')
os.chdir(cwd)
print ''
# LLVM.
print '- preparing llvm...'
#generator = 'Visual Studio 10 Win64'
generator = 'Ninja'
def prepareLLVM(path, obj_path, mode):
os.chdir(cwd)
if not os.path.exists(path):
os.makedirs(path)
if not os.path.exists(obj_path):
os.makedirs(obj_path)
os.chdir(obj_path)
shell_call(' '.join([
'PATH=$PATH:../../../third_party/ninja/',
'cmake',
'-G"%s"' % (generator),
'-DCMAKE_INSTALL_PREFIX:STRING=../../../%s' % (path),
'-DCMAKE_BUILD_TYPE:STRING=%s' % (mode),
'-DLLVM_TARGETS_TO_BUILD:STRING="X86;PowerPC;CppBackend"',
'-DLLVM_INCLUDE_EXAMPLES:BOOL=OFF',
'-DLLVM_INCLUDE_TESTS:BOOL=OFF',
'../../../third_party/llvm/',
]))
os.chdir(cwd)
prepareLLVM('build/llvm/debug/', 'build/llvm/debug-obj/', 'Debug')
prepareLLVM('build/llvm/release/', 'build/llvm/release-obj/', 'Release')
print ''
post_update_deps('debug')
post_update_deps('release')
print '- running gyp...'
run_all_gyps()
print ''
print 'Success!'
return 0
class PullCommand(Command):
"""'pull' command."""
def __init__(self, *args, **kwargs):
super(PullCommand, self).__init__(
name='pull',
help_short='Pulls the repo and all dependencies.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Pulling...'
print ''
print '- pulling self...'
shell_call('git pull')
print ''
print '- pulling dependencies...'
shell_call('git submodule update')
print ''
post_update_deps('debug')
post_update_deps('release')
print '- running gyp...'
run_all_gyps()
print ''
print 'Success!'
return 0
def run_gyp(format):
"""Runs gyp on the main project with the given format.
Args:
format: gyp -f value.
"""
shell_call(' '.join([
'third_party/gyp/gyp',
'-f %s' % (format),
# Set the VS version.
# TODO(benvanik): allow user to set?
'-G msvs_version=2010',
# Removes the out/ from ninja builds.
'-G output_dir=.',
'--depth=.',
'--generator-output=build/xenia/',
'xenia.gyp',
]))
def run_all_gyps():
"""Runs all gyp configurations.
"""
run_gyp('ninja')
run_gyp('xcode')
run_gyp('msvs')
class GypCommand(Command):
"""'gyp' command."""
def __init__(self, *args, **kwargs):
super(GypCommand, self).__init__(
name='gyp',
help_short='Runs gyp to update all projects.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Running gyp...'
print ''
# Update GYP.
run_all_gyps()
print 'Success!'
return 0
class BuildCommand(Command):
"""'build' command."""
def __init__(self, *args, **kwargs):
super(BuildCommand, self).__init__(
name='build',
help_short='Builds the project.',
*args, **kwargs)
def execute(self, args, cwd):
# TODO(benvanik): add arguments:
# --force
debug = '--debug' in args
config = 'debug' if debug else 'release'
# If there's no LLVM we may have been cleaned - run setup again.
if not os.path.exists('build/llvm/'):
print 'Missing LLVM, running setup...'
shell_call('python xenia-build.py setup')
print ''
print 'Building %s...' % (config)
print ''
print '- running gyp for ninja...'
run_gyp('ninja')
print ''
print '- building xenia in %s...' % (config)
result = shell_call('third_party/ninja/ninja -C build/xenia/%s' % (config),
throw_on_error=False)
print ''
if result != 0:
return result
print 'Success!'
return 0
class TestCommand(Command):
"""'test' command."""
def __init__(self, *args, **kwargs):
super(TestCommand, self).__init__(
name='test',
help_short='Runs all tests.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Testing...'
print ''
# First run make and update all of the test files.
# TOOD(benvanik): disable on Windows
print 'Updating test files...'
result = shell_call('make -C test/codegen/')
print ''
if result != 0:
return result
# Start the test runner.
print 'Launching test runner...'
result = shell_call('bin/xenia-test')
print ''
return result
class XethunkCommand(Command):
"""'xethunk' command."""
def __init__(self, *args, **kwargs):
super(XethunkCommand, self).__init__(
name='xethunk',
help_short='Updates the xethunk.bc file.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Building xethunk...'
print ''
path = 'src/cpu/xethunk/xethunk'
result = shell_call('clang -emit-llvm -O0 -c %s.c -o %s.bc' % (path, path),
throw_on_error=False)
if result != 0:
return result
shell_call('build/llvm/release/bin/llvm-dis %s.bc -o %s.ll' % (path, path))
shell_call('cat %s.ll' % (path))
print 'Success!'
return 0
class CleanCommand(Command):
"""'clean' command."""
def __init__(self, *args, **kwargs):
super(CleanCommand, self).__init__(
name='clean',
help_short='Removes intermediate files and build output.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Cleaning build artifacts...'
print ''
print '- removing build/xenia/...'
if os.path.isdir('build/xenia/'):
shutil.rmtree('build/xenia/')
print ''
print 'Success!'
return 0
class NukeCommand(Command):
"""'nuke' command."""
def __init__(self, *args, **kwargs):
super(NukeCommand, self).__init__(
name='nuke',
help_short='Removes all build/ output.',
*args, **kwargs)
def execute(self, args, cwd):
print 'Cleaning build artifacts...'
print ''
print '- removing build/...'
if os.path.isdir('build/'):
shutil.rmtree('build/')
print ''
print 'Success!'
return 0
if __name__ == '__main__':
main()
Reference in New Issue View Git Blame Copy Permalink