def create_custom_builders(env):
def generate_so_name(target, source, env):
source_dir = os.path.dirname(str(source[0]))
cwd = os.getcwd()
os.chdir(source_dir)
if sys.platform == 'linux2':
os.system("/sbin/ldconfig -n .")
os.chdir(cwd)
return None
bld = env.Builder(
action=Action(generate_so_name, "== Generating soname $TARGET"))
env.Append(BUILDERS={'SonameLink': bld})
def generate_linker_name(target, source, env):
source_file = os.path.basename(str(source[0]))
os.system("ln -sf %s %s" % (source_file, str(target[0])))
return None
bld = env.Builder(action=Action(
generate_linker_name, "== Generating linker name $TARGET to $SOURCE"))
env.Append(BUILDERS={'LinkerNameLink': bld})
import shutil
bld = env.Builder(action=Action(
lambda target, source, env: shutil.copy(str(source[0]), str(target[0])
), "== Build copying $SOURCE"))
env.Append(BUILDERS={'CopyFileAndUpdateIncludes': bld})
def BlenderProg(self=None, builddir=None, progname=None, sources=None, libs=None, libpath=None, binarykind=''):
global vcp
print bc.HEADER+'Configuring program '+bc.ENDC+bc.OKGREEN+progname+bc.ENDC
lenv = self.Clone()
lenv.Append(LINKFLAGS = lenv['PLATFORM_LINKFLAGS'])
if lenv['OURPLATFORM'] in ('win32-vc', 'cygwin', 'win64-vc'):
if lenv['BF_DEBUG']:
lenv.Prepend(LINKFLAGS = ['/DEBUG','/PDB:'+progname+'.pdb','/NODEFAULTLIB:libcmt'])
if lenv['OURPLATFORM']=='linux':
if lenv['WITH_BF_PYTHON']:
lenv.Append(LINKFLAGS = lenv['BF_PYTHON_LINKFLAGS'])
if lenv['OURPLATFORM']=='sunos5':
if lenv['WITH_BF_PYTHON']:
lenv.Append(LINKFLAGS = lenv['BF_PYTHON_LINKFLAGS'])
if lenv['CXX'].endswith('CC'):
lenv.Replace(LINK = '$CXX')
if lenv['OURPLATFORM']=='darwin':
if lenv['WITH_BF_PYTHON']:
lenv.Append(LINKFLAGS = lenv['BF_PYTHON_LINKFLAGS'])
lenv.Append(LINKFLAGS = lenv['BF_OPENGL_LINKFLAGS'])
if lenv['BF_PROFILE']:
lenv.Append(LINKFLAGS = lenv['BF_PROFILE_LINKFLAGS'])
if root_build_dir[0]==os.sep or root_build_dir[1]==':':
lenv.Append(LIBPATH=root_build_dir + '/lib')
lenv.Append(LIBPATH=libpath)
lenv.Append(LIBS=libs)
if lenv['WITH_BF_QUICKTIME']:
lenv.Append(LIBS = lenv['BF_QUICKTIME_LIB'])
lenv.Append(LIBPATH = lenv['BF_QUICKTIME_LIBPATH'])
prog = lenv.Program(target=builddir+'bin/'+progname, source=sources)
if lenv['BF_DEBUG'] and lenv['OURPLATFORM'] in ('win32-vc', 'win64-vc') and lenv['BF_BSC']:
f = lenv.File(progname + '.bsc', builddir)
brs = lenv.Command(f, prog, [bsc])
SConsEnvironment.Default(self, brs)
SConsEnvironment.Default(self, prog)
if self['BF_MSVS'] and self['OURPLATFORM'] in ('win32-vc', 'win64-vc') and progname == 'blender':
print "! ",builddir + "/" + progname + '.sln'
sln = self.MSVSProject(target = builddir + "/" + progname + '.sln',
projects= vcp,
variant = 'Release')
SConsEnvironment.Default(self, sln)
program_list.append(prog)
if lenv['OURPLATFORM']=='darwin':
lenv['BINARYKIND'] = binarykind
lenv.AddPostAction(prog,Action(AppIt,strfunction=my_appit_print))
elif os.sep == '/' and lenv['OURPLATFORM'] != 'linuxcross': # any unix (except cross-compilation)
if lenv['WITH_BF_PYTHON']:
if not lenv['WITHOUT_BF_INSTALL'] and not lenv['WITHOUT_BF_PYTHON_INSTALL'] and not BlenderEnvironment.PyBundleActionAdded:
lenv.AddPostAction(prog,Action(UnixPyBundle,strfunction=my_unixpybundle_print))
BlenderEnvironment.PyBundleActionAdded = True
elif lenv['OURPLATFORM'].startswith('win') or lenv['OURPLATFORM'] == 'linuxcross': # windows or cross-compilation
if lenv['WITH_BF_PYTHON']:
if not lenv['WITHOUT_BF_PYTHON_INSTALL'] and not BlenderEnvironment.PyBundleActionAdded:
lenv.AddPostAction(prog,Action(WinPyBundle,strfunction=my_winpybundle_print))
BlenderEnvironment.PyBundleActionAdded = True
return prog
def set_quiet_output(env):
mycaction = Action("$CCCOM", strfunction=my_compile_print)
myshcaction = Action("$SHCCCOM", strfunction=my_compile_print)
mycppaction = Action("$CXXCOM", strfunction=my_compile_print)
myshcppaction = Action("$SHCXXCOM", strfunction=my_compile_print)
mylibaction = Action("$ARCOM", strfunction=my_linking_print)
mylinkaction = Action("$LINKCOM", strfunction=my_program_print)
static_ob, shared_ob = SCons.Tool.createObjBuilders(env)
static_ob.add_action('.c', mycaction)
static_ob.add_action('.cpp', mycppaction)
static_ob.add_action('.cc', mycppaction)
shared_ob.add_action('.c', myshcaction)
shared_ob.add_action('.cc', myshcppaction)
static_lib = SCons.Builder.Builder(action=mylibaction,
emitter='$LIBEMITTER',
prefix='$LIBPREFIX',
suffix='$LIBSUFFIX',
src_suffix='$OBJSUFFIX',
src_builder='StaticObject')
program = SCons.Builder.Builder(action=mylinkaction,
emitter='$PROGEMITTER',
prefix='$PROGPREFIX',
suffix='$PROGSUFFIX',
src_suffix='$OBJSUFFIX',
src_builder='Object',
target_scanner=SCons.Defaults.ProgScan)
env['BUILDERS']['Object'] = static_ob
env['BUILDERS']['StaticObject'] = static_ob
env['BUILDERS']['StaticLibrary'] = static_lib
env['BUILDERS']['Library'] = static_lib
env['BUILDERS']['Program'] = program
if env['BF_LINE_OVERWRITE']:
SCons.Action._ActionAction.print_cmd_line = my_print_cmd_line
# Done.
os.system("rm -rf " + temp)
list.close()
#
# Output a user friendly command.
#
def generateISOstr(target, source, env):
return " ISO " + str(target[0])
#
# Create the ISO builder.
#
isoBuilder = Builder(action = Action(generateISO, generateISOstr),
suffix = '.iso',
src_suffix = '.isodesc')
target.Append(BUILDERS = { 'ISO' : isoBuilder })
#
# Instructs to build an ISO and MD5+SHA1 checksums.
#
isoImage = target.ISO('#boot/AmayaOS-0.1-alpha3-x86.iso', ['#boot/boot.isodesc'])
isoImageMd5 = target.Checksum('#boot/boot.iso.md5', '#boot/boot.iso')
isoImageSha1 = target.Checksum('#boot/boot.iso.sha1', '#boot/boot.iso')
#
# Dependencies and target aliases.
#
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
print("Loading qt5 tool...")
def locateQt5Command(env, command, qtdir):
fullpath1 = os.path.join(qtdir, 'bin', command + '-qt5')
if (os.access(fullpath1, os.X_OK)
or os.access(fullpath1 + ".exe", os.X_OK)):
return fullpath1
fullpath3 = os.path.join(qtdir, 'bin', command + '5')
if (os.access(fullpath3, os.X_OK)
or os.access(fullpath3 + ".exe", os.X_OK)):
return fullpath3
fullpath2 = os.path.join(qtdir, 'bin', command)
if (os.access(fullpath2, os.X_OK)
or os.access(fullpath2 + ".exe", os.X_OK)):
return fullpath2
fullpath = env.Detect([command + '-qt5', command + '5', command])
if not (fullpath is None):
return fullpath
raise Exception("Qt4 command '" + command + "' not found. Tried: " +
fullpath1 + " and " + fullpath2)
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
splitext = SCons.Util.splitext
env['QTDIR'] = _detect(env)
# TODO: 'Replace' should be 'SetDefault'
# env.SetDefault(
env.Replace(
QTDIR=_detect(env),
QT5_BINPATH=os.path.join('$QTDIR', 'bin'),
QT5_CPPPATH=os.path.join('$QTDIR', 'include'),
QT5_LIBPATH=os.path.join('$QTDIR', 'lib'),
# TODO: This is not reliable to QTDIR value changes but needed in order to support '-qt4' variants
QT5_MOC=locateQt5Command(env, 'moc', env['QTDIR']),
QT5_UIC=locateQt5Command(env, 'uic', env['QTDIR']),
QT5_RCC=locateQt5Command(env, 'rcc', env['QTDIR']),
QT5_LUPDATE=locateQt5Command(env, 'lupdate', env['QTDIR']),
QT5_LRELEASE=locateQt5Command(env, 'lrelease', env['QTDIR']),
QT5_LIB='', # KLUDGE to avoid linking qt3 library
QT5_AUTOSCAN=
1, # Should the qt tool try to figure out, which sources are to be moc'ed?
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT5_UICFLAGS=CLVar(''),
QT5_MOCFROMHFLAGS=CLVar(''),
QT5_MOCFROMCXXFLAGS=CLVar('-i'),
QT5_QRCFLAGS='',
# suffixes/prefixes for the headers / sources to generate
QT5_UISUFFIX='.ui',
QT5_UICDECLPREFIX='ui_',
QT5_UICDECLSUFFIX='.h',
QT5_MOCHPREFIX='moc_',
QT5_MOCHSUFFIX='$CXXFILESUFFIX',
QT5_MOCCXXPREFIX='moc_',
QT5_MOCCXXSUFFIX='.moc',
QT5_QRCSUFFIX='.qrc',
QT5_QRCCXXSUFFIX='$CXXFILESUFFIX',
QT5_QRCCXXPREFIX='qrc_',
# Commands for the qt support ...
QT5_UICCOM='$QT5_UIC $QT5_UICFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMHCOM='$QT5_MOC $QT5_MOCFROMHFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMCXXCOM=[
'$QT5_MOC $QT5_MOCFROMCXXFLAGS -o $TARGET $SOURCE',
Action(checkMocIncluded, None)
],
QT5_LUPDATECOM='$QT5_LUPDATE $SOURCE -ts $TARGET',
QT5_LRELEASECOM='$QT5_LRELEASE $SOURCE',
QT5_RCCCOM='$QT5_RCC $QT5_QRCFLAGS $SOURCE -o $TARGET',
)
# Translation builder
tsbuilder = Builder(
action=SCons.Action.Action(
'$QT5_LUPDATECOM'), #,'$QT5_LUPDATECOMSTR'),
multi=1)
env.Append(BUILDERS={'Ts': tsbuilder})
qmbuilder = Builder(
action=SCons.Action.Action(
'$QT5_LRELEASECOM'), # , '$QT5_LRELEASECOMSTR'),
src_suffix='.ts',
suffix='.qm',
single_source=True)
env.Append(BUILDERS={'Qm': qmbuilder})
# Resource builder
def scanResources(node, env, path, arg):
contents = node.get_contents()
includes = qrcinclude_re.findall(contents)
return includes
qrcscanner = SCons.Scanner.Scanner(name='qrcfile',
function=scanResources,
argument=None,
skeys=['.qrc'])
qrcbuilder = Builder(
action=SCons.Action.Action('$QT5_RCCCOM'), #, '$QT5_RCCCOMSTR'),
source_scanner=qrcscanner,
src_suffix='$QT5_QRCSUFFIX',
suffix='$QT5_QRCCXXSUFFIX',
prefix='$QT5_QRCCXXPREFIX',
single_source=True)
env.Append(BUILDERS={'Qrc': qrcbuilder})
# Interface builder
uic5builder = Builder(
action=SCons.Action.Action('$QT5_UICCOM'), #, '$QT5_UICCOMSTR'),
src_suffix='$QT5_UISUFFIX',
suffix='$QT5_UICDECLSUFFIX',
prefix='$QT5_UICDECLPREFIX',
single_source=True
#TODO: Consider the uiscanner on new scons version
)
env.Append(BUILDERS={'Uic5': uic5builder})
# Metaobject builder
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.Action(
'$QT5_MOCFROMHCOM') #, '$QT5_MOCFROMHCOMSTR')
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT5_MOCHPREFIX'
mocBld.suffix[h] = '$QT5_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.Action(
'$QT5_MOCFROMCXXCOM') #, '$QT5_MOCFROMCXXCOMSTR')
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT5_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT5_MOCCXXSUFFIX'
env.Append(BUILDERS={'Moc5': mocBld})
# er... no idea what that was for
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.src_builder.append('Uic5')
shared_obj.src_builder.append('Uic5')
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(
PROGEMITTER=[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER=[AutomocStatic],
# Of course, we need to link against the qt libraries
CPPPATH=["$QT5_CPPPATH"],
LIBPATH=["$QT5_LIBPATH"],
LIBS=['$QT5_LIB'])
#import new
#method = new.instancemethod(enable_modules, env, SCons.Environment)
#env.EnableQt4Modules=method
SConsEnvironment.EnableQt5Modules = enable_modules
SConsEnvironment.EnableQtModules = enable_modules
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
env.SetDefault(
QTDIR=_detect(env),
QT_BINPATH=os.path.join('$QTDIR', 'bin'),
QT_CPPPATH=os.path.join('$QTDIR', 'include'),
QT_LIBPATH=os.path.join('$QTDIR', 'lib'),
QT_MOC=os.path.join('$QT_BINPATH', 'moc'),
QT_UIC=os.path.join('$QT_BINPATH', 'uic'),
QT_LIB='qt', # may be set to qt-mt
QT_AUTOSCAN=1, # scan for moc'able sources
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT_UICIMPLFLAGS=CLVar(''),
QT_UICDECLFLAGS=CLVar(''),
QT_MOCFROMHFLAGS=CLVar(''),
QT_MOCFROMCXXFLAGS=CLVar('-i'),
# suffixes/prefixes for the headers / sources to generate
QT_UICDECLPREFIX='',
QT_UICDECLSUFFIX='.h',
QT_UICIMPLPREFIX='uic_',
QT_UICIMPLSUFFIX='$CXXFILESUFFIX',
QT_MOCHPREFIX='moc_',
QT_MOCHSUFFIX='$CXXFILESUFFIX',
QT_MOCCXXPREFIX='',
QT_MOCCXXSUFFIX='.moc',
QT_UISUFFIX='.ui',
# Commands for the qt support ...
# command to generate header, implementation and moc-file
# from a .ui file
QT_UICCOM=[
CLVar('$QT_UIC $QT_UICDECLFLAGS -o ${TARGETS[0]} $SOURCE'),
CLVar('$QT_UIC $QT_UICIMPLFLAGS -impl ${TARGETS[0].file} '
'-o ${TARGETS[1]} $SOURCE'),
CLVar('$QT_MOC $QT_MOCFROMHFLAGS -o ${TARGETS[2]} ${TARGETS[0]}')
],
# command to generate meta object information for a class
# declarated in a header
QT_MOCFROMHCOM=('$QT_MOC $QT_MOCFROMHFLAGS -o ${TARGETS[0]} $SOURCE'),
# command to generate meta object information for a class
# declarated in a cpp file
QT_MOCFROMCXXCOM=[
CLVar('$QT_MOC $QT_MOCFROMCXXFLAGS -o ${TARGETS[0]} $SOURCE'),
Action(checkMocIncluded, None)
])
# ... and the corresponding builders
uicBld = Builder(action=SCons.Action.Action('$QT_UICCOM', '$QT_UICCOMSTR'),
emitter=uicEmitter,
src_suffix='$QT_UISUFFIX',
suffix='$QT_UICDECLSUFFIX',
prefix='$QT_UICDECLPREFIX',
source_scanner=uicScanner)
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.Action('$QT_MOCFROMHCOM', '$QT_MOCFROMHCOMSTR')
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT_MOCHPREFIX'
mocBld.suffix[h] = '$QT_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.Action('$QT_MOCFROMCXXCOM', '$QT_MOCFROMCXXCOMSTR')
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT_MOCCXXSUFFIX'
# register the builders
env['BUILDERS']['Uic'] = uicBld
env['BUILDERS']['Moc'] = mocBld
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.add_src_builder('Uic')
shared_obj.add_src_builder('Uic')
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(
PROGEMITTER=[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER=[AutomocStatic],
# Of course, we need to link against the qt libraries
CPPPATH=["$QT_CPPPATH"],
LIBPATH=["$QT_LIBPATH"],
LIBS=['$QT_LIB'])
def BuildProgram(env):
def _append_pio_macros():
env.AppendUnique(CPPDEFINES=[("PLATFORMIO",
int("{0:02d}{1:02d}{2:02d}".format(
*pioversion_to_intstr())))])
_append_pio_macros()
env.PrintConfiguration()
# fix ASM handling under non case-sensitive OS
if not Util.case_sensitive_suffixes(".s", ".S"):
env.Replace(AS="$CC", ASCOM="$ASPPCOM")
if "__debug" in COMMAND_LINE_TARGETS:
env.ProcessDebug()
# process extra flags from board
if "BOARD" in env and "build.extra_flags" in env.BoardConfig():
env.ProcessFlags(env.BoardConfig().get("build.extra_flags"))
# remove base flags
env.ProcessUnFlags(env.get("BUILD_UNFLAGS"))
# apply user flags
env.ProcessFlags(env.get("BUILD_FLAGS"))
# process framework scripts
env.BuildFrameworks(env.get("PIOFRAMEWORK"))
# restore PIO macros if it was deleted by framework
_append_pio_macros()
# build dependent libs; place them before built-in libs
env.Prepend(LIBS=env.BuildProjectLibraries())
# append specified LD_SCRIPT
if ("LDSCRIPT_PATH" in env
and not any("-Wl,-T" in f for f in env['LINKFLAGS'])):
env.Append(LINKFLAGS=['-Wl,-T"$LDSCRIPT_PATH"'])
# enable "cyclic reference" for linker
if env.get("LIBS") and env.GetCompilerType() == "gcc":
env.Prepend(_LIBFLAGS="-Wl,--start-group ")
env.Append(_LIBFLAGS=" -Wl,--end-group")
# Handle SRC_BUILD_FLAGS
env.ProcessFlags(env.get("SRC_BUILD_FLAGS"))
env.Append(LIBPATH=["$BUILD_DIR"],
PIOBUILDFILES=env.CollectBuildFiles(
"$BUILDSRC_DIR",
"$PROJECTSRC_DIR",
src_filter=env.get("SRC_FILTER"),
duplicate=False))
if "__test" in COMMAND_LINE_TARGETS:
env.Append(PIOBUILDFILES=env.ProcessTest())
if not env['PIOBUILDFILES'] and not COMMAND_LINE_TARGETS:
sys.stderr.write(
"Error: Nothing to build. Please put your source code files "
"to '%s' folder\n" % env.subst("$PROJECTSRC_DIR"))
env.Exit(1)
program = env.Program(join("$BUILD_DIR", env.subst("$PROGNAME")),
env['PIOBUILDFILES'])
checksize_action = Action.Action(env.CheckUploadSize,
"Checking program size")
AlwaysBuild(env.Alias("checkprogsize", program, checksize_action))
if set(["upload", "program"]) & set(COMMAND_LINE_TARGETS):
env.AddPostAction(program, checksize_action)
return program
#
def generateBootImage(target, source, env):
# Use the host compiled 'img' program.
os.system("sbin/img/img " + str(source[0]) + " " + str(target[0]))
os.system("gzip -fq '" + str(target[0]) + "'")
#
# Output user friendly command.
#
def generateBootImageStr(target, source, env):
return " IMG " + str(target[0])
#
# Create boot image builder.
#
imgBuilder = Builder(action = Action(generateBootImage, generateBootImageStr),
suffix = '.img',
src_suffix = '.imgdesc')
target.Append(BUILDERS = { 'Img' : imgBuilder })
#
# Define dependencies and targets.
#
img = target.Img('boot/boot.img', ['boot/boot.imgdesc'])
target.Clean(img, '#boot/boot.img.gz')
Depends(img, ['bin', 'lib', 'kernel', 'sbin', 'srv'])
AlwaysBuild(img)
def SetupBuildEnv(env, progress, prog_type, prog_name, source_files, build_dir,
install_dir):
build_env = env.Clone()
# build_env.Execute(Mkdir(install_dir))
build_env['PROJECT_DIR'] = build_env.get('PROJECT_DIR',
build_env.Dir('.').abspath)
build_env['TEMPFILE'] = TempFileMungeOutput
build_env['TEMPFILEBUILDDIR'] = build_dir
build_env['TEMPFILEPROGNAME'] = prog_name
header_files = []
if prog_type == "unit":
temp = []
for source in source_files:
temp.append(source.replace(".h", ".c"))
header_files = source_files
source_files = temp
win_redirect = ""
linux_redirect = "2>&1"
if sys.platform == 'win32':
win_redirect = "2>&1"
linux_redirect = ""
# clear out all previous build compile logs
build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs"
import os
for root, dirs, files in os.walk(build_env['PROJECT_DIR'] + "/" +
build_dir + "/build_logs"):
for name in files:
if name.endswith('.txt'):
#os.unlink(os.path.join(root, name))
pass
source_objs = []
source_build_files = []
for file in source_files:
build_env.VariantDir(build_dir + "/" + os.path.dirname(file),
os.path.dirname(file),
duplicate=0)
file = build_dir + "/" + file
source_build_files.append(file)
if (prog_type == 'shared'):
build_obj = build_env.SharedObject(
file,
SHCCCOM=build_env['SHCCCOM'] + " " + win_redirect + " > \"" +
build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs/" +
os.path.splitext(os.path.basename(file))[0] +
"_compile.txt\" " + linux_redirect,
SHCXXCOM=build_env['SHCXXCOM'] + " " + win_redirect + " > \"" +
build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs/" +
os.path.splitext(os.path.basename(file))[0] +
"_compile.txt\" " + linux_redirect)
source_objs.append(build_obj)
elif (prog_type == 'static' or prog_type == 'exec'):
filename = os.path.splitext(os.path.basename(file))[0]
build_obj = build_env.Object(
file,
CCCOM=build_env['CCCOM'] + " " + win_redirect + " > \"" +
build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs/" +
filename + "_compile.txt\" " + linux_redirect,
CXXCOM=build_env['CXXCOM'] + " " + win_redirect + " > \"" +
build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs/" +
filename + "_compile.txt\" " + linux_redirect)
source_objs.append(build_obj)
if prog_type == 'shared':
progress.AddBuild(
env, source_build_files,
env.subst('$SHLIBPREFIX') + prog_name + env.subst('$SHLIBSUFFIX'))
elif prog_type == 'static':
progress.AddBuild(
env, source_build_files,
env.subst('$LIBPREFIX') + prog_name + env.subst('$LIBSUFFIX'),
True)
elif prog_type == 'exec' or prog_type == 'unit':
progress.AddBuild(
env, source_build_files,
env.subst('$PROGPREFIX') + prog_name + env.subst('$PROGSUFFIX'))
if (prog_type == 'shared'):
if sys.platform != 'win32':
linkcom_string_match = re.sub(r"\s\>\".*", "\",",
build_env['SHLINKCOM'])
build_env['SHLINKCOM'] = linkcom_string_match + str(
" > " + build_env['PROJECT_DIR'] + "/" + build_dir +
"/build_logs/" + prog_name + "_link.txt 2>&1")
elif (prog_type == 'static' or prog_type == 'exec' or prog_type == 'unit'):
if sys.platform != 'win32':
linkcom_string_match = re.sub(r"\s\>\".*", "\",",
build_env['LINKCOM'])
build_env['LINKCOM'] = linkcom_string_match + str(
" > " + build_env['PROJECT_DIR'] + "/" + build_dir +
"/build_logs/" + prog_name + "_link.txt 2>&1")
if (prog_type == "shared"):
prog = build_env.SharedLibrary(
build_env['PROJECT_DIR'] + "/" + build_dir + "/" + prog_name,
source_objs)
if type(prog) is NodeList:
prog_build_name = os.path.basename(prog[0].abspath)
else:
prog_build_name = os.path.basename(prog.abspath)
build_env.AlwaysBuild(
build_env.Command(install_dir + '/' + prog_build_name, prog,
Copy('$TARGET', '$SOURCE')))
elif (prog_type == "static"):
prog = build_env.StaticLibrary(
build_env['PROJECT_DIR'] + "/" + build_dir + "/" + prog_name,
source_objs)
if type(prog) is NodeList:
prog_build_name = os.path.basename(prog[0].abspath)
else:
prog_build_name = os.path.basename(prog.abspath)
build_env.AlwaysBuild(
build_env.Command(install_dir + '/' + prog_build_name, prog,
Copy('$TARGET', '$SOURCE')))
elif (prog_type == 'exec'):
prog = build_env.Program(
build_env['PROJECT_DIR'] + "/" + build_dir + "/" + prog_name,
source_objs)
if type(prog) is NodeList:
prog_build_name = os.path.basename(prog[0].abspath)
else:
prog_build_name = os.path.basename(prog.abspath)
build_env.AlwaysBuild(
build_env.Command(install_dir + '/' + prog_build_name, prog,
Copy('$TARGET', '$SOURCE')))
elif (prog_type == 'unit'):
prog = build_env.CxxTest(build_env['PROJECT_DIR'] + "/" + build_dir +
"/" + prog_name,
header_files,
CXXTEST_RUNNER="ErrorPrinter",
CXXTEST_OPTS="--world=" + prog_name)
for exe in prog:
if os.path.basename(os.path.splitext(str(exe))[0]) == prog_name:
for node in exe.children():
if os.path.basename(os.path.splitext(
str(node))[0]) == prog_name:
if sys.platform != 'win32':
node.get_executor().set_action_list(
Action.Action(
'$CXX -o $TARGET -c $CXXFLAGS $CCFLAGS $_CCCOMCOM $SOURCES '
+ win_redirect + " > \"" +
build_env['PROJECT_DIR'] + "/" +
build_dir + "/build_logs/" + prog_name +
"_compile.txt\" " + linux_redirect,
'$CXXCOMSTR'))
if not os.path.exists(build_env['PROJECT_DIR'] + "/" + build_dir +
"/build_logs"):
os.makedirs(build_env['PROJECT_DIR'] + "/" + build_dir + "/build_logs")
# if ARGUMENTS.get('fail', 0):
# Command('target', 'source', ['/bin/false'])
build_env['BUILD_LOG_TIME'] = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y_%m_%d__%H_%M_%S')
def print_cmd_line(s, targets, sources, env):
with open(
env['PROJECT_DIR'] + "/" + build_dir + "/build_logs/build_" +
env['BUILD_LOG_TIME'] + ".log", "a") as f:
f.write(s + "\n")
try:
print_cmd = GetOption('option_verbose')
except AttributeError:
print_cmd = False
if not print_cmd:
build_env['PRINT_CMD_LINE_FUNC'] = print_cmd_line
built_bins = []
if ("Windows" in platform.system()):
if (prog_type == 'shared'):
built_bins.append(build_dir + "/" +
build_env.subst('$SHLIBPREFIX') + prog_name +
build_env.subst('$SHLIBSUFFIX'))
elif (prog_type == 'static'):
built_bins.append(build_dir + "/" + build_env.subst('$LIBPREFIX') +
prog_name + build_env.subst('$LIBSUFFIX'))
elif (prog_type == 'exec'):
built_bins.append(build_dir + "/" +
build_env.subst('$PROGPREFIX') + prog_name +
build_env.subst('$PROGSUFFIX'))
else:
if (prog_type == 'shared'):
built_bins.append(build_dir + "/" +
build_env.subst('$SHLIBPREFIX') + prog_name +
build_env.subst('$SHLIBSUFFIX'))
elif (prog_type == 'static'):
built_bins.append(build_dir + "/" + build_env.subst('$LIBPREFIX') +
prog_name + build_env.subst('$LIBSUFFIX'))
elif (prog_type == 'exec'):
built_bins.append(build_dir + "/" +
build_env.subst('$PROGPREFIX') + prog_name +
build_env.subst('$PROGSUFFIX'))
return [build_env, prog]
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
def locateQt4Command(env, command, qtdir):
if len(qtdir) == 0:
qtdir = "/usr"
if env["qt5"]:
suffixes = [
'-qt5',
'-qt5.exe',
'5',
'5.exe',
'',
'.exe',
]
else:
suffixes = [
'-qt4',
'-qt4.exe',
'4',
'4.exe',
'',
'.exe',
]
triedPaths = []
for suffix in suffixes:
fullpath = os.path.join(qtdir, 'bin', command + suffix)
if os.access(fullpath, os.X_OK):
return fullpath
triedPaths.append(fullpath)
fullpath = env.Detect([command + '-qt4', command + '4', command])
if not (fullpath is None): return fullpath
raise Exception("Qt4 command '" + command + "' not found. Tried: " +
', '.join(triedPaths))
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
splitext = SCons.Util.splitext
env['QTDIR'] = _detect(env)
# TODO: 'Replace' should be 'SetDefault'
# env.SetDefault(
env.Replace(
QTDIR=_detect(env),
# TODO: This is not reliable to QTDIR value changes but needed in order to support '-qt4' variants
QT4_MOC=locateQt4Command(env, 'moc', env['QTDIR']),
QT4_UIC=locateQt4Command(env, 'uic', env['QTDIR']),
QT4_RCC=locateQt4Command(env, 'rcc', env['QTDIR']),
QT4_LUPDATE=locateQt4Command(env, 'lupdate', env['QTDIR']),
QT4_LRELEASE=locateQt4Command(env, 'lrelease', env['QTDIR']),
QT4_LIB='', # KLUDGE to avoid linking qt3 library
QT4_AUTOSCAN=
1, # Should the qt tool try to figure out, which sources are to be moc'ed?
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT4_UICFLAGS=CLVar(''),
QT4_MOCFROMHFLAGS=CLVar(''),
QT4_MOCFROMCXXFLAGS=CLVar('-i'),
QT4_QRCFLAGS='--compress 9 --threshold 5',
# suffixes/prefixes for the headers / sources to generate
QT4_UISUFFIX='.ui',
QT4_UICDECLPREFIX='ui_',
QT4_UICDECLSUFFIX='.h',
QT4_MOCHPREFIX='moc_',
QT4_MOCHSUFFIX='$CXXFILESUFFIX',
QT4_MOCCXXPREFIX='',
QT4_MOCCXXSUFFIX='.moc',
QT4_QRCSUFFIX='.qrc',
QT4_QRCCXXSUFFIX='$CXXFILESUFFIX',
QT4_QRCCXXPREFIX='qrc_',
QT4_MOCCPPPATH=[],
QT4_MOCINCFLAGS=
'$( ${_concat("-I", QT4_MOCCPPPATH, INCSUFFIX, __env__, RDirs)} $)',
# Commands for the qt support ...
QT4_UICCOM='$QT4_UIC $QT4_UICFLAGS -o $TARGET $SOURCE',
# FIXME: The -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED flag is a hack to work
# around an issue in Qt
# See https://bugreports.qt-project.org/browse/QTBUG-22829
QT4_MOCFROMHCOM=
'$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMHFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',
QT4_MOCFROMCXXCOM=[
'$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMCXXFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',
Action(checkMocIncluded, None)
],
QT4_LUPDATECOM='$QT4_LUPDATE $SOURCE -ts $TARGET',
QT4_LRELEASECOM='$QT4_LRELEASE -silent $SOURCE -qm $TARGET',
QT4_RCCCOM='$QT4_RCC $QT4_QRCFLAGS -name $SOURCE $SOURCE -o $TARGET',
)
if len(env["QTDIR"]) > 0:
env.Replace(QT4_LIBPATH=os.path.join('$QTDIR', 'lib'))
# Translation builder
tsbuilder = Builder(
action=SCons.Action.Action(
'$QT4_LUPDATECOM'), #,'$QT4_LUPDATECOMSTR'),
multi=1)
env.Append(BUILDERS={'Ts': tsbuilder})
qmbuilder = Builder(action=SCons.Action.Action(
'$QT4_LRELEASECOM', cmdstr='$QT4_LRELEASECOMSTR'),
src_suffix='.ts',
suffix='.qm',
single_source=True)
env.Append(BUILDERS={'Qm': qmbuilder})
# Resource builder
def scanResources(node, env, path, arg):
# I've being careful on providing names relative to the qrc file
# If that was not needed that code could be simplified a lot
def recursiveFiles(basepath, path):
result = []
for item in os.listdir(os.path.join(basepath, path)):
itemPath = os.path.join(path, item)
if os.path.isdir(os.path.join(basepath, itemPath)):
result += recursiveFiles(basepath, itemPath)
else:
result.append(itemPath)
return result
contents = node.get_contents()
includes = [
included[1] for included in qrcinclude_re.findall(contents)
]
qrcpath = os.path.dirname(node.path)
dirs = [
included for included in includes
if os.path.isdir(os.path.join(qrcpath, included))
]
# dirs need to include files recursively
for dir in dirs:
includes.remove(dir)
includes += recursiveFiles(qrcpath, dir)
return includes
qrcscanner = SCons.Scanner.Scanner(name='qrcfile',
function=scanResources,
argument=None,
skeys=['.qrc'])
qrcbuilder = Builder(action=SCons.Action.Action('$QT4_RCCCOM',
cmdstr='$QT4_RCCCOMSTR'),
source_scanner=qrcscanner,
src_suffix='$QT4_QRCSUFFIX',
suffix='$QT4_QRCCXXSUFFIX',
prefix='$QT4_QRCCXXPREFIX',
single_source=True)
env.Append(BUILDERS={'Qrc': qrcbuilder})
# Interface builder
def addDisableWarningsPragmaToFile(target, source, env):
assert (len(target) == 1)
assert (len(source) == 1)
srcf = str(source[0])
dstf = str(target[0])
with open(dstf, 'r+') as uiHeader:
data = uiHeader.read()
template = Template("""#pragma once
#pragma warning(push, 0)
#pragma GCC system_header
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wall"
$uiheadertext
#pragma clang diagnostic pop
#pragma warning(pop)
""")
uiHeader.seek(0)
uiHeader.write(template.substitute(uiheadertext=data))
uiHeader.truncate()
uic4builder = Builder(action=[
SCons.Action.Action('$QT4_UICCOM', cmdstr='$QT4_UICCOMSTR'),
SCons.Action.Action(addDisableWarningsPragmaToFile, None)
],
src_suffix='$QT4_UISUFFIX',
suffix='$QT4_UICDECLSUFFIX',
prefix='$QT4_UICDECLPREFIX',
single_source=True
#TODO: Consider the uiscanner on new scons version
)
env['BUILDERS']['Uic4'] = uic4builder
# Metaobject builder
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.Action('$QT4_MOCFROMHCOM',
cmdstr='$QT4_MOCFROMHCOMSTR')
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT4_MOCHPREFIX'
mocBld.suffix[h] = '$QT4_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.Action('$QT4_MOCFROMCXXCOM',
cmdstr='$QT4_MOCFROMCXXCOMSTR')
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT4_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT4_MOCCXXSUFFIX'
env['BUILDERS']['Moc4'] = mocBld
# er... no idea what that was for
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.src_builder.append('Uic4')
shared_obj.src_builder.append('Uic4')
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(
PROGEMITTER=[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER=[AutomocStatic],
# Of course, we need to link against the qt libraries
LIBPATH=["$QT4_LIBPATH"],
LIBS=['$QT4_LIB'])
# TODO: Does dbusxml2cpp need an adapter
env.AddMethod(enable_modules, "EnableQt4Modules")
def generate(env):
"""Add Builders and construction variables for qt5 to an Environment."""
suffixes = [
'-qt5',
'-qt5.exe',
'5',
'5.exe',
'',
'.exe',
]
command_suffixes = ['-qt5', '5', '']
def locateQt5Command(env, command, qtdir) :
triedPaths = []
for suffix in suffixes :
fullpath = os.path.join(env.fs.Dir(qtdir).abspath,'bin',command + suffix)
if os.access(fullpath, os.X_OK) :
return fullpath
triedPaths.append(fullpath)
fullpath = env.Detect([command+s for s in command_suffixes])
if not (fullpath is None) : return fullpath
raise Exception("Qt5 command '" + command + "' not found. Tried: " + ', '.join(triedPaths))
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
env['QT5DIR'] = _detect(env)
# TODO: 'Replace' should be 'SetDefault'
# env.SetDefault(
env.Replace(
QT5DIR = _detect(env),
QT5_BINPATH = os.path.join('$QT5DIR', 'bin'),
QT5_LIBPATH = os.path.join('$QTDIR', 'lib'),
# TODO: This is not reliable to QT5DIR value changes but needed in order to support '-qt5' variants
QT5_MOC = locateQt5Command(env,'moc', env['QT5DIR']),
QT5_UIC = locateQt5Command(env,'uic', env['QT5DIR']),
QT5_RCC = locateQt5Command(env,'rcc', env['QT5DIR']),
#QT5_LUPDATE = locateQt5Command(env,'lupdate', env['QT5DIR']),
#QT5_LRELEASE = locateQt5Command(env,'lrelease', env['QT5DIR']),
QT5_AUTOSCAN = 1, # Should the qt5 tool try to figure out, which sources are to be moc'ed?
QT5_AUTOSCAN_STRATEGY = 0, # While scanning for files to moc, should we search for includes in qtsolutions style?
QT5_GOBBLECOMMENTS = 0, # If set to 1, comments are removed before scanning cxx/h files.
QT5_CPPDEFINES_PASSTOMOC = 1, # If set to 1, all CPPDEFINES get passed to the moc executable.
QT5_CLEAN_TS = 0, # If set to 1, translation files (.ts) get cleaned on 'scons -c'
QT5_AUTOMOC_SCANCPPPATH = 1, # If set to 1, the CPPPATHs (or QT5_AUTOMOC_CPPPATH) get scanned for moc'able files
QT5_AUTOMOC_CPPPATH = [], # Alternative paths that get scanned for moc files
# Some Qt5 specific flags. I don't expect someone wants to
# manipulate those ...
QT5_UICFLAGS = CLVar(''),
QT5_MOCFROMHFLAGS = CLVar(''),
QT5_MOCFROMCXXFLAGS = CLVar('-i'),
QT5_QRCFLAGS = '',
# suffixes/prefixes for the headers / sources to generate
QT5_UISUFFIX = '.ui',
QT5_UICDECLPREFIX = 'ui_',
QT5_UICDECLSUFFIX = '.h',
QT5_MOCINCPREFIX = '-I',
QT5_MOCHPREFIX = 'moc_',
QT5_MOCHSUFFIX = '$CXXFILESUFFIX',
QT5_MOCCXXPREFIX = '',
QT5_MOCCXXSUFFIX = '.moc',
QT5_QRCSUFFIX = '.qrc',
QT5_QRCCXXSUFFIX = '$CXXFILESUFFIX',
QT5_QRCCXXPREFIX = 'qrc_',
#QT5_MOCDEFPREFIX = '-D',
#QT5_MOCDEFSUFFIX = '',
#QT5_MOCDEFINES = '${_defines(QT5_MOCDEFPREFIX, CPPDEFINES, QT5_MOCDEFSUFFIX, __env__)}',
QT5_MOCCPPPATH = [],
QT5_MOCINCFLAGS = '$( ${_concat(QT5_MOCINCPREFIX, QT5_MOCCPPPATH, INCSUFFIX, __env__, RDirs)} $)',
# Commands for the qt5 support ...
QT5_UICCOM = '$QT5_UIC $QT5_UICFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMHCOM = '"$QT5_MOC" $QT5_MOCFROMHFLAGS $QT5_MOCINCFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMCXXCOM = [
'$QT5_MOC $QT5_MOCFROMCXXFLAGS $QT5_MOCINCFLAGS -o $TARGET $SOURCE',
Action(checkMocIncluded,None)],
QT5_RCCCOM = '"$QT5_RCC" $QT5_QRCFLAGS $SOURCE -o $TARGET',
#QT5_LUPDATECOM = '$QT5_LUPDATE $QT5_LUPDATEFLAGS $SOURCES -ts $TARGET',
#QT5_LRELEASECOM = '$QT5_LRELEASE $QT5_LRELEASEFLAGS -qm $TARGET $SOURCES',
# Specialized variables for the Extended Automoc support
# (Strategy #1 for qtsolutions)
#QT5_XMOCHPREFIX = 'moc_',
#QT5_XMOCHSUFFIX = '.cpp',
#QT5_XMOCCXXPREFIX = '',
#QT5_XMOCCXXSUFFIX = '.moc',
)
try:
env.AddMethod(Ts5, "Ts5")
env.AddMethod(Qm5, "Qm5")
#env.AddMethod(Qrc5, "Qrc5")
env.AddMethod(ExplicitMoc5, "ExplicitMoc5")
env.AddMethod(ExplicitUic5, "ExplicitUic5")
except AttributeError:
# Looks like we use a pre-0.98 version of SCons...
from SCons.Script.SConscript import SConsEnvironment
SConsEnvironment.Ts5 = Ts5
SConsEnvironment.Qm5 = Qm5
#SConsEnvironment.Qrc5 = Qrc5
SConsEnvironment.ExplicitMoc5 = ExplicitMoc5
SConsEnvironment.ExplicitUic5 = ExplicitUic5
# Interface builder
uic5builder = Builder(
action = SCons.Action.Action('$QT5_UICCOM', '$QT5_UICCOMSTR'),
src_suffix='$QT5_UISUFFIX',
suffix='$QT5_UICDECLSUFFIX',
prefix='$QT5_UICDECLPREFIX',
single_source = True
#TODO: Consider the uiscanner on new scons version
)
env['BUILDERS']['Uic5'] = uic5builder
env['BUILDERS']['Qrc5'] = __qrc_builder
# Metaobject builder
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.CommandGeneratorAction(__moc_generator_from_h, {'cmdstr':'$QT5_MOCCOMSTR'})
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT5_MOCHPREFIX'
mocBld.suffix[h] = '$QT5_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.CommandGeneratorAction(__moc_generator_from_cxx, {'cmdstr':'$QT5_MOCCOMSTR'})
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT5_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT5_MOCCXXSUFFIX'
env['BUILDERS']['Moc5'] = mocBld
# Metaobject builder for the extended auto scan feature
# (Strategy #1 for qtsolutions)
xMocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.CommandGeneratorAction(__mocx_generator_from_h, {'cmdstr':'$QT5_MOCCOMSTR'})
xMocBld.add_action(h, act)
xMocBld.prefix[h] = '$QT5_XMOCHPREFIX'
xMocBld.suffix[h] = '$QT5_XMOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.CommandGeneratorAction(__mocx_generator_from_cxx, {'cmdstr':'$QT5_MOCCOMSTR'})
xMocBld.add_action(cxx, act)
xMocBld.prefix[cxx] = '$QT5_XMOCCXXPREFIX'
xMocBld.suffix[cxx] = '$QT5_XMOCCXXSUFFIX'
env['BUILDERS']['XMoc5'] = xMocBld
# Add the Qrc5 action to the CXX file builder (registers the
# *.qrc extension with the Environment)
cfile_builder, cxxfile_builder = SCons.Tool.createCFileBuilders(env)
qrc_act = SCons.Action.CommandGeneratorAction(__qrc_generator, {'cmdstr':'$QT5_QRCCOMSTR'})
cxxfile_builder.add_action('$QT5_QRCSUFFIX', qrc_act)
cxxfile_builder.add_emitter('$QT5_QRCSUFFIX', __qrc_emitter)
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(PROGEMITTER =[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER =[AutomocStatic],
)
# TODO: Does dbusxml2cpp need an adapter
try:
env.AddMethod(enable_modules, "EnableQt5Modules")
except AttributeError:
# Looks like we use a pre-0.98 version of SCons...
from SCons.Script.SConscript import SConsEnvironment
SConsEnvironment.EnableQt5Modules = enable_modules
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import os
from SCons.Action import *
#
# Generate an LinnFS filesystem image.
#
def generateLinnFS(target=None, source=None, env=None):
os.system("srv/filesystem/linn/host/create boot/boot.linn" \
" -d . -s -n 16384 -e '*.cpp' -e '*.h' -e '*.c' -e '*.o' -e 'lib*' -e 'doc' " \
" -e 'SCons*' -e '*.a' -e '*.S' -e '*.ld' -e 'boot*'")
os.system("gzip -f boot/boot.linn")
#
# Prints out a user friendly command-line string.
#
def generateLinnFSStr(target, source, env):
return " LINN boot/boot.linn.gz"
#
# Create LinnFS Action.
#
action = Action(generateLinnFS, generateLinnFSStr)
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
splitext = SCons.Util.splitext
dep_include = env["OPTICKSDEPENDENCIESINCLUDE"]
dep_bin = env["OPTICKSDEPENDENCIESBIN"]
env.AppendUnique(
QT_BINPATH=dep_bin,
QT_CPPPATH=os.path.join(dep_include, 'qt4'),
QT_MOC=os.path.join('$QT_BINPATH', 'moc'),
QT_UIC=os.path.join('$QT_BINPATH', 'uic'),
QT_QRC=os.path.join('$QT_BINPATH', 'rcc'),
QT_LIB=None, # filled in by AddModules
QT_MODULES=[], # filled in by AddModules
QT_AUTOSCAN=1, # scan for moc'able sources
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT_UICIMPLFLAGS=CLVar(''),
QT_UICDECLFLAGS=CLVar(''),
QT_MOCFROMHFLAGS=CLVar(''),
QT_MOCFROMCXXFLAGS=CLVar('-i'),
# suffixes/prefixes for the headers / sources to generate
QT_UICDECLPREFIX='ui_',
QT_UICDECLSUFFIX='.h',
QT_QRCIMPLSUFFIX='_qrc.cpp',
QT_MOCHPREFIX='moc_',
QT_MOCHSUFFIX='$CXXFILESUFFIX',
QT_MOCCXXPREFIX='',
QT_MOCCXXSUFFIX='.moc',
QT_UISUFFIX='.ui',
QT_QRCSUFFIX='.qrc',
# Commands for the qt support ...
# command to generate header, implementation and moc-file
# from a .qrc file
QT_QRCCOM=[
CLVar(
'$QT_QRC $QT_QRCDECLFLAGS $SOURCE -name ${SOURCE.filebase} -o ${TARGETS[0]}'
)
],
# from a .ui file
QT_UICCOM=[CLVar('$QT_UIC $QT_UICDECLFLAGS -o ${TARGETS[0]} $SOURCE')],
# command to generate meta object information for a class
# declarated in a header
QT_MOCFROMHCOM=('$QT_MOC $QT_MOCFROMHFLAGS -o ${TARGETS[0]} $SOURCE'),
# command to generate meta object information for a class
# declarated in a cpp file
QT_MOCFROMCXXCOM=[
CLVar('$QT_MOC $QT_MOCFROMCXXFLAGS -o ${TARGETS[0]} $SOURCE'),
Action(checkMocIncluded, None)
])
# ... and the corresponding builders
qrcBld = Builder(action={'$QT_QRCSUFFIX': '$QT_QRCCOM'},
suffix='$QT_QRCIMPLSUFFIX',
src_suffix='$QT_QRCSUFFIX')
uicBld = Builder(action={'$QT_UISUFFIX': '$QT_UICCOM'},
src_suffix='$QT_UISUFFIX',
suffix='$QT_UICDECLSUFFIX',
prefix='$QT_UICDECLPREFIX',
source_scanner=uicScanner)
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
mocBld.add_action(h, '$QT_MOCFROMHCOM')
mocBld.prefix[h] = '$QT_MOCHPREFIX'
mocBld.suffix[h] = '$QT_MOCHSUFFIX'
for cxx in cxx_suffixes:
mocBld.add_action(cxx, '$QT_MOVFROMCXXCOM')
mocBld.prefix[cxx] = '$QT_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT_MOCCXXSUFFIX'
# register the builders
env['BUILDERS']['Uic'] = uicBld
env['BUILDERS']['Moc'] = mocBld
env['BUILDERS']['Qrc'] = qrcBld
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.src_builder.append('Qrc')
shared_obj.src_builder.append('Qrc')
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(PROGEMITTER=[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER=[AutomocStatic])
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
env.SetDefault(
QT_AUTOSCAN=1, # scan for moc'able sources
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT_UICIMPLFLAGS=CLVar(''),
QT_UICDECLFLAGS=CLVar(''),
QT_MOCFROMHFLAGS=CLVar(''),
QT_MOCFROMCXXFLAGS=CLVar('-i'),
# suffixes/prefixes for the headers / sources to generate
QT_UICDECLPREFIX='', #'ui_',
QT_UICDECLSUFFIX='.h',
QT_UICIMPLPREFIX='', #'ui_',
QT_UICIMPLSUFFIX='$CXXFILESUFFIX',
QT_MOCHPREFIX='moc_',
QT_MOCHSUFFIX='$CXXFILESUFFIX',
QT_MOCCXXPREFIX='',
QT_MOCCXXSUFFIX='.moc',
QT_UISUFFIX='.ui',
QT4_LUPDATE=os.path.join('$QT_BINPATH', 'lupdate'),
QT4_LRELEASE=os.path.join('$QT_BINPATH', 'lrelease'),
QT4_LUPDATECOM='$QT4_LUPDATE $SOURCE -ts $TARGET',
QT4_LRELEASECOM='$QT4_LRELEASE $SOURCE',
# Commands for the qt support ...
# command to generate header, implementation and moc-file
# from a .ui file
QT_UICCOM=[
CLVar('$QT_UIC $QT_UICDECLFLAGS -o ${TARGETS[0]} $SOURCE'),
CLVar('$QT_UIC $QT_UICIMPLFLAGS -impl ${TARGETS[0].file} '
'-o ${TARGETS[1]} $SOURCE'),
#CLVar('$QT_MOC $QT_MOCFROMHFLAGS -o ${TARGETS[2]} ${TARGETS[0]}'),
],
# command to generate meta object information for a class
# declarated in a header
QT_MOCFROMHCOM=('$QT_MOC $QT_MOCFROMHFLAGS -o ${TARGETS[0]} $SOURCE'),
# command to generate meta object information for a class
# declarated in a cpp file
QT_MOCFROMCXXCOM=[
CLVar('$QT_MOC $QT_MOCFROMCXXFLAGS -o ${TARGETS[0]} $SOURCE'),
Action(checkMocIncluded, None),
Action(simplifyInclude)
])
# ... and the corresponding builders
uicBld = Builder(
action=SCons.Action.Action('$QT_UICCOM', '$QT_UICCOMSTR'),
emitter=uicEmitter,
src_suffix='$QT_UISUFFIX',
suffix='$QT_UICDECLSUFFIX',
prefix='$QT_UICDECLPREFIX',
source_scanner=uicScanner,
)
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.Action('$QT_MOCFROMHCOM', '$QT_MOCFROMHCOMSTR')
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT_MOCHPREFIX'
mocBld.suffix[h] = '$QT_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.Action('$QT_MOCFROMCXXCOM', '$QT_MOCFROMCXXCOMSTR')
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT_MOCCXXSUFFIX'
# register the builders
# Translation builder
tsbuilder = Builder(
action=SCons.Action.Action(
'$QT4_LUPDATECOM'), #,'$QT4_LUPDATECOMSTR'),
multi=1)
qmbuilder = Builder(
action=SCons.Action.Action(
'$QT4_LRELEASECOM'), # , '$QT4_LRELEASECOMSTR'),
src_suffix='.ts',
suffix='.qm',
single_source=True)
env['BUILDERS']['Ts'] = tsbuilder
env['BUILDERS']['Qm'] = qmbuilder
env['BUILDERS']['Uic'] = uicBld
env['BUILDERS']['Moc'] = mocBld
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.add_src_builder('Uic')
shared_obj.add_src_builder('Uic')
env.AddMethod(enableQtEmmitters, "EnableQtEmmitters")
os.system("genext2fs -d " + temp + " -b 16384 " + str(target[0]))
# Done.
os.system("rm -rf " + temp)
list.close()
#
# Prints out a user friendly command-line string.
#
def generateExt2Str(target, source, env):
return " EXT2 " + str(target[0])
#
# Create extended 2 builder.
#
ext2Builder = Builder(action=Action(generateExt2, generateExt2Str),
suffix='.ext2',
src_suffix='.ext2desc')
target.Append(BUILDERS={'Ext2': ext2Builder})
#
# Specify dependencies and targets.
#
ext2 = target.Ext2('boot/boot.ext2', ['boot/boot.ext2desc'])
Depends(ext2, ['bin', 'lib', 'kernel', 'sbin', 'srv'])
AlwaysBuild(ext2)
def generate(env):
"""Add Builders and construction variables for qt to an Environment."""
def locateQt5Command(env, command, qtdir):
suffixes = [
'-qt5',
'-qt5.exe',
'5',
'5.exe',
'',
'.exe',
]
triedPaths = []
for suffix in suffixes:
fullpath = os.path.join(qtdir, 'bin', command + suffix)
if os.access(fullpath, os.X_OK):
return fullpath
triedPaths.append(fullpath)
fullpath = env.Detect([command + '-qt5', command + '5', command])
if not (fullpath is None): return fullpath
raise Exception("Qt5 command '" + command + "' not found. Tried: " +
', '.join(triedPaths))
CLVar = SCons.Util.CLVar
Action = SCons.Action.Action
Builder = SCons.Builder.Builder
splitext = SCons.Util.splitext
env['QTDIR'] = env.GetBuildPath(_detect(env))
# TODO: 'Replace' should be 'SetDefault'
# env.SetDefault(
env.Replace(
QTDIR=_detect(env),
QT5_BINPATH=os.path.join('$QTDIR', 'bin'),
QT5_LIBPATH=os.path.join('$QTDIR', 'lib'),
# TODO: This is not reliable to QTDIR value changes but needed in order to support '-qt5' variants
QT5_MOC=locateQt5Command(env, 'moc', env['QTDIR']),
QT5_UIC=locateQt5Command(env, 'uic', env['QTDIR']),
QT5_RCC=locateQt5Command(env, 'rcc', env['QTDIR']),
QT5_LUPDATE=locateQt5Command(env, 'lupdate', env['QTDIR']),
QT5_LRELEASE=locateQt5Command(env, 'lrelease', env['QTDIR']),
QT5_AUTOSCAN=
1, # Should the qt tool try to figure out, which sources are to be moc'ed?
# Some QT specific flags. I don't expect someone wants to
# manipulate those ...
QT5_UICFLAGS=CLVar(''),
QT5_MOCFROMHFLAGS=CLVar(''),
QT5_MOCFROMCXXFLAGS=CLVar('-i'),
QT5_QRCFLAGS='',
# suffixes/prefixes for the headers / sources to generate
QT5_UISUFFIX='.ui',
QT5_UICDECLPREFIX='ui_',
QT5_UICDECLSUFFIX='.h',
QT5_MOCINCPREFIX='-I',
QT5_MOCHPREFIX='moc_',
QT5_MOCHSUFFIX='$CXXFILESUFFIX',
QT5_MOCCXXPREFIX='',
QT5_MOCCXXSUFFIX='.moc',
QT5_QRCSUFFIX='.qrc',
QT5_QRCCXXSUFFIX='$CXXFILESUFFIX',
QT5_QRCCXXPREFIX='qrc_',
QT5_MOCCPPPATH=[],
QT5_MOCINCFLAGS=
'$( ${_concat(QT5_MOCINCPREFIX, QT5_MOCCPPPATH, INCSUFFIX, __env__, RDirs)} $)',
# Commands for the qt support ...
QT5_UICCOM='"$QT5_UIC" $QT5_UICFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMHCOM=
'"$QT5_MOC" $QT5_MOCFROMHFLAGS $QT5_MOCINCFLAGS -o $TARGET $SOURCE',
QT5_MOCFROMCXXCOM=[
'$QT5_MOC $QT5_MOCFROMCXXFLAGS $QT5_MOCINCFLAGS -o $TARGET $SOURCE',
Action(checkMocIncluded, None)
],
QT5_LUPDATECOM='"$QT5_LUPDATE" $SOURCE -ts $TARGET',
QT5_LRELEASECOM='"$QT5_LRELEASE" $SOURCE',
QT5_RCCCOM='"$QT5_RCC" $QT5_QRCFLAGS $SOURCE -o $TARGET',
)
print "%s" % (env['QTDIR'])
# Translation builder
tsbuilder = Builder(
action=SCons.Action.Action(
'$QT5_LUPDATECOM'), #,'$QT5_LUPDATECOMSTR'),
multi=1)
env.Append(BUILDERS={'Ts': tsbuilder})
qmbuilder = Builder(
action=SCons.Action.Action(
'$QT5_LRELEASECOM'), # , '$QT5_LRELEASECOMSTR'),
src_suffix='.ts',
suffix='.qm',
single_source=True)
env.Append(BUILDERS={'Qm': qmbuilder})
# Resource builder
def scanResources(node, env, path, arg):
# I've being careful on providing names relative to the qrc file
# If that was not needed that code could be simplified a lot
def recursiveFiles(basepath, path):
result = []
for item in os.listdir(os.path.join(basepath, path)):
itemPath = os.path.join(path, item)
if os.path.isdir(os.path.join(basepath, itemPath)):
result += recursiveFiles(basepath, itemPath)
else:
result.append(itemPath)
return result
contents = node.get_contents()
includes = qrcinclude_re.findall(contents)
qrcpath = os.path.dirname(node.path)
dirs = [
included for included in includes
if os.path.isdir(os.path.join(qrcpath, included))
]
# dirs need to include files recursively
for dir in dirs:
includes.remove(dir)
includes += recursiveFiles(qrcpath, dir)
return includes
qrcscanner = SCons.Scanner.Scanner(name='qrcfile',
function=scanResources,
argument=None,
skeys=['.qrc'])
qrcbuilder = Builder(action=SCons.Action.Action('$QT5_RCCCOM',
'$QT5_RCCCOMSTR'),
source_scanner=qrcscanner,
src_suffix='$QT5_QRCSUFFIX',
suffix='$QT5_QRCCXXSUFFIX',
prefix='$QT5_QRCCXXPREFIX',
single_source=True)
env.Append(BUILDERS={'Qrc': qrcbuilder})
# Interface builder
uic5builder = Builder(action=SCons.Action.Action('$QT5_UICCOM',
'$QT5_UICCOMSTR'),
src_suffix='$QT5_UISUFFIX',
suffix='$QT5_UICDECLSUFFIX',
prefix='$QT5_UICDECLPREFIX',
single_source=True
#TODO: Consider the uiscanner on new scons version
)
env['BUILDERS']['Uic5'] = uic5builder
# Metaobject builder
mocBld = Builder(action={}, prefix={}, suffix={})
for h in header_extensions:
act = SCons.Action.Action('$QT5_MOCFROMHCOM', '$QT5_MOCFROMHCOMSTR')
mocBld.add_action(h, act)
mocBld.prefix[h] = '$QT5_MOCHPREFIX'
mocBld.suffix[h] = '$QT5_MOCHSUFFIX'
for cxx in cxx_suffixes:
act = SCons.Action.Action('$QT5_MOCFROMCXXCOM',
'$QT5_MOCFROMCXXCOMSTR')
mocBld.add_action(cxx, act)
mocBld.prefix[cxx] = '$QT5_MOCCXXPREFIX'
mocBld.suffix[cxx] = '$QT5_MOCCXXSUFFIX'
env['BUILDERS']['Moc5'] = mocBld
# er... no idea what that was for
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
static_obj.src_builder.append('Uic5')
shared_obj.src_builder.append('Uic5')
# We use the emitters of Program / StaticLibrary / SharedLibrary
# to scan for moc'able files
# We can't refer to the builders directly, we have to fetch them
# as Environment attributes because that sets them up to be called
# correctly later by our emitter.
env.AppendUnique(
PROGEMITTER=[AutomocStatic],
SHLIBEMITTER=[AutomocShared],
LIBEMITTER=[AutomocStatic],
)
# TODO: Does dbusxml2cpp need an adapter
env.AddMethod(enable_modules, "EnableQt5Modules")
# Write to output file.
out = open(str(target[0]), "w")
out.write(sum + " " + str(source[0]) + "\n")
out.close()
def ChecksumString(target, source, env):
# Retrieve extension.
file, ext = os.path.splitext(str(target[0]))
# Print out accordingly.
if ext == ".md5":
return " MD5 " + str(target[0])
elif ext == ".sha1":
return " SHA1 " + str(target[0])
else:
return " CHKSUM " + str(target[0])
#
# Registers the Checksum builder.
#
target.Append(
BUILDERS={
'Checksum': target.Builder(
action=Action(ChecksumBuilder, ChecksumString)),
})