def _add_flags_to_overrides(env, overrides, name, newflags):
newflags = CLVar(newflags)
flags = overrides.get(name, env.get(name, []))[:]
flags = CLVar(flags)
for nf in newflags:
if not nf in flags:
flags.append(nf)
overrides[name] = flags
def _remove_flags_from_overrides(env, overrides, name, delflags):
delflags = CLVar(delflags)
flags = overrides.get(name, env.get(name, []))[:]
flags = CLVar(flags)
for df in delflags:
if df in flags:
flags.remove(df)
overrides[name] = flags
def generate(env):
env['CHPL'] = 'chpl'
env['CHPLFLAGS'] = CLVar('')
env['CHPLLINKFLAGS'] = CLVar('')
env['CHPLSUFFIX'] = '.chpl'
chapelBuilder = Builder(
action='$CHPL $CHPLFLAGS -o $TARGET $SOURCES',
src_suffix=['.chpl'],
single_source=False,
)
env.Append(BUILDERS={
'ChapelProgram': chapelBuilder,
})
def generate(env):
env["CHPL"] = "chpl"
env["CHPLFLAGS"] = CLVar("")
env["CHPLLINKFLAGS"] = CLVar("")
env["CHPLSUFFIX"] = ".chpl"
chapelBuilder = Builder(
action="$CHPL $CHPLFLAGS -o $TARGET $SOURCES",
src_suffix=[".chpl"],
single_source=False,
)
env.Append(
BUILDERS={
"ChapelProgram": chapelBuilder,
}
)
def createATypedSwigModule(self,
target,
sources=[],
deplibs=[],
skip=[],
**kwargs):
env = self.myClone()
env.loadTools(['swig'])
nodes = []
for atype in self['ATYPES']:
if atype not in skip:
libEnv = env.myClone()
libTarget = '%s_%s' % (target, atype)
libEnv.Append(CPPPATH=['$SRCDIR/modules/atypes/%s' % atype])
libEnv.AppendUnique(
SWIGPATH=['$SRCDIR/modules/atypes/%s' % atype])
libEnv.AppendUnique(SWIGFLAGS=CLVar('-module %s_atyped_%s' %
(target, atype)))
libEnv['SHOBJSUFFIX'] = '_%s%s' % (atype, self['SHOBJSUFFIX'])
nodes += libEnv.createSwigModule(libTarget,
sources,
deplibs,
createPublicHeader=False,
atype=atype,
**kwargs)
return nodes
def createATypedSharedLibrary(self,
target,
sources=[],
deplibs=[],
skip=[],
**kwargs):
env = self.myClone()
nodes = []
for atype in self['ATYPES']:
if atype not in skip:
libEnv = env.myClone()
if Arch.isWindows():
libEnv.AppendUnique(CPPDEFINES=CLVar('BUILDING_' +
target.upper()))
libTarget = '%s_%s' % (target, atype)
libEnv['SHOBJSUFFIX'] = '_%s%s' % (atype, self['SHOBJSUFFIX'])
nodes += libEnv.createSharedLibrary(libTarget,
sources,
deplibs,
createPublicHeader=False,
targetAType=atype,
**kwargs)
return nodes
def generate(env):
"""Add Builders and construction variables for ar to an Environment."""
env["CYTHON_FLAGS"] = CLVar("--fast-fail -3")
env["CYTHON_DEPS"] = []
env["CYTHON_COMPILE_DEPS"] = []
env.Append(BUILDERS={"CythonToC": CythonToCBuilder})
env.AddMethod(CythonCompile, "CythonCompile")
env.AddMethod(CythonModule, "CythonModule")
def generate(env):
cppTool.generate(env)
if not env.get('CXXVERSION'):
try:
line = os.popen("/bin/bash -c 'gcc --version 2>&1'").readline()
env['CXXVERSION'] = re.compile(r'[^(]*[^)]*\) ([^\n ]*)').findall(
line)[0]
except:
env['CXXVERSION'] = '4.2.1'
env['COMPILER'] = 'gcc-' + env['CXXVERSION']
env['CXXFLAGS'] = CLVar(
'-Wall -fno-strict-aliasing -Woverloaded-virtual -ftemplate-depth-200 -frounding-math'
)
if is64Bit():
env.Append(CPPDEFINES=CLVar('OS_64BIT'))
if env['DEBUG']:
env.Append(CXXFLAGS=['-g', '-O0'])
elif env['PROFILE']:
env.Append(CXXFLAGS=['-fprofile-arcs', '-ftest-coverage'])
else:
env.Append(CXXFLAGS=['-O3', '-finline-limit=500'])
if env['OPENMP']:
env.Append(CXXFLAGS=['-fopenmp'])
if env['PARALLEL']:
env['CXX'] = 'mpicxx'
env.Append(CXXFLAGS=['-DFVM_PARALLEL'])
#bug fix for mpich
env.Append(CXXFLAGS=['-DMPICH_IGNORE_CXX_SEEK'])
else:
env['CXX'] = 'c++'
#env['CCFLAGS'] = env['CXXFLAGS']
env['SHCXXFLAGS'] = CLVar('$CXXFLAGS -fPIC')
def generate(env):
"""Add Builders and construction variables for cyglink to an Environment."""
gnulink.generate(env)
env['LINKFLAGS'] = CLVar('-Wl,-no-undefined')
env['SHLIBPREFIX'] = 'cyg'
env['SHLIBSUFFIX'] = '.dll'
env['IMPLIBPREFIX'] = 'lib'
env['IMPLIBSUFFIX'] = '.dll.a'
# Variables used by versioned shared libraries
# SHLIBVERSIONFLAGS and LDMODULEVERSIONFLAGS are same as in gnulink...
env['_SHLIBVERSIONFLAGS'] = '$SHLIBVERSIONFLAGS'
env['_LDMODULEVERSIONFLAGS'] = '$LDMODULEVERSIONFLAGS'
env['_IMPLIB_PRE_SOURCES'] = _implib_pre_flags
env['_IMPLIB_POST_SOURCES'] = _implib_post_flags
env['SHLINKCOM'] = '$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH ' \
'$_IMPLIB_PRE_SOURCES $SOURCES $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
env['LDMODULECOM'] = '$LDMODULE -o $TARGET $SHLINKFLAGS $__LDMODULEVERSIONFLAGS $__RPATH ' \
'$_IMPLIB_PRE_SOURCES $SOURCES $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
# Overwrite emitters. Cyglink does things differently when creating symlinks
env['SHLIBEMITTER'] = [cyglink_lib_emitter, cyglink_shlib_symlink_emitter]
env['LDMODULEEMITTER'] = [
cyglink_ldmodule_emitter, cyglink_ldmod_symlink_emitter
]
# This is the non versioned shlib filename
# If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
env['SHLIB_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_shlib_stem${IMPLIBSUFFIX}'
env['LDMODULE_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${IMPLIBSUFFIX}'
env['SHLIB_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_shlib_stem${_SHLIB_IMPLIBSUFFIX}'
env['LDMODULE_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${_LDMODULE_IMPLIBSUFFIX}'
env['_cyglink_shlibversion'] = cyglink_shlibversion
env['_SHLIB_IMPLIBSUFFIX'] = '${_cyglink_shlibversion}${IMPLIBSUFFIX}'
env['_SHLIBSUFFIX'] = '${_cyglink_shlibversion}${SHLIBSUFFIX}'
env['_cyglink_ldmodule_version'] = cyglink_ldmodule_version
env['_LDMODULESUFFIX'] = '${_cyglink_ldmodule_version}${LDMODULESUFFIX}'
env['_LDMODULE_IMPLIBSUFFIX'] = '${_cyglink_ldmodule_version}${IMPLIBSUFFIX}'
# Remove variables set by default initialization which aren't needed/used by cyglink
# these variables were set by gnulink but are not used in cyglink
for rv in ['_SHLIBSONAME', '_LDMODULESONAME']:
if rv in env:
del env[rv]
def generate(env):
mylinker.generate(env)
env['FRAMEWORKPATHPREFIX'] = '-F'
env['_FRAMEWORKPATH'] = '${_concat(FRAMEWORKPATHPREFIX, FRAMEWORKPATH, "", __env__, RDirs)}'
env['_FRAMEWORKS'] = '${_concat("-framework ", FRAMEWORKS, "", __env__)}'
env['LINKCOM'] = env[
'LINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
env['SHLINKFLAGS'] = CLVar('$LINKFLAGS -dynamiclib')
env['SHLINKCOM'] = env[
'SHLINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
env['_APPLELINK_CURRENT_VERSION'] = _applelib_currentVersionFromSoVersion
env['_APPLELINK_COMPATIBILITY_VERSION'] = _applelib_compatVersionFromSoVersion
env['_SHLIBVERSIONFLAGS'] = '$_APPLELINK_CURRENT_VERSION $_APPLELINK_COMPATIBILITY_VERSION '
env['_LDMODULEVERSIONFLAGS'] = '$_APPLELINK_CURRENT_VERSION $_APPLELINK_COMPATIBILITY_VERSION '
# override the default for loadable modules, which are different
# on OS X than dynamic shared libs. echoing what XCode does for
# pre/suffixes:
env['LDMODULEPREFIX'] = ''
env['LDMODULESUFFIX'] = ''
env['LDMODULEFLAGS'] = CLVar('$LINKFLAGS -bundle')
env[
'LDMODULECOM'] = '$LDMODULE -o ${TARGET} $LDMODULEFLAGS'\
' $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
# New stuff
env['_SHLIBSONAME'] = _applelib_soname
env['_SHLIBSUFFIX'] = '${_SHLIBVERSION}${SHLIBSUFFIX}'
env[
'__SHLIBVERSIONFLAGS'] = '${__lib_either_version_flag(__env__,'\
'"SHLIBVERSION","_APPLELINK_CURRENT_VERSION", "_SHLIBVERSIONFLAGS")}'
env[
'__LDMODULEVERSIONFLAGS'] = '${__lib_either_version_flag(__env__,'\
'"LDMODULEVERSION","_APPLELINK_CURRENT_VERSION", "_LDMODULEVERSIONFLAGS")}'
def generate(env):
cppTool.generate(env)
if not env.get('CXXVERSION'):
try:
line = os.popen("/bin/bash -c 'icc --version 2>&1'").readline()
env['CXXVERSION'] = re.compile(r'[^(]*[^)]*\) ([^\n ]*)').findall(
line)[0]
except:
env['CXXVERSION'] = '10.1'
env['COMPILER'] = 'icc-' + env['CXXVERSION']
env['CXXFLAGS'] = CLVar('-fno-strict-aliasing -ftemplate-depth-200')
if is64Bit():
env.Append(CPPDEFINES=CLVar('OS_64BIT'))
if env['DEBUG']:
env.Append(CXXFLAGS=['-g'])
else:
env.Append(CXXFLAGS=['-O3', '-xHost'])
if env['OPENMP']:
env.Append(CXXFLAGS=['-fopenmp'])
if env['PARALLEL']:
env['CXX'] = 'mpicxx'
env.Append(CXXFLAGS=['-DFVM_PARALLEL'])
# bug fix for mpich
env.Append(CXXFLAGS=['-DMPICH_IGNORE_CXX_SEEK'])
else:
env['CXX'] = 'icpcc'
#env['CCFLAGS'] = env['CXXFLAGS']
env['SHCXXFLAGS'] = CLVar('$CXXFLAGS -fPIC')
def createSwigModule(self,
target,
sources=[],
deplibs=[],
atype=None,
**kwargs):
env = self.myClone()
env.loadTools(['swig'])
env.Append(CPPPATH=['$AUTOGENDIR'])
env['SHLIBPREFIX'] = ""
if env['PARALLEL']:
env.AppendUnique(
SWIGFLAGS=CLVar('-DFVM_PARALLEL -c++ -python -module %s' %
target))
else:
env.AppendUnique(SWIGFLAGS=CLVar('-c++ -python -module %s' %
target))
env['SWIGOUTDIR'] = '$COMPONENTTARGETDIR'
env.AppendUnique(CPPDEFINES='RLOG_COMPONENT=%s' % target)
deplibs += ['python']
env._updateEnv(target, deplibs, atype, True)
# wrapSources = [ swigre.sub(r'\1_wrap.cc', source) for source in sources]
nodes = env.SharedLibrary('$COMPONENTTARGETDIR/_' + target,
sources,
targetAType=atype,
**kwargs)
#self._addTarget(wrapSources)
self._addTarget(nodes)
return nodes
def generate(env):
SCons.Tool.gnulink.generate(env)
env['LINKFLAGS'] = CLVar('-rdynamic')
if env['DEBUG']:
env.Append(LINKFLAGS=['-g'])
elif env['PROFILE']:
env.Append(LINKFLAGS=['-lgcov', '-fprofile-arcs', '-ftest-coverage'])
env['SHLINKFLAGS'] = env['LINKFLAGS']
env.Append(SHLINKFLAGS=['-shared'])
if env['OPENMP']:
env.Append(SHLINKFLAGS=['-fopenmp'])
env['SYSLIBS'] = []
def updateEnv(env):
#default compiler suite is gcc
env['CXXVERSION'] = None
if env['COMPILER'] is None:
compilerSuite = 'gcc'
else:
c = env['COMPILER'].split('-')
compilerSuite = c[0]
if len(c) > 1:
env['CXXVERSION'] = c[1]
if compilerSuite == 'gcc':
env.loadTools(['gnulink', 'g++'])
elif compilerSuite == 'intelc':
env.loadTools(['gnulink', 'intelc'])
else:
raise UserError, 'Unknown compiler: %s' % env['COMPILER']
env.AppendUnique(CPPDEFINES=CLVar('OS_LINUX'))
def setup_shared_lib_logic(env):
"""Initialize an environment for shared library building.
Args:
env: environment to set up
"""
createSharedLibBuilder(env)
env["_get_shlib_stem"] = _get_shlib_stem
env["_get_shlib_dir"] = _get_shlib_dir
env["_SHLIBSOVERSION"] = _soversion
env["_SHLIBSONAME"] = _soname
env["SHLIBNAME"] = "${_get_shlib_dir}${SHLIBPREFIX}$_get_shlib_stem${_SHLIBSUFFIX}"
# This is the non versioned shlib filename
# If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
env["SHLIB_NOVERSION_SYMLINK"] = "${_get_shlib_dir}${SHLIBPREFIX}$_get_shlib_stem${SHLIBSUFFIX}"
# This is the sonamed file name
# If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
env["SHLIB_SONAME_SYMLINK"] = "${_get_shlib_dir}$_SHLIBSONAME"
# Note this is gnu style
env["SHLIBSONAMEFLAGS"] = "-Wl,-soname=$_SHLIBSONAME"
env["_SHLIBVERSION"] = "${SHLIBVERSION and '.'+SHLIBVERSION or ''}"
env["_SHLIBVERSIONFLAGS"] = "$SHLIBVERSIONFLAGS -Wl,-soname=$_SHLIBSONAME"
env["SHLIBEMITTER"] = [lib_emitter, shlib_symlink_emitter]
# If it's already set, then don't overwrite.
env["SHLIBPREFIX"] = env.get('SHLIBPREFIX', "lib")
env["_SHLIBSUFFIX"] = "${SHLIBSUFFIX}${_SHLIBVERSION}"
env["SHLINKFLAGS"] = CLVar("$LINKFLAGS -shared")
env["SHLINKCOM"] = "$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH $SOURCES $_LIBDIRFLAGS $_LIBFLAGS"
env["SHLINK"] = "$LINK"
def createSharedLibrary(self,
target,
sources=[],
deplibs=[],
createPublicHeader=True,
targetAType=None,
**kwargs):
env = self.myClone()
env._updateEnv(target, deplibs, targetAType)
env.AppendUnique(CPPDEFINES='RLOG_COMPONENT=%s' % target)
env.Append(CPPPATH=['$AUTOGENDIR'])
env['CURRENTLIB'] = target.upper()
if Arch.isWindows():
env.AppendUnique(CPPDEFINES=CLVar('BUILDING_' + env['CURRENTLIB']))
nodes = env.SharedLibrary('$COMPONENTTARGETDIR/' + target, sources,
**kwargs)
self._addTarget(nodes)
# if target not in self._compDirMap.keys():
# self.Alias(target, nodes)
return nodes
def generate(env):
env["SPHINX"] = env.Detect("sphinx-build") or "sphinx-build"
env["SPHINXFLAGS"] = CLVar("")
env.AddMethod(Source)
env.AddMethod(HTML)
def buildCUnitTestFromFiles (env,
files,
buildFolder = "",
vars = None,
extraObjects = [],
package="cunit",
**kwargs):
# Create the Builders
env.Append (BUILDERS = {
"CUTestSuite":
env.Builder (action = env.Action (__makeCUTestSuite, "$$CUTESTSUITESTR"),
prefix = "cunit_",
single_source = True),
"CUMainSource":
env.Builder (action = env.Action (__makeCUMainSource,
"$$CUMAINSOURCESTR"),
emitter = __emitCUMainSource)
},
CUTESTSUITESTR = \
("Creating source for test suite '${CU_SUITE_NAME}'..."),
CUMAINSOURCESTR = \
("Creating main CUnit source file..."))
# Create the source files for the suites
suites = set()
sources = []
for source in files:
path, base = os.path.split (source)
suiteName = os.path.splitext (base)[0]
sources.append (env.CUTestSuite (os.path.join (buildFolder, "cunit_%s" % base),
source,
CU_SUITE_NAME = suiteName,
**kwargs))
suites.add (suiteName)
# Create the main source file
sources.append (env.CUMainSource (os.path.join (buildFolder, "cutest_main.c"),
env.Value (suites), **kwargs))
# Build the test program
from SCons.Util import CLVar
libs = kwargs.get ("LIBS", None)
if libs:
del kwargs["LIBS"]
libs = CLVar (libs) + "cunit"
else:
libs = CLVar (env.get ("LIBS", [])) + "cunit"
cutest = env.Program (os.path.join (buildFolder, package + "-test"),
sources + extraObjects,
LIBS = libs,
**kwargs)[0]
# Cleanup the coverage data.
# - *.gcno files are generated along with the object files and
# contain function information. They must be cleaned along with
# the associated object;
# - *.gcda files are generated when running the program. They must
# be deleted each time the program is rebuilt, and cleaned along
# with the related object.
if env.get("coverage"):
env["CLEANUP_COVERAGE_DATA_STR"] = \
("Cleaning coverage data for ${TARGET.name}...")
objects = env.Flatten (sources + extraObjects)
cutest.cuObjects = objects
env.AddPreAction (cutest,
env.Action (__cleanupCoverageData,
"$$CLEANUP_COVERAGE_DATA_STR"))
for o in objects:
baseName = os.path.splitext (o.path)[0]
env.Clean (o, "#%s.gcda" % baseName)
env.Clean (o, "#%s.gcno" % baseName)
env.SideEffect ("#%s.gcno" % baseName, o)
return cutest
def generate(env):
env['SPHINX'] = env.Detect('sphinx-build') or 'sphinx-build'
env['SPHINXFLAGS'] = CLVar('')
env.AddMethod(Source)
env.AddMethod(HTML)
def test_CLVar(self):
"""Test the command-line construction variable class"""
# the default value should be an empty list
d = CLVar()
assert isinstance(d, CLVar), type(d)
assert d.data == [], d.data
assert str(d) == '', str(d)
# input to CLVar is a string - should be split
f = CLVar('aa bb')
r = f + 'cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ' cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', ' cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', ' cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
# input to CLVar is a list of one string, should not be split
f = CLVar(['aa bb'])
r = f + 'cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ' cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', 'cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', ' cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa bb', ' cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
# input to CLVar is a list of strings
f = CLVar(['aa', 'bb'])
r = f + 'cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ' cc dd'
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', ' cc dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + ['cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', 'cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
r = f + [' cc', 'dd']
assert isinstance(r, CLVar), type(r)
assert r.data == ['aa', 'bb', ' cc', 'dd'], r.data
assert str(r) == 'aa bb cc dd', str(r)
# make sure inplace adding a string works as well (issue 2399)
# UserList would convert the string to a list of chars
f = CLVar(['aa', 'bb'])
f += 'cc dd'
assert isinstance(f, CLVar), type(f)
assert f.data == ['aa', 'bb', 'cc', 'dd'], f.data
assert str(f) == 'aa bb cc dd', str(f)
f = CLVar(['aa', 'bb'])
f += ' cc dd'
assert isinstance(f, CLVar), type(f)
assert f.data == ['aa', 'bb', 'cc', 'dd'], f.data
assert str(f) == 'aa bb cc dd', str(f)
def generate(env, **kw):
occbuild = kw.get('occbuild', None)
if occbuild:
occbuild_path = occbuild[0].abspath
depend_emitter = lambda target, source, env: occbuild_depend_emitter(
target, source, env, occbuild)
else:
occbuild_path = 'occbuild'
depend_emitter = None
pideps_scanner = Scanner(function=pideps_scan,
skeys=['.occ'],
path_function=FindPathDirs('INCPATH'))
tce_bld = Builder(action=Action('$OCCBUILDCOM', '$OCCBUILDCOMSTR'),
emitter=depend_emitter,
suffix='.tce',
src_suffix='.occ')
# FIXME: The source scanner does not work well enough yet :/
#source_scanner = pideps_scanner)
lib_bld = Builder(action=Action('$OCCBUILDLIBRARYCOM',
'$OCCBUILDLIBRARYCOMSTR'),
emitter=[depend_emitter, occbuild_library_emitter],
suffix='.lib',
src_suffix='.tce',
src_builder=[tce_bld])
prog_bld = Builder(
action=Action('$OCCBUILDPROGRAMCOM', '$OCCBUILDPROGRAMCOMSTR'),
emitter=[depend_emitter, occbuild_program_emitter],
suffix='$PROGSUFFIX',
src_suffix=['.occ', '.tce'],
# FIXME: If I leave the sourcebuilder in, scons seems to
# want to turn my .occ extensions when I have a mixed
# .occ, .tce source list into .tce using the builder
) #src_builder = [tce_bld])
tbc_headr_bld = Builder(action=Action('$TBCHEADERCOM', '$TBCHEADERCOMSTR'),
emitter=[depend_emitter],
suffix='.h',
src_suffix=['.occ', '.tce'],
src_bulider=[tce_bld])
# Add the new Builder to the list of builders
# Use of $( $) causes bracketed flags not trigger rebuild when changed
env['BUILDERS']['OccamObject'] = tce_bld
env['OCCBUILDCOM'] = '$OCCBUILD $_OCCBUILD_TOOLCHAIN $_OCCBUILD_SEARCH_DIRS $OCCBUILDFLAGS --object $SOURCES'
env['BUILDERS']['OccamLibrary'] = lib_bld
env['OCCBUILDLIBRARYCOM'] = '$OCCBUILD $_OCCBUILD_TOOLCHAIN $_OCCBUILD_SEARCH_DIRS $OCCBUILDFLAGS --library $TARGET $SOURCES'
env['BUILDERS']['OccamProgram'] = prog_bld
env['OCCBUILDPROGRAMCOM'] = '$OCCBUILD $_OCCBUILD_TOOLCHAIN $_OCCBUILD_SEARCH_DIRS $OCCBUILDFLAGS --program $SOURCES'
env['BUILDERS']['OccamBytecodeHeader'] = tbc_headr_bld
env['TBCHEADERCOM'] = '$SKROC $_SKROC_SEARCH_DIRS $SKROCFLAGS --c -f $TARGET $SOURCES'
env['OCCBUILD'] = occbuild_path
env['_OCCBUILD_SEARCH_DIRS'] = '$( ${_concat(OCCBUILD_SEARCH_PFX, INCPATH, "", __env__, RDirs, TARGET, SOURCE)} $)'
env['_SKROC_SEARCH_DIRS'] = '$( ${_concat(SKROC_SEARCH_PFX, INCPATH, "", __env__, RDirs, TARGET, SOURCE)} $)'
env['OCCBUILD_SEARCH_PFX'] = '--search '
env['SKROC_SEARCH_PFX'] = '-L '
env['OCCBUILD_TOOLCHAIN'] = None
env['_OCCBUILD_TOOLCHAIN'] = '${(OCCBUILD_TOOLCHAIN and "--toolchain $OCCBUILD_TOOLCHAIN" or "")}'
def OccLibDepend(self, node, lib_name):
if not isinstance(lib_name, list): list(lib_name)
for lib in lib_name:
self.Depends(node, self['OCCLIBS'][lib]['dep'])
if 'inc' in self['OCCLIBS'][lib]:
for n in node:
n.env.AppendUnique(INCPATH=self['OCCLIBS'][lib]['inc'])
env.AddMethod(OccLibDepend)
env['OCCLIBS'] = dict()
env['INCPATH'] = CLVar('')
env['OCCBUILDFLAGS'] = CLVar('')
