mirror of
https://git.rtems.org/rtems-libbsd/
synced 2025-05-13 05:05:04 +08:00
9d65f34b75
There was a typo in the patch that added the HAVE_<LIBRARY> definition that prevented "./waf configure" from succeeding. This adds the missing character.
601 lines
23 KiB
Python
601 lines
23 KiB
Python
# SPDX-License-Identifier: BSD-2-Clause
|
|
"""LibBSD build configuration to waf integration module.
|
|
"""
|
|
|
|
# Copyright (c) 2015, 2020 Chris Johns <chrisj@rtems.org>. All rights reserved.
|
|
#
|
|
# Copyright (c) 2009, 2015 embedded brains GmbH. All rights reserved.
|
|
#
|
|
# embedded brains GmbH
|
|
# Dornierstr. 4
|
|
# 82178 Puchheim
|
|
# Germany
|
|
# <info@embedded-brains.de>
|
|
#
|
|
# Copyright (c) 2012 OAR Corporation. All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
from __future__ import print_function
|
|
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import re
|
|
|
|
import builder
|
|
|
|
import rtems_waf.rtems as rtems
|
|
|
|
|
|
BUILDSET_DIR = builder.BUILDSET_DIR
|
|
BUILDSET_DEFAULT = builder.BUILDSET_DEFAULT
|
|
|
|
windows = os.name == 'nt'
|
|
|
|
if windows:
|
|
host_shell = 'sh -c '
|
|
else:
|
|
host_shell = ''
|
|
|
|
def _add_flags_if_not_present(current_flags, addional_flags):
|
|
for flag in addional_flags:
|
|
if flag not in current_flags:
|
|
current_flags.append(flag)
|
|
|
|
#
|
|
# The waf builder for libbsd.
|
|
#
|
|
class Builder(builder.ModuleManager):
|
|
def __init__(self, trace=False):
|
|
super(Builder, self).__init__()
|
|
self.trace = trace
|
|
self.data = {}
|
|
|
|
@staticmethod
|
|
def _sourceList(bld, files):
|
|
sources = []
|
|
if type(files) is dict:
|
|
for cfg in files:
|
|
if cfg in ['cflags', 'includes']:
|
|
continue
|
|
if cfg != 'default':
|
|
for c in cfg.split(' '):
|
|
if not bld.env['HAVE_%s' % (c)]:
|
|
continue
|
|
sources += sorted(files[cfg])
|
|
else:
|
|
sources = sorted(files)
|
|
return sources
|
|
|
|
def generate(self, rtems_version):
|
|
def _dataInsert(data, cpu, space, frag):
|
|
#
|
|
# The default handler returns None. Skip it.
|
|
#
|
|
if frag is not None:
|
|
# Start at the top of the tree
|
|
d = data
|
|
path = frag[0]
|
|
if path[0] not in d:
|
|
d[path[0]] = {}
|
|
# Select the sub-part of the tree as the compile options
|
|
# specialise how files are built.
|
|
d = d[path[0]]
|
|
# Group based on the space, ie kernel or user
|
|
if space not in d:
|
|
d[space] = {}
|
|
d = d[space]
|
|
if type(path[1]) is list:
|
|
p = ' '.join(path[1])
|
|
else:
|
|
p = path[1]
|
|
if p not in d:
|
|
d[p] = {}
|
|
d = d[p]
|
|
if cpu not in d:
|
|
d[cpu] = {}
|
|
config = frag[0][2][0]
|
|
if config != 'default':
|
|
if 'configure' not in data:
|
|
data['configure'] = {}
|
|
configTest = frag[1]['configTest']
|
|
if configTest not in data['configure']:
|
|
data['configure'][configTest] = {}
|
|
data['configure'][configTest][config] = frag[0][2][1]
|
|
if type(frag[1]) is list:
|
|
if config not in d[cpu]:
|
|
d[cpu][config] = []
|
|
d[cpu][config] += frag[1]
|
|
else:
|
|
d[cpu][config] = frag[1]
|
|
#
|
|
# The CPU is for files and the flags and includes are common.
|
|
#
|
|
if len(frag) > 3:
|
|
if 'cflags' not in d:
|
|
d['cflags'] = []
|
|
d['cflags'] += frag[2]
|
|
d['cflags'] = list(set(d['cflags']))
|
|
if len(frag) >= 3 and None not in frag[-1]:
|
|
if 'includes' not in d:
|
|
d['includes'] = []
|
|
d['includes'] += frag[-1]
|
|
d['includes'] = list(set(d['includes']))
|
|
|
|
self.generateBuild()
|
|
|
|
self.data = {}
|
|
|
|
enabled_modules = self.getEnabledModules()
|
|
for mn in enabled_modules:
|
|
m = self[mn]
|
|
enabled = True
|
|
for dep in m.dependencies:
|
|
if dep not in enabled_modules:
|
|
enabled = False
|
|
break
|
|
if enabled:
|
|
for f in m.files:
|
|
_dataInsert(self.data, 'all', f.getSpace(),
|
|
f.getFragment())
|
|
for cpu, files in sorted(m.cpuDependentSourceFiles.items()):
|
|
for f in files:
|
|
_dataInsert(self.data, cpu, f.getSpace(),
|
|
f.getFragment())
|
|
|
|
# Start here if you need to understand self.data. Add 'True or'
|
|
if self.trace:
|
|
import pprint
|
|
pprint.pprint(self.data)
|
|
|
|
def bsp_configure(self, conf, arch_bsp):
|
|
if 'configure' in self.data:
|
|
for configTest in self.data['configure']:
|
|
for cfg in self.data['configure'][configTest]:
|
|
if configTest == 'header':
|
|
for h in self.data['configure'][configTest][cfg]:
|
|
conf.check(header_name=h,
|
|
features="c",
|
|
includes=conf.env.IFLAGS,
|
|
mandatory=False)
|
|
elif configTest == 'library':
|
|
for l in self.data['configure'][configTest][cfg]:
|
|
if conf.check_cc(lib=l,
|
|
fragment=rtems.test_application(),
|
|
execute=False,
|
|
mandatory=False):
|
|
conf.env['HAVE_%s' % l.upper()] = True
|
|
else:
|
|
bld.fatal('invalid config test: %s' % (configTest))
|
|
section_flags = ["-fdata-sections", "-ffunction-sections"]
|
|
_add_flags_if_not_present(conf.env.CFLAGS, section_flags)
|
|
_add_flags_if_not_present(conf.env.CXXFLAGS, section_flags)
|
|
_add_flags_if_not_present(conf.env.LINKFLAGS, ["-Wl,--gc-sections"])
|
|
|
|
def build(self, bld):
|
|
#
|
|
# Localize the config.
|
|
#
|
|
config = self.getConfiguration()
|
|
module_header_path = "rtems/bsd"
|
|
module_header_name = "modules.h"
|
|
|
|
#
|
|
#
|
|
# C/C++ flags
|
|
#
|
|
common_flags = []
|
|
common_flags += ['-O%s' % (bld.env.OPTIMIZATION)]
|
|
if 'common-flags' in config:
|
|
common_flags += [f for f in config['common-flags']]
|
|
if bld.env.WARNINGS and 'common-warnings' in config:
|
|
common_flags += [f for f in config['common-warnings']]
|
|
elif 'common-no-warnings' in config:
|
|
common_flags += [f for f in config['common-no-warnings']]
|
|
if 'cflags' in config:
|
|
cflags = config['cflags'] + common_flags
|
|
if 'cxxflags' in config:
|
|
cxxflags = config['cxxflags'] + common_flags
|
|
|
|
#
|
|
# Defines
|
|
#
|
|
defines = []
|
|
if len(bld.env.FREEBSD_OPTIONS) > 0:
|
|
for o in bld.env.FREEBSD_OPTIONS.split(','):
|
|
defines += ['%s=1' % (o.strip().upper())]
|
|
|
|
#
|
|
# Include paths, maintain paths for each build space.
|
|
#
|
|
include_paths = config['include-paths']
|
|
if 'build' not in include_paths:
|
|
bld.fatal('no build include path found in include-path defaults')
|
|
buildinclude = include_paths['build']
|
|
if isinstance(buildinclude, list):
|
|
buildinclude = buildinclude[0]
|
|
inc_paths = sorted(include_paths)
|
|
inc_paths.remove('build')
|
|
inc_paths.remove('cpu')
|
|
includes = {}
|
|
for inc in inc_paths:
|
|
includes[inc] = include_paths[inc]
|
|
# cpu include paths must be the first searched
|
|
if 'cpu' in include_paths:
|
|
cpu = bld.get_env()['RTEMS_ARCH']
|
|
for i in include_paths['cpu']:
|
|
includes['kernel'].insert(0, i.replace('@CPU@', cpu))
|
|
includes['kernel'] += [buildinclude]
|
|
|
|
#
|
|
# Path mappings
|
|
#
|
|
if 'path-mappings' in config:
|
|
for source, target in config['path-mappings']:
|
|
for space in includes:
|
|
incs = includes[space]
|
|
if source in incs:
|
|
target = [target] if isinstance(target,
|
|
str) else target
|
|
i = incs.index(source)
|
|
incs.remove(source)
|
|
incs[i:i] = target
|
|
|
|
#
|
|
# Place the kernel include paths after the user paths
|
|
#
|
|
includes['user'] += includes['kernel']
|
|
|
|
#
|
|
# Collect the libbsd uses
|
|
#
|
|
libbsd_use = []
|
|
|
|
#
|
|
# Network test configuration
|
|
#
|
|
if not os.path.exists(bld.env.NET_CONFIG):
|
|
bld.fatal('network configuraiton \'%s\' not found' %
|
|
(bld.env.NET_CONFIG))
|
|
tags = [
|
|
'NET_CFG_INTERFACE_0', 'NET_CFG_SELF_IP', 'NET_CFG_NETMASK',
|
|
'NET_CFG_PEER_IP', 'NET_CFG_GATEWAY_IP'
|
|
]
|
|
try:
|
|
net_cfg_lines = open(bld.env.NET_CONFIG).readlines()
|
|
except:
|
|
bld.fatal('network configuraiton \'%s\' read failed' %
|
|
(bld.env.NET_CONFIG))
|
|
lc = 0
|
|
sed = 'sed '
|
|
for l in net_cfg_lines:
|
|
lc += 1
|
|
if l.strip().startswith('NET_CFG_'):
|
|
ls = l.split('=')
|
|
if len(ls) != 2:
|
|
bld.fatal('network configuraiton \'%s\' ' + \
|
|
'parse error: %d: %s' % (bld.env.NET_CONFIG, lc, l))
|
|
lhs = ls[0].strip()
|
|
rhs = ls[1].strip()
|
|
for t in tags:
|
|
if lhs == t:
|
|
sed += "-e 's/@%s@/%s/' " % (t, rhs)
|
|
bld(target="testsuite/include/rtems/bsd/test/network-config.h",
|
|
source="testsuite/include/rtems/bsd/test/network-config.h.in",
|
|
rule=sed + " < ${SRC} > ${TGT}",
|
|
update_outputs=True)
|
|
|
|
#
|
|
# Add a copy rule for all headers where the install path and the source
|
|
# path are not the same.
|
|
#
|
|
if 'header-paths' in config:
|
|
header_build_copy_paths = [
|
|
hp for hp in config['header-paths']
|
|
if hp[2] != '' and not hp[0].endswith(hp[2])
|
|
]
|
|
for headers in header_build_copy_paths:
|
|
target = os.path.join(buildinclude, headers[2])
|
|
start_dir = bld.path.find_dir(headers[0])
|
|
for header in start_dir.ant_glob(headers[1]):
|
|
relsourcepath = header.path_from(start_dir)
|
|
targetheader = os.path.join(target, relsourcepath)
|
|
bld(features='subst',
|
|
target=targetheader,
|
|
source=header,
|
|
is_copy=True)
|
|
|
|
#
|
|
# Generate a header that contains information about enabled modules
|
|
#
|
|
def rtems_libbsd_modules_h_gen(self):
|
|
output = ""
|
|
output += '/*\n'
|
|
output += ' * This file contains a list of modules that have been\n'
|
|
output += ' * enabled during libbsd build. It is a generated file\n'
|
|
output += ' * DO NOT EDIT MANUALLY.\n'
|
|
output += ' */'
|
|
output += '\n'
|
|
output += '#ifndef RTEMS_BSD_MODULES_H\n'
|
|
for mod in config['modules-enabled']:
|
|
modname = re.sub("[^A-Za-z0-9]", "_", mod.upper())
|
|
output += '#define RTEMS_BSD_MODULE_{} 1\n'.format(modname)
|
|
output += '#endif /* RTEMS_BSD_MODULES_H */\n'
|
|
self.outputs[0].write(output)
|
|
|
|
modules_h_file_with_path = os.path.join(buildinclude,
|
|
module_header_path,
|
|
module_header_name)
|
|
bld(rule=rtems_libbsd_modules_h_gen,
|
|
target=modules_h_file_with_path,
|
|
before=['c', 'cxx'])
|
|
|
|
#
|
|
# Add the specific rule based builders
|
|
#
|
|
|
|
#
|
|
# KVM Symbols
|
|
#
|
|
if 'KVMSymbols' in self.data:
|
|
kvmsymbols = self.data['KVMSymbols']['kernel']
|
|
if 'includes' in kvmsymbols['files']:
|
|
kvmsymbols_includes = kvmsymbols['files']['includes']
|
|
else:
|
|
kvmsymbols_includes = []
|
|
bld(target=kvmsymbols['files']['all']['default'][0],
|
|
source='rtemsbsd/rtems/generate_kvm_symbols',
|
|
rule=host_shell + './${SRC} > ${TGT}',
|
|
update_outputs=True)
|
|
bld.objects(target='kvmsymbols',
|
|
features='c',
|
|
cflags=cflags,
|
|
includes=kvmsymbols_includes + includes['kernel'],
|
|
source=kvmsymbols['files']['all']['default'][0])
|
|
libbsd_use += ["kvmsymbols"]
|
|
|
|
bld.add_group()
|
|
|
|
#
|
|
# RPC Generation
|
|
#
|
|
if 'RPCGen' in self.data:
|
|
if bld.env.AUTO_REGEN:
|
|
rpcgen = self.data['RPCGen']['user']
|
|
rpcname = rpcgen['files']['all']['default'][0][:-2]
|
|
bld(target=rpcname + '.h',
|
|
source=rpcname + '.x',
|
|
rule=host_shell + '${RPCGEN} -h -o ${TGT} ${SRC}')
|
|
|
|
#
|
|
# Route keywords
|
|
#
|
|
if 'RouteKeywords' in self.data:
|
|
if bld.env.AUTO_REGEN:
|
|
routekw = self.data['RouteKeywords']['user']
|
|
rkwname = routekw['files']['all']['default'][0]
|
|
rkw_rule = host_shell + "cat ${SRC} | " + \
|
|
"awk 'BEGIN { r = 0 } { if (NF == 1) " + \
|
|
"printf \"#define\\tK_%%s\\t%%d\\n\\t{\\\"%%s\\\", K_%%s},\\n\", " + \
|
|
"toupper($1), ++r, $1, toupper($1)}' > ${TGT}"
|
|
bld(target=rkwname + '.h', source=rkwname, rule=rkw_rule)
|
|
|
|
#
|
|
# Lex
|
|
#
|
|
if 'lex' in self.data:
|
|
lexes = self.data['lex']['user']
|
|
for l in sorted(lexes.keys()):
|
|
lex = lexes[l]['all']['default']
|
|
if 'cflags' in lex:
|
|
lexDefines = [d[2:] for d in lex['cflags']]
|
|
else:
|
|
lexDefines = []
|
|
if 'includes' in lex:
|
|
lexIncludes = lex['includes']
|
|
else:
|
|
lexIncludes = []
|
|
lex_rule = host_shell + '${LEX} -P ' + lex['sym'] + ' -t ${SRC} | ' + \
|
|
'sed -e \'/YY_BUF_SIZE/s/16384/1024/\' > ${TGT}'
|
|
if bld.env.AUTO_REGEN:
|
|
bld(target=lex['file'][:-2] + '.c',
|
|
source=lex['file'],
|
|
rule=lex_rule)
|
|
if lex['build']:
|
|
bld.objects(target='lex_%s' % (lex['sym']),
|
|
features='c',
|
|
cflags=cflags,
|
|
includes=lexIncludes + includes['user'],
|
|
defines=defines + lexDefines,
|
|
source=lex['file'][:-2] + '.c')
|
|
libbsd_use += ['lex_%s' % (lex['sym'])]
|
|
|
|
#
|
|
# Yacc
|
|
#
|
|
if 'yacc' in self.data:
|
|
yaccs = self.data['yacc']['user']
|
|
for y in sorted(yaccs.keys()):
|
|
yacc = yaccs[y]['all']['default']
|
|
yaccFile = yacc['file']
|
|
if yacc['sym'] is not None:
|
|
yaccSym = yacc['sym']
|
|
else:
|
|
yaccSym = os.path.basename(yaccFile)[:-2]
|
|
yaccHeader = '%s/%s' % (os.path.dirname(yaccFile),
|
|
yacc['header'])
|
|
if 'cflags' in yacc:
|
|
yaccDefines = [d[2:] for d in yacc['cflags']]
|
|
else:
|
|
yaccDefines = []
|
|
if 'includes' in yacc:
|
|
yaccIncludes = yacc['includes']
|
|
else:
|
|
yaccIncludes = []
|
|
yacc_rule = host_shell + '${YACC} -b ' + yaccSym + \
|
|
' -d -p ' + yaccSym + ' ${SRC} && ' + \
|
|
'sed -e \'/YY_BUF_SIZE/s/16384/1024/\' < ' + \
|
|
yaccSym + '.tab.c > ${TGT} && ' + \
|
|
'rm -f ' + yaccSym + '.tab.c && mv ' + yaccSym + '.tab.h ' + yaccHeader
|
|
if bld.env.AUTO_REGEN:
|
|
bld(target=yaccFile[:-2] + '.c',
|
|
source=yaccFile,
|
|
rule=yacc_rule)
|
|
if yacc['build']:
|
|
bld.objects(target='yacc_%s' % (yaccSym),
|
|
features='c',
|
|
cflags=cflags,
|
|
includes=yaccIncludes + includes['user'],
|
|
defines=defines + yaccDefines,
|
|
source=yaccFile[:-2] + '.c')
|
|
libbsd_use += ['yacc_%s' % (yaccSym)]
|
|
|
|
#
|
|
# We have 'm' different sets of flags and there can be 'n' cpus
|
|
# specific files for those flags.
|
|
#
|
|
objs = 0
|
|
for space in sorted(self.data['sources']):
|
|
sources = sorted(self.data['sources'][space])
|
|
if space == 'kernel' and 'default' in sources:
|
|
sources.remove('default')
|
|
for flags in sources:
|
|
objs += 1
|
|
build = self.data['sources'][space][flags]
|
|
target = 'objs%02d' % (objs)
|
|
bld_sources = Builder._sourceList(bld, build['all'])
|
|
archs = sorted(build)
|
|
for i in ['all', 'cflags', 'includes']:
|
|
if i in archs:
|
|
archs.remove(i)
|
|
for arch in archs:
|
|
if bld.get_env()['RTEMS_ARCH'] == arch:
|
|
bld_sources += Builder._sourceList(bld, build[arch])
|
|
bld_cflags = sorted(build.get('cflags', []))
|
|
if 'default' in bld_cflags:
|
|
bld_cflags.remove('default')
|
|
bld.objects(target=target,
|
|
features='c cxx',
|
|
cflags=cflags + bld_cflags,
|
|
cxxflags=cxxflags,
|
|
includes=sorted(build.get('includes', [])) +
|
|
includes[space],
|
|
defines=defines,
|
|
source=bld_sources)
|
|
libbsd_use += [target]
|
|
|
|
#
|
|
# We hold the kernel 'default' cflags set of files to the end to
|
|
# create the static library with.
|
|
#
|
|
build = self.data['sources']['kernel']['default']
|
|
bld_sources = Builder._sourceList(bld, build['all'])
|
|
archs = sorted(build)
|
|
archs.remove('all')
|
|
for arch in archs:
|
|
if bld.get_env()['RTEMS_ARCH'] == arch:
|
|
bld_sources += Builder._sourceList(bld, build[arch])
|
|
bld.stlib(target='bsd',
|
|
features='c cxx',
|
|
cflags=cflags,
|
|
cxxflags=cxxflags,
|
|
includes=includes['kernel'],
|
|
defines=defines,
|
|
source=bld_sources,
|
|
use=libbsd_use)
|
|
|
|
#
|
|
# Installs.
|
|
#
|
|
# Header file collector.
|
|
#
|
|
arch_lib_path = rtems.arch_bsp_lib_path(bld.env.RTEMS_VERSION,
|
|
bld.env.RTEMS_ARCH_BSP)
|
|
arch_inc_path = rtems.arch_bsp_include_path(bld.env.RTEMS_VERSION,
|
|
bld.env.RTEMS_ARCH_BSP)
|
|
|
|
bld.install_files("${PREFIX}/" + arch_lib_path, ["libbsd.a"])
|
|
|
|
if 'header-paths' in config:
|
|
headerPaths = config['header-paths']
|
|
cpu = bld.get_env()['RTEMS_ARCH']
|
|
for headers in headerPaths:
|
|
paths = [headers[0].replace('@CPU@', cpu)]
|
|
# Apply the path mappings
|
|
for source, targets in config['path-mappings']:
|
|
if source in paths:
|
|
i = paths.index(source)
|
|
paths.remove(source)
|
|
paths[i:i] = targets
|
|
|
|
for hp in paths:
|
|
# Get the dest path
|
|
ipath = os.path.join(arch_inc_path, headers[2])
|
|
start_dir = bld.path.find_dir(hp)
|
|
if start_dir != None:
|
|
bld.install_files("${PREFIX}/" + ipath,
|
|
start_dir.ant_glob(headers[1]),
|
|
cwd=start_dir,
|
|
relative_trick=True)
|
|
|
|
bld.install_files(os.path.join("${PREFIX}", arch_inc_path,
|
|
module_header_path),
|
|
modules_h_file_with_path,
|
|
cwd=bld.path)
|
|
|
|
#
|
|
# Tests
|
|
#
|
|
tests = []
|
|
if 'tests' in self.data:
|
|
tests = self.data['tests']['user']
|
|
enabled_modules = self.getEnabledModules()
|
|
for testName in sorted(tests):
|
|
test = tests[testName]['all']
|
|
test_source = []
|
|
libs = ['bsd', 'm', 'z', 'rtemstest']
|
|
for cfg in test:
|
|
build_test = True
|
|
for mod in test[cfg]['modules']:
|
|
if mod not in enabled_modules:
|
|
build_test = False
|
|
break
|
|
if build_test and cfg != 'default':
|
|
for c in cfg.split(' '):
|
|
if not bld.env['HAVE_%s' % (c)]:
|
|
build_test = False
|
|
break
|
|
if build_test:
|
|
test_sources = ['testsuite/%s/%s.c' % (testName, f) \
|
|
for f in test[cfg]['files']]
|
|
libs = test[cfg]['libs'] + libs
|
|
if build_test:
|
|
bld.program(target='%s.exe' % (testName),
|
|
features='cprogram',
|
|
cflags=cflags,
|
|
includes=includes['user'],
|
|
source=test_sources,
|
|
use=['bsd'],
|
|
lib=libs,
|
|
install_path=None)
|