def update(self, fname):
if os.path.exists(fname) and not GetOption("silent") and not env.GetOption("help"):
print "Restoring previous command-line options from '%s'" % fname
vars = Variables(fname, self.opts)
vars.AddVariables(*self.variables)
vars.Update(env)
vars.Save(fname, env)
def generate(env):
params = Variables(env['PARAMETER_SOURCE'], ARGUMENTS)
params.Add(EnumVariable('crosscompile', 'Enable cross compile', 'no', ['no', 'android', 'mingw', 'gcc']))
params.Update(env)
configGroup = None
try:
configReport = env.configReport
configGroup = 'Cross-Compile'
configReport.add('Enable cross compile', crosscompile, configGroup)
except:
pass
env.SetDefault(CROSSCOMPILE_CFLAGS = '')
env.SetDefault(CROSSCOMPILE_CPPFLAGS = '')
env.SetDefault(CROSSCOMPILE_CXXFLAGS = '')
env.SetDefault(CROSSCOMPILE_LINKFLAGS = '')
env.SetDefault(CROSSCOMPILE_LIBS = '')
env.SetDefault(CROSSCOMPILE_PROGRAM_LIBS = '')
if env['crosscompile'] == 'android':
android.generate(env, configGroup)
elif env['crosscompile'] == 'mingw':
mingw.generate(env, configGroup)
elif env['crosscompile'] == 'gcc':
gcc.generate(env, configGroup)
def update(self, fname='options.cache'):
if os.path.exists(fname) and not GetOption("silent") and\
not GetOption("help"):
print """Note: Restoring previous command-line options from '%s'.
Please delete this file when trying to start from scratch.""" % fname
vars = Variables(fname, self.opts)
vars.AddVariables(*self.variables)
vars.Update(self.env)
vars.Save(fname, self.env)
def Update(self, env, args=None):
self.unknown = {}
_Base.Update(self, env, args)
# Remember all known variables as being updated (even those with
# default value of None and no specified value that have not been
# changed). A variable updated in a cloned environment is not
# automatically considered udpated in the parent environment, but
# a value updated in the parent environment before being cloned will
# be considered updated in the cloned environment.
env['_UPDATED_VARIABLES_'] = [option.key for option in self.options]
def generate(env, configGroup):
# add parameters to configurate toolchain
params = Variables(env['PARAMETER_SOURCE'], ARGUMENTS)
params.Add(('gcc_compiler', 'GCC cross compiler prefix', ''))
params.Add(('gcc_cppflags', 'GCC cross compiler cpp flags', ''))
params.Add(('gcc_linkflags', 'GCC cross compiler link flags', ''))
params.Add(
PathVariable('gcc_sysroot', 'GCC cross compiler system root', '',
PathVariable.Accept))
params.Update(env)
try:
configReport = env.configReport
configReport.add('GCC cross compiler prefix', 'gcc_compiler',
configGroup)
configReport.add('GCC cross compiler cpp flags', 'gcc_cppflags',
configGroup)
configReport.add('GCC cross compiler link flags', 'gcc_linkflags',
configGroup)
configReport.add('GCC cross compiler system root', 'gcc_sysroot',
configGroup)
except:
pass
# get configuration parameters
compiler = env.subst(env['gcc_compiler'])
sysroot = env.subst(env['gcc_sysroot'])
cppflags = env['gcc_cppflags']
env['CC'] = compiler + 'gcc'
env['CXX'] = compiler + 'g++'
env['LD'] = compiler + 'ld'
env['STRIP'] = compiler + 'strip'
env['OBJCOPY'] = compiler + 'objcopy'
env['AS'] = compiler + 'as'
env['AR'] = compiler + 'ar'
env['RANLIB'] = compiler + 'ranlib'
env.Append(CROSSCOMPILE_CPPFLAGS=cppflags)
env.Append(CROSSCOMPILE_LINKFLAGS=linkflags)
env.Append(CROSSCOMPILE_CPPFLAGS=['--sysroot={}'.format(sysroot)])
env.Append(CROSSCOMPILE_LINKFLAGS=['--sysroot={}'.format(sysroot)])
# apply cross compile flags to build environment
env.Append(CFLAGS=env['CROSSCOMPILE_CFLAGS'])
env.Append(CPPFLAGS=env['CROSSCOMPILE_CPPFLAGS'])
env.Append(CXXFLAGS=env['CROSSCOMPILE_CXXFLAGS'])
env.Append(LINKFLAGS=env['CROSSCOMPILE_LINKFLAGS'])
def Update(self, env):
print("required options are: ", self.required)
SVariables.Update(self, env)
for requirement in self.required:
if not env.has_key(requirement):
print('violation: ', requirement)
def generate(env, configGroup):
# add parameters to configurate toolchain
params = Variables(env['PARAMETER_SOURCE'], ARGUMENTS)
params.Add(
PathVariable(
'android_ndkroot',
'Path to Android NDK toolchain (NDK_ROOT env-param by default)',
os.path.expanduser(os.environ['NDK_ROOT']),
PathVariable.PathAccept))
params.Add(
EnumVariable('android_arch', 'Android architecture to build for',
'armv7a', ['armv7', 'armv7a', 'armv8', 'x86', 'x86_64']))
params.Add(('android_apilevel', 'Android API level', '18'))
params.Add(('android_gccversion', 'Android NDK GCC version', '4.9'))
params.Update(env)
try:
configReport = env.configReport
configReport.add('Path to Android NDK toolchain', 'android_ndkroot',
configGroup)
configReport.add('Android architecture to build for', 'android_arch',
configGroup)
configReport.add('Android API level', 'android_apilevel', configGroup)
configReport.add('Android NDK GCC version', 'android_gccversion',
configGroup)
except:
pass
# get configuration parameters
ndkroot = env.subst(env['android_ndkroot'])
arch = env['android_arch']
apilevel = env['android_apilevel']
gccVersion = env['android_gccversion']
# set construction variables
stlsupport = 'gnu-libstdc++'
if env['android_arch'] == 'armv7':
abi = 'androideabi'
fullarch = 'armeabi-v7'
hardfp = False
elif env['android_arch'] == 'armv7a':
abi = 'androideabi'
fullarch = 'armeabi-v7a'
hardfp = True
elif env['android_arch'] == 'armv8':
abi = 'androideabi'
fullarch = 'armeabi-v8'
hardfp = True
elif env['android_arch'] == 'x86':
abi = 'android'
fullarch = 'x86'
hardfp = False
elif env['android_arch'] == 'x86_64':
abi = 'android'
fullarch = 'x86_64'
hardfp = False
else:
raise Exception('Invalid architecture {}'.format(env['android_arch']))
compilerPrefix = '{}-{}-{}{}-'.format(arch,
platform.system().lower(), abi,
apilevel)
compilerPrefix2 = '{}-{}-{}-'.format(arch, platform.system().lower(), abi)
pathToolchain = os.path.join(
ndkroot, 'toolchains', 'llvm', 'prebuilt',
'-'.join([platform.system().lower(),
platform.machine()]))
env['ANDROID_TOOLCHAIN'] = pathToolchain
pathBin = os.path.join(pathToolchain, 'bin')
env['ANDROID_BIN'] = pathBin
compiler = os.path.join(pathBin, compilerPrefix)
compiler2 = os.path.join(pathBin, compilerPrefix2)
env['ANDROID_COMPILER'] = compiler
env['ANDROID_FULLARCH'] = fullarch
env['ANDROID_HARDFP'] = hardfp
env['CC'] = compiler + 'clang'
env['CXX'] = compiler + 'clang++'
env['LD'] = compiler2 + 'ld'
env['STRIP'] = compiler2 + 'strip'
env['OBJCOPY'] = compiler2 + 'objcopy'
env['AS'] = compiler2 + 'as'
env['AR'] = compiler2 + 'ar'
env['RANLIB'] = compiler2 + 'ranlib'
env['NASM'] = compiler2 + 'yasm'
# libraries to link against required for libraries and binaries to load on android.
# additional libraries can be required. android is in general quite picky about
# these libraries and the loading order
env.Append(CROSSCOMPILE_IBS=['m', 'z', 'log', 'c', 'android'])
# libs.append( 'gnustl_static' ) # stl support using static gnustl
env.Append(CROSSCOMPILE_CPPFLAGS=[
'-O3'
]) # default is -O2 so try to squeeze out a bit more speed if possible
# hardware floating point support
if hardfp:
env.Append(CROSSCOMPILE_CPPFLAGS=['-D_NDK_MATH_NO_SOFTFP=1'])
# apply cross compile flags to build environment
env.Append(LIBS=env['CROSSCOMPILE_LIBS'])
env.Append(CFLAGS=env['CROSSCOMPILE_CFLAGS'])
env.Append(CPPFLAGS=env['CROSSCOMPILE_CPPFLAGS'])
env.Append(CXXFLAGS=env['CROSSCOMPILE_CXXFLAGS'])
env.Append(LINKFLAGS=env['CROSSCOMPILE_LINKFLAGS'])
from eiffel_loop.eiffel import project
from eiffel_loop.eiffel.ecf import EIFFEL_CONFIG_FILE
from eiffel_loop.eiffel.ecf import FREEZE_BUILD
from SCons.Environment import Base
from SCons.Variables import Variables
from glob import glob
var = Variables()
var.Add('cpu', '', 'x64')
var.Add('project', '', glob('*.ecf')[0])
os.environ['ISE_LIBRARY'] = os.environ['ISE_EIFFEL']
env = Base()
var.Update(env)
env.Append(ENV=os.environ)
env.Append(ISE_PLATFORM=os.environ['ISE_PLATFORM'])
project_py = project.read_project_py()
project_py.set_build_environment(env.get('cpu'))
ecf_path = env.get('project')
config = EIFFEL_CONFIG_FILE(ecf_path)
build = FREEZE_BUILD(config, project_py)
build.install_resources(build.resources_destination())
'HOME' : os.environ[ 'HOME' ] },
toolpath = [askaptoolpath],
tools = ['default', 'askap_package', 'doxybuilder',
'functestbuilder', 'icebuilder', 'cloptions' ]
)
# Importing TERM allows programs (such as clang) to produce colour output
# if the terminal supports it
if 'TERM' in os.environ:
env['ENV']['TERM'] = os.environ['TERM']
opts = Variables('sconsopts.cfg', ARGUMENTS)
opts.Add(BoolVariable("nompi", "Disable MPI", False))
opts.Add(BoolVariable("openmp", "Use OpenMP", False))
opts.Add(BoolVariable("update", "svn update?", False))
opts.Update(env)
# Standard compiler flags
env.AppendUnique(CCFLAGS=['-Wall'])
env.AppendUnique(CCFLAGS=['-O2'])
env.AppendUnique(CCFLAGS=['-g'])
env.AppendUnique(CCFLAGS=['-DASKAP_DEBUG'])
# If the system has environment modules support we need to import
# the whole environment
if has_environment_modules():
env["ENV"] = os.environ
# Support setting of "RBUILD_NOMPI" in the environment, because forgetting
# to pass nompi=1 on the command line is a common error
if os.environ.has_key('RBUILD_NOMPI') and os.environ['RBUILD_NOMPI'] == '1':
