def build(phase):
pthread_h = config_call('fbuild.config.c.posix.pthread_h',
phase.platform,
phase.cxx.shared)
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h',
phase.platform,
phase.cxx.static,
phase.cxx.shared)
flags = []
libs=[call('buildsystem.sqlite3.build_runtime', phase, phase).static]
external_libs = []
path = Path('src/tools')
dst = phase.ctx.buildroot / 'bin/flx_sqlite3'
srcs = [path / 'flx_sqlite3.c']
includes = [ phase.ctx.buildroot / 'lib/rtl', phase.ctx.buildroot / 'config/target' ]
if dlfcn_h.dlopen:
external_libs.extend ( dlfcn_h.external_libs)
if pthread_h.pthread_create:
flags.extend(pthread_h.flags)
libs.extend(pthread_h.libs)
external_libs.extend(pthread_h.external_libs)
return Record (
static = phase.c.static.build_exe(dst, srcs,
includes=includes,
cflags=flags,
libs=libs,
external_libs=external_libs)
)
def _print_gcc_extensions(platform, lang, p):
gcc = config_call('fbuild.config.c.gnu.extensions', platform, lang.static)
have_gnu_x86 = gcc.named_registers_x86 and not gcc.named_registers_x86_64
p('HAVE_CGOTO', gcc.computed_gotos)
p('HAVE_ASM_LABELS', gcc.asm_labels)
p('HAVE_GNU_BUILTIN_EXPECT', bool(gcc.builtin_expect))
hash_map = config_call('fbuild.config.cxx.gnu.gcc_cxx_hash_map',
platform, lang.static)
p('HAVE_STL_GNU_CXX', hash_map.header)
def _print_gcc_extensions(platform, lang, p):
gcc = config_call('fbuild.config.c.gnu.extensions', platform, lang.static)
have_gnu_x86 = gcc.named_registers_x86 and not gcc.named_registers_x86_64
p('HAVE_CGOTO', gcc.computed_gotos)
p('HAVE_ASM_LABELS', gcc.asm_labels)
p('HAVE_GNU_BUILTIN_EXPECT', bool(gcc.builtin_expect))
hash_map = config_call('fbuild.config.cxx.gnu.gcc_cxx_hash_map', platform,
lang.static)
p('HAVE_STL_GNU_CXX', hash_map.header)
def _print_openmp_support(ctx, platform, lang, p):
try:
static = config_call("fbuild.builders.c.openmp.config", platform, ctx, lang.static)
except ConfigFailed:
static = {}
try:
shared = config_call("fbuild.builders.c.openmp.config", platform, ctx, lang.shared)
except ConfigFailed:
shared = {}
p("HAVE_OPENMP", bool(static) or bool(shared))
p("HAVE_STATIC_OPENMP", bool(static))
p("HAVE_SHARED_OPENMP", bool(shared))
def _print_gcc_extensions(platform, lang, p):
gcc = config_call("fbuild.config.c.gnu.extensions", platform, lang.static)
have_gnu_x86 = gcc.named_registers_x86 and not gcc.named_registers_x86_64
p("HAVE_GNU_X86", have_gnu_x86)
p("HAVE_GNU_X86_64", gcc.named_registers_x86_64)
p("HAVE_CGOTO", gcc.computed_gotos)
p("HAVE_ASM_LABELS", gcc.asm_labels)
p("HAVE_GNU_BUILTIN_EXPECT", bool(gcc.builtin_expect))
p("USE_REGPARM3", have_gnu_x86)
hash_map = config_call("fbuild.config.cxx.gnu.gcc_cxx_hash_map", platform, lang.static)
p("HAVE_STL_GNU_CXX", hash_map.header)
def _print_posix_support(platform, lang, p):
# print out information about the posix libraries
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h',
platform, lang.static, lang.shared)
if dlfcn_h.dlopen:
p('HAVE_DLOPEN', True)
p('SUPPORT_DYNAMIC_LOADING', True)
switch = list(dlfcn_h.flags)
p('DYNAMIC_LOADING_CFLAGS', ' '.join(switch))
switch=list('-L' + p for p in dlfcn_h.libpaths)
switch.extend('-l' + l for l in dlfcn_h.libs)
switch.extend('-l' + l for l in dlfcn_h.external_libs)
p('DYNAMIC_LOADING_LIBS', ' '.join(switch))
else:
p('HAVE_DLOPEN', False)
socket_h = config_call('fbuild.config.c.posix.sys_socket_h',
platform, lang.static)
if socket_h.accept:
# We strip off the trailing '*' from the socklen_t type.
p('FLX_SOCKLEN_T', socket_h.accept.args[-1][:-1])
pthread_h = config_call('fbuild.config.c.posix.pthread_h',
platform, lang.static)
if pthread_h.pthread_create:
p('HAVE_PTHREADS', True)
switch = list(pthread_h.flags)
p('PTHREAD_CFLAGS', ' '.join(switch))
switch=list('-L' + p for p in pthread_h.libpaths)
switch.extend('-l' + l for l in pthread_h.libs)
switch.extend('-l' + l for l in pthread_h.external_libs)
p('PTHREAD_LIBS', ' '.join(switch))
else:
p('HAVE_PTHREADS', False)
poll_h = config_call('fbuild.config.c.posix.poll_h',
platform, lang.static)
p('HAVE_POLL', bool(poll_h.header))
mman_h = config_call('fbuild.config.c.posix.sys_mman_h',
platform, lang.static)
p('HAVE_MMAP', bool(mman_h.header))
for name, macro in mman_h.macros():
p('HAVE_' + name, bool(macro))
event_h = config_call('fbuild.config.c.bsd.sys_event_h',
platform, lang.static)
p('HAVE_KQUEUE_DEMUXER', bool(event_h.kqueue))
epoll_h = config_call('fbuild.config.c.linux.sys_epoll_h',
platform, lang.static)
p('HAVE_EPOLL', bool(epoll_h.epoll_create))
port_h = config_call('fbuild.config.c.solaris.port_h',
platform, lang.static)
p('HAVE_EVTPORTS', bool(port_h.port_create))
def _print_openmp_support(ctx, platform, lang, p):
try:
static = config_call('fbuild.builders.c.openmp.config', platform, ctx,
lang.static)
except ConfigFailed:
static = {}
try:
shared = config_call('fbuild.builders.c.openmp.config', platform, ctx,
lang.shared)
except ConfigFailed:
shared = {}
p('HAVE_OPENMP', bool(static) or bool(shared))
p('HAVE_STATIC_OPENMP', bool(static))
p('HAVE_SHARED_OPENMP', bool(shared))
def _print_posix_support(platform, lang, p):
# print out information about the posix libraries
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h', platform,
lang.static, lang.shared)
if dlfcn_h.dlopen:
p('HAVE_DLOPEN', True)
p('SUPPORT_DYNAMIC_LOADING', True)
switch = list(dlfcn_h.flags)
p('DYNAMIC_LOADING_CFLAGS', ' '.join(switch))
switch = list('-L' + p for p in dlfcn_h.libpaths)
switch.extend('-l' + l for l in dlfcn_h.libs)
switch.extend('-l' + l for l in dlfcn_h.external_libs)
p('DYNAMIC_LOADING_LIBS', ' '.join(switch))
else:
p('HAVE_DLOPEN', False)
socket_h = config_call('fbuild.config.c.posix.sys_socket_h', platform,
lang.static)
if socket_h.accept:
# We strip off the trailing '*' from the socklen_t type.
p('FLX_SOCKLEN_T', socket_h.accept.args[-1][:-1])
pthread_h = config_call('fbuild.config.c.posix.pthread_h', platform,
lang.static)
if pthread_h.pthread_create:
p('HAVE_PTHREADS', True)
switch = list(pthread_h.flags)
p('PTHREAD_CFLAGS', ' '.join(switch))
switch = list('-L' + p for p in pthread_h.libpaths)
switch.extend('-l' + l for l in pthread_h.libs)
switch.extend('-l' + l for l in pthread_h.external_libs)
p('PTHREAD_LIBS', ' '.join(switch))
else:
p('HAVE_PTHREADS', False)
poll_h = config_call('fbuild.config.c.posix.poll_h', platform, lang.static)
p('HAVE_POLL', bool(poll_h.header))
mman_h = config_call('fbuild.config.c.posix.sys_mman_h', platform,
lang.static)
p('HAVE_MMAP', bool(mman_h.header))
for name, macro in mman_h.macros():
p('HAVE_' + name, bool(macro))
event_h = config_call('fbuild.config.c.bsd.sys_event_h', platform,
lang.static)
p('HAVE_KQUEUE_DEMUXER', bool(event_h.kqueue))
epoll_h = config_call('fbuild.config.c.linux.sys_epoll_h', platform,
lang.static)
p('HAVE_EPOLL', bool(epoll_h.epoll_create))
port_h = config_call('fbuild.config.c.solaris.port_h', platform,
lang.static)
p('HAVE_EVTPORTS', bool(port_h.port_create))
def build_runtime(host_phase, target_phase):
path = Path('src', 'rtl')
buildsystem.copy_hpps_to_rtl(target_phase.ctx,
path / 'flx_rtl.hpp',
path / 'flx_rtl_shapes.hpp',
path / 'flx_compiler_support_headers.hpp',
path / 'flx_compiler_support_bodies.hpp',
path / 'flx_dynlink.hpp',
path / 'flx_i18n.hpp',
path / 'flx_ioutil.hpp',
path / 'flx_strutil.hpp',
path / 'flx_executil.hpp',
path / 'flx_sync.hpp',
path / 'flx_world.hpp',
path / 'flx_async_world.hpp',
path / 'flx_world_config.hpp',
path / 'plat_linux.hpp',
)
for f in Path.glob(path/"*.hpp"):
print("Copying " + f + " --> " +target_phase.ctx.buildroot/f )
copy(ctx=target_phase.ctx, src=f,dst=target_phase.ctx.buildroot/f)
srcs = [copy(ctx=target_phase.ctx, src=f, dst=target_phase.ctx.buildroot / f) for f in Path.glob(path / '*.cpp')]
includes = [
target_phase.ctx.buildroot / 'host/lib/rtl',
target_phase.ctx.buildroot / 'share/lib/rtl'
]
macros = ['BUILD_RTL']
libs = [
call('buildsystem.flx_async.build_runtime', host_phase,target_phase),
call('buildsystem.flx_exceptions.build_runtime', target_phase),
call('buildsystem.flx_gc.build_runtime', host_phase, target_phase),
]
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h',
target_phase.platform,
target_phase.cxx.static,
target_phase.cxx.shared)
if dlfcn_h.dlopen:
external_libs = dlfcn_h.external_libs
else:
external_libs = []
dst = 'host/lib/rtl/flx'
return Record(
static=buildsystem.build_cxx_static_lib(target_phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=external_libs),
shared=buildsystem.build_cxx_shared_lib(target_phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=external_libs))
def build_runtime(host_phase, target_phase):
"""
Builds the judy runtime library, and returns the static and shared
library versions.
"""
path = Path('src/judy/src')
# Copy the header into the runtime library.
buildsystem.copy_to(target_phase.ctx,
target_phase.ctx.buildroot / 'lib/rtl',
[path / 'Judy.h',
path / 'Judy1/Judy1.h',
path / 'JudyL/JudyL.h'])
types = config_call('fbuild.config.c.c99.types',
target_phase.platform, target_phase.c.static)
if types.voidp.size == 8:
macros = ['JU_64BIT']
else:
macros = ['JU_32BIT']
if 'windows' in target_phase.platform:
macros.append('BUILD_JUDY') #Apply this to all source files.
srcs = [copy(target_phase.ctx, p, target_phase.ctx.buildroot / p) for p in [
path / 'JudyCommon/JudyMalloc.c',
path / 'JudySL/JudySL.c',
path / 'JudyHS/JudyHS.c'] +
(path / 'Judy1' / '*.c').glob() +
(path / 'JudyL' / '*.c').glob()]
# Copy all the common judy sources we need so people can rebuild the RTL without a source distro
for p in ((path / 'JudyCommon' / '*.c').glob() +
(path / 'Judy*' / '*.h').glob()):
if p not in ('JudyMalloc.c', 'JudyPrintJP.c'):
copy(target_phase.ctx, p, target_phase.ctx.buildroot / p)
includes = [path,
path / 'JudyCommon',
path / 'JudyL',
path / 'Judy1']
static = buildsystem.build_c_static_lib(target_phase, 'lib/rtl/judy',
srcs=srcs,
macros=macros,
includes=includes)
shared = buildsystem.build_c_shared_lib(target_phase, 'lib/rtl/judy',
srcs=srcs,
macros=macros,
includes=includes)
return Record(static=static, shared=shared)
def build_runtime(host_phase, target_phase):
path = Path('src', 'rtl')
buildsystem.copy_hpps_to_rtl(target_phase.ctx,
target_phase.ctx.buildroot / 'config/target/flx_rtl_config.hpp',
target_phase.ctx.buildroot / 'config/target/flx_meta.hpp',
path / 'flx_rtl.hpp',
path / 'flx_compiler_support_headers.hpp',
path / 'flx_compiler_support_bodies.hpp',
path / 'flx_dynlink.hpp',
path / 'flx_i18n.hpp',
path / 'flx_ioutil.hpp',
path / 'flx_strutil.hpp',
path / 'flx_executil.hpp',
)
dst = 'lib/rtl/flx'
srcs = Path.glob(path / '*.cpp')
includes = [
target_phase.ctx.buildroot / 'config/target',
'src/exceptions',
'src/demux',
'src/faio',
'src/judy/src',
'src/gc',
'src/pthread',
]
macros = ['BUILD_RTL']
libs = [
call('buildsystem.flx_async.build_runtime', target_phase),
call('buildsystem.flx_exceptions.build_runtime', target_phase),
call('buildsystem.flx_gc.build_runtime', host_phase, target_phase),
]
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h',
target_phase.platform,
target_phase.cxx.static,
target_phase.cxx.shared)
if dlfcn_h.dlopen:
external_libs = dlfcn_h.external_libs
else:
external_libs = []
return Record(
static=buildsystem.build_cxx_static_lib(target_phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=external_libs),
shared=buildsystem.build_cxx_shared_lib(target_phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=external_libs))
def _print_math_support(platform, lang, p):
cmath = config_call("fbuild.config.cxx.cmath.cmath", platform, lang.static)
math_h = config_call("fbuild.config.c.stdlib.math_h", platform, lang.static)
ieeefp_h = config_call("fbuild.config.c.ieeefp_h.ieeefp_h", platform, lang.static)
p("HAVE_CXX_ISNAN_IN_CMATH", bool(cmath.isnan))
p("HAVE_CXX_ISINF_IN_CMATH", bool(cmath.isinf))
p("HAVE_CXX_ISFINITE_IN_CMATH", bool(cmath.isfinite))
p("HAVE_C99_ISFINITE_IN_MATH", bool(math_h.isfinite))
p("HAVE_C99_ISINF_IN_MATH", bool(math_h.isinf))
p("HAVE_C99_ISNAN_IN_MATH", bool(math_h.isnan))
p("HAVE_BSD_FINITE_IN_MATH", bool(math_h.finite))
p("HAVE_BSD_ISINF_IN_MATH", bool(math_h.isinf))
p("HAVE_BSD_ISNAN_IN_MATH", bool(math_h.isnan))
p("HAVE_BSD_FINITE_IN_IEEEFP", bool(ieeefp_h.finite))
p("HAVE_BSD_ISINF_IN_IEEEFP", bool(ieeefp_h.isinf))
p("HAVE_BSD_ISNAN_IN_IEEEFP", bool(ieeefp_h.isnan))
p("HAVE_FINITE_IN_IEEEFP", bool(ieeefp_h.finite))
p("HAVE_ISINF_IN_IEEEFP", bool(ieeefp_h.isinf))
p("HAVE_ISNANF_IN_IEEEFP", bool(ieeefp_h.isnanf))
def build_runtime(host_phase, target_phase):
"""
Builds the judy runtime library, and returns the static and shared
library versions.
"""
path = Path('src/judy/src')
# Copy the header into the runtime library.
buildsystem.copy_to(target_phase.ctx,
target_phase.ctx.buildroot / 'share/lib/rtl',
[path / 'Judy.h'])
types = config_call('fbuild.config.c.c99.types', target_phase.platform,
target_phase.c.static)
if types.voidp.size == 8:
macros = ['JU_64BIT']
else:
macros = ['JU_32BIT']
if 'windows' in target_phase.platform:
macros.append('BUILD_JUDY') #Apply this to all source files.
srcs = [
copy(target_phase.ctx, p, target_phase.ctx.buildroot / 'share' / p)
for p in [
path / 'JudyCommon/JudyMalloc.c', path / 'JudySL/JudySL.c', path /
'JudyHS/JudyHS.c'
] + (path / 'Judy1' / '*.c').glob() + (path / 'JudyL' / '*.c').glob()
]
# Copy all the common judy sources we need so people can rebuild the RTL without a source distro
for p in ((path / 'JudyCommon' / '*.c').glob() +
(path / 'Judy*' / '*.h').glob()):
if p not in ('JudyMalloc.c', 'JudyPrintJP.c'):
copy(target_phase.ctx, p, target_phase.ctx.buildroot / 'share' / p)
includes = [path, path / 'JudyCommon', path / 'JudyL', path / 'Judy1']
static = buildsystem.build_c_static_lib(target_phase,
'host/lib/rtl/judy',
srcs=srcs,
macros=macros,
includes=includes)
shared = buildsystem.build_c_shared_lib(target_phase,
'host/lib/rtl/judy',
srcs=srcs,
macros=macros,
includes=includes)
return Record(static=static, shared=shared)
def _print_math_support(platform, lang, p):
cmath = config_call('fbuild.config.cxx.cmath.cmath', platform, lang.static)
math_h = config_call('fbuild.config.c.stdlib.math_h', platform,
lang.static)
ieeefp_h = config_call('fbuild.config.c.ieeefp_h.ieeefp_h', platform,
lang.static)
p('HAVE_CXX_ISNAN_IN_CMATH', bool(cmath.isnan))
p('HAVE_CXX_ISINF_IN_CMATH', bool(cmath.isinf))
p('HAVE_CXX_ISFINITE_IN_CMATH', bool(cmath.isfinite))
p('HAVE_C99_ISFINITE_IN_MATH', bool(math_h.isfinite))
p('HAVE_C99_ISINF_IN_MATH', bool(math_h.isinf))
p('HAVE_C99_ISNAN_IN_MATH', bool(math_h.isnan))
p('HAVE_BSD_FINITE_IN_MATH', bool(math_h.finite))
p('HAVE_BSD_ISINF_IN_MATH', bool(math_h.isinf))
p('HAVE_BSD_ISNAN_IN_MATH', bool(math_h.isnan))
p('HAVE_BSD_FINITE_IN_IEEEFP', bool(ieeefp_h.finite))
p('HAVE_BSD_ISINF_IN_IEEEFP', bool(ieeefp_h.isinf))
p('HAVE_BSD_ISNAN_IN_IEEEFP', bool(ieeefp_h.isnan))
p('HAVE_FINITE_IN_IEEEFP', bool(ieeefp_h.finite))
p('HAVE_ISINF_IN_IEEEFP', bool(ieeefp_h.isinf))
p('HAVE_ISNANF_IN_IEEEFP', bool(ieeefp_h.isnanf))
def configure(ctx):
"""Configure Felix."""
build = config_build(ctx)
host = config_host(ctx, build)
target = config_target(ctx, host)
types = config_call('fbuild.config.c.c99.types', target.platform,
target.c.static)
compiler = hack_toolchain_name(str(target.c.static))
os = hack_os_name(target.platform)
bits = hack_size(types.voidp.size)
target_config(ctx, target, os, bits, compiler)
return Record(build=build, host=host, target=target)
def build_runtime(host_phase, target_phase):
"""
Builds the judy runtime library, and returns the static and shared
library versions.
"""
path = Path("src/judy/src")
# Copy the header into the runtime library.
buildsystem.copy_to(target_phase.ctx, target_phase.ctx.buildroot / "lib/rtl", [path / "Judy.h"])
types = config_call("fbuild.config.c.c99.types", target_phase.platform, target_phase.c.static)
if types.voidp.size == 8:
macros = ["JU_64BIT"]
else:
macros = ["JU_32BIT"]
srcs = [path / "JudyCommon/JudyMalloc.c", path / "JudySL/JudySL.c", path / "JudyHS/JudyHS.c"]
static = buildsystem.build_c_static_lib(
target_phase,
"lib/rtl/judy",
srcs=srcs,
objs=_build_objs(host_phase, target_phase, target_phase.c.static, "Judy1")
+ _build_objs(host_phase, target_phase, target_phase.c.static, "JudyL"),
macros=macros,
includes=[path, path / "JudyCommon"],
)
shared = buildsystem.build_c_shared_lib(
target_phase,
"lib/rtl/judy",
srcs=srcs,
objs=_build_objs(host_phase, target_phase, target_phase.c.shared, "Judy1")
+ _build_objs(host_phase, target_phase, target_phase.c.shared, "JudyL"),
macros=macros,
includes=[path, path / "JudyCommon"],
)
return Record(static=static, shared=shared)
def _print_types(platform, lang, p):
cxx_types = config_call('fbuild.config.cxx.cxx03.types', platform,
lang.static)
def write(name, type_):
if name == '_Bool':
name = 'cbool'
elif name == 'void*':
name = 'VOIDP'
name = name.replace(' ', '')
alias = cxx_types.structural_alias(type_)
if isinstance(type_, fbuild.config.c.IntType):
p('ALIAS_' + name, alias)
name = name.upper()
p('SIZEOF_' + name, type_.size)
p('ALIGNOF_' + name, type_.alignment)
# standard language type info
p('CHAR_IS_UNSIGNED', not cxx_types.char.signed)
p('HAVE_BOOL', bool(cxx_types.bool))
p('HAVE_LONGLONG', bool(cxx_types.long_long))
p('HAVE_LONGDOUBLE', bool(cxx_types.long_double))
max_align = 1
aligns = {1: 'char'}
for name, type_ in cxx_types.types():
if type_ is None:
continue
aligns.setdefault(type_.alignment, name)
max_align = max(max_align, type_.alignment)
write(name, type_)
p('MAX_ALIGN', max_align)
p('flx_aligns', aligns)
p('arith_conv', cxx_types.conversion_map())
c99_types = config_call('fbuild.config.c.stdlib.types', platform,
lang.static)
stddef_h = config_call('fbuild.config.c.stdlib.stddef_h', platform,
lang.static)
complex_h = config_call('fbuild.config.c.stdlib.complex_h', platform,
lang.static)
stdint_h = config_call('fbuild.config.c.stdlib.stdint_h', platform,
lang.static)
sys_types_h = config_call('fbuild.config.c.posix.sys_types_h', platform,
lang.static)
p('HAVE_STDINT', bool(stdint_h.header))
p('HAVE_SYS_TYPES', bool(sys_types_h.header))
# write out data for the types.
for name, type_ in set(
chain(cxx_types.types(), c99_types.types(), stddef_h.types(),
complex_h.types(), stdint_h.types(), sys_types_h.types())):
if type_ is None:
continue
write(name, type_)
if not stdint_h.header:
if c99_types.long_long:
p('ALIAS_intmax_t', 'long long')
p('ALIAS_uintmax_t', 'unsigned long long')
else:
p('ALIAS_intmax_t', 'long')
p('ALIAS_uintmax_t', 'unsigned long')
visited = set()
for name, type_ in cxx_types.int_types():
if type_ is not None and type_ not in visited:
visited.add(type_)
if type_.signed:
p('ALIAS_int%s_t' % (type_.size * 8), name)
else:
p('ALIAS_uint%s_t' % (type_.size * 8), name)
p('ALIAS_intptr_t', cxx_types.structural_alias(cxx_types.voidp))
p('ALIAS_uintptr_t',
'unsigned ' + cxx_types.structural_alias(cxx_types.voidp))
if not sys_types_h.ssize_t:
if c99_types.long_long and \
stddef_h.size_t.size == c99_types.long_long.size:
p('ALIAS_ssize_t', 'long long')
else:
p('ALIAS_ssize_t', 'long')
def _print_compiler(ctx, lang, platform, p):
# determine information about the compiler
p('HAVE_PIC', '-fPIC' in lang.shared.compiler.flags)
p('PIC', '-fPIC')
static = lang.static
shared = lang.shared
if 'windows' in platform:
p('SPEC_OBJ_FILENAME', '/Fo')
p('SPEC_EXE_FILENAME', '/Fe')
p(
'CCOBJ_STATIC_FLX', '"' + str(static.compiler.cl.exe) +
'" /nologo /c ' + ' '.join(static.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cl.includes))
p(
'CCLINK_STATIC_LIB', '"' + str(static.lib_linker.exe) + '" ' +
' '.join(i for i in static.lib_linker.flags))
p(
'CCOBJ_DYNAMIC_FLX', '"' + str(shared.compiler.cl.exe) +
'" /nologo /c ' + ' '.join(shared.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cl.includes))
p(
'CCLINK_STATIC', '"' + str(static.compiler.cl.exe) + '" /nologo ' +
' '.join(shared.exe_linker.flags) + ' ' +
' '.join('-L' + i for i in static.exe_linker.libpaths))
p(
'CCLINK_DYNAMIC_FLX', '"' + str(shared.compiler.cl.exe) +
'" /nologo ' + ' '.join(shared.lib_linker.flags) + ' ' +
' '.join('-L' + i for i in shared.lib_linker.libpaths))
else:
p('SPEC_OBJ_FILENAME', '-o ')
p('SPEC_EXE_FILENAME', '-o ')
static_arch = static.compiler.cc.arch
p(
'CCOBJ_STATIC_FLX',
str(static.compiler.cc.exe) + ' -c ' +
' '.join(static.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cc.includes) + ' ' +
' '.join('-m' + i for i in static.compiler.cc.machine_flags) +
' ' + ('-arch ' + static_arch if static_arch else '') + ' ' +
' '.join('-W' + i for i in static.compiler.cc.warnings))
p(
'CCLINK_STATIC_LIB',
str(static.lib_linker.exe) + ' ' +
' '.join(i for i in static.lib_linker.flags))
p(
'CCLINK_STATIC',
str(static.exe_linker.cc.exe) + ' ' +
' '.join(shared.exe_linker.flags) + ' ' +
' '.join('-m' + i for i in static.compiler.cc.machine_flags) +
' ' + ('-arch ' + static_arch if static_arch else '') + ' ' +
' '.join('-L' + i for i in static.exe_linker.cc.libpaths))
shared_arch = shared.compiler.cc.arch
p(
'CCOBJ_DYNAMIC_FLX',
str(shared.compiler.cc.exe) + ' -c ' +
' '.join(shared.compiler.flags) + ' ' +
' '.join('-I' + i for i in shared.compiler.cc.includes) + ' ' +
('-arch ' + shared_arch if shared_arch else '') + ' ' +
' '.join('-m' + i for i in shared.compiler.cc.machine_flags) +
' ' + ' '.join('-W' + i for i in static.compiler.cc.warnings))
p(
'CCLINK_DYNAMIC_FLX',
str(shared.lib_linker.cc.exe) + ' ' +
' '.join(shared.lib_linker.flags) + ' ' +
('-arch ' + shared_arch if shared_arch else '') + ' ' +
' '.join('-m' + i for i in shared.compiler.cc.machine_flags) +
' ' + ' '.join('-L' + i for i in shared.compiler.cc.libpaths))
p('EXT_STATIC_OBJ', fbuild.builders.platform.static_obj_suffix(ctx))
p('EXT_SHARED_OBJ', fbuild.builders.platform.shared_obj_suffix(ctx))
p('EXT_LIB', fbuild.builders.platform.static_lib_suffix(ctx))
p('EXT_SHLIB', fbuild.builders.platform.shared_lib_suffix(ctx))
p('EXT_EXE', fbuild.builders.platform.exe_suffix(ctx))
if 'windows' in platform:
p('OPTIMISE', ' '.join(static.compiler.cl.optimize_flags))
p('DEBUG_FLAGS', ' '.join(static.compiler.cl.debug_flags))
else:
p('OPTIMISE', ' '.join(static.compiler.cc.optimize_flags))
p('DEBUG_FLAGS', ' '.join(static.compiler.cc.debug_flags))
p(
'LITTLE_ENDIAN',
config_call('fbuild.config.c.platform.arch', platform,
static).little_endian)
def _print_config(ctx, f, build, host, target):
def p(msg, *args):
if not args:
print(msg, file=f)
else:
print(msg, '=', file=f, *(repr(a) for a in args))
def pp(msg, *args):
p(' ' + msg, *args)
# --------------------------------------------------------------------------
# version information
p('flx_version = ' + repr(version.flx_version))
p('flx_version_major = ' + repr(version.flx_version_major))
p('flx_version_minor = ' + repr(version.flx_version_minor))
p('flx_version_patch = ' + repr(version.flx_version_patch))
p('flx_version_release = ' + repr(version.flx_version_release))
# --------------------------------------------------------------------------
# setup paths
p('src_dir', str(call('fbuildroot.src_dir', ctx)))
p('PREFIX', str(call('fbuildroot.prefix', ctx)))
p('FLXCC_CPP', 'cpp ')
# --------------------------------------------------------------------------
# get all the platform information
supported_platforms = set()
for platforms in fbuild.builders.platform.archmap.values():
supported_platforms |= platforms
supported_platforms = sorted(supported_platforms)
windows_h = config_call('fbuild.config.c.win32.windows_h', target.platform,
target.c.static)
p('HAVE_MSVC', bool(windows_h.header))
p('HAVE_GNU', 'windows' not in target.platform)
# --------------------------------------------------------------------------
# phases
for phase_name, phase in (('build', build), ('host', host), ('target',
target)):
for lang in 'c', 'cxx':
p('class ' + phase_name.upper() + '_' + lang.upper() + ':')
p(' class options:')
platform = phase.platform
for name in supported_platforms:
pp(name.upper(), name in platform)
lang = phase[lang]
_print_compiler(ctx, lang, platform, pp)
_print_types(platform, lang, pp)
_print_c99_support(platform, lang, pp)
_print_posix_support(platform, lang, pp)
_print_windows_support(platform, lang, pp)
_print_math_support(platform, lang, pp)
_print_openmp_support(ctx, platform, lang, pp)
_print_cxx_bugs(ctx, platform, lang, pp)
_print_gcc_extensions(platform, lang, pp)
# --------------------------------------------------------------------------
# expose target_cxx to the top level config
for platform in supported_platforms:
p(platform.upper() + '=TARGET_CXX.options.' + platform.upper())
# --------------------------------------------------------------------------
# figure out the global library loading scheme
p('SUPPORT_STATIC_LINKAGE', True)
p('SUPPORT_DYNAMIC_LOADING=TARGET_CXX.options.SUPPORT_DYNAMIC_LOADING')
p('if SUPPORT_DYNAMIC_LOADING:')
p(' DEFAULT_LINK_MODEL', 'dynamic')
p('else:')
p(' DEFAULT_LINK_MODEL', 'static')
def build_runtime(phase):
path = Path("src/demux")
buildsystem.copy_hpps_to_rtl(
phase.ctx,
# phase.ctx.buildroot / 'lib/rtl/flx_demux_config.hpp', # portable
# portable
path / "flx_demux.hpp",
path / "demux_demuxer.hpp",
path / "demux_timer_queue.hpp",
path / "demux_quitter.hpp",
# windows (monolithic)
path / "win/demux_iocp_demuxer.hpp",
path / "win/demux_overlapped.hpp",
path / "win/demux_win_timer_queue.hpp",
path / "win/demux_wself_piper.hpp",
# posix
path / "posix/demux_posix_demuxer.hpp",
path / "posix/demux_posix_timer_queue.hpp",
path / "posix/demux_pfileio.hpp",
path / "posix/demux_select_demuxer.hpp",
path / "posix/demux_sockety.hpp",
path / "posix/demux_self_piper.hpp",
path / "posix/demux_ts_select_demuxer.hpp",
# linux, osx 10.3 (select impl), 10.4 real.
path / "poll/demux_poll_demuxer.hpp",
path / "poll/demux_ts_poll_demuxer.hpp",
# linux (>= 2.6)
path / "epoll/demux_epoll_demuxer.hpp",
# osx (10.3 onwards)/bsd
path / "kqueue/demux_kqueue_demuxer.hpp",
# solaris (9 onwards?)
path / "evtport/demux_evtport_demuxer.hpp",
)
dst = "host/lib/rtl/demux"
srcs = [path / "*.cpp"]
includes = [phase.ctx.buildroot / "host/lib/rtl", Path("src", "pthread"), Path("src", "gc"), path]
macros = ["BUILD_DEMUX"]
libs = [call("buildsystem.flx_pthread.build_runtime", phase)]
extra_libs = []
if "win32" in phase.platform:
print("DEMUX: providing WIN32 IO COMPLETION PORTS")
srcs.extend(
(
path / "win/demux_iocp_demuxer.cpp", # windows
path / "win/demux_overlapped.cpp", # windows
path / "win/demux_wself_piper.cpp", # windows
path / "win/demux_win_timer_queue.cpp", # windows
)
)
includes.append(path / "win")
extra_libs.extend(("ws2_32", "mswsock"))
if "posix" in phase.platform:
print("DEMUX: providing POSIX SELECT")
srcs.extend(
(
path / "posix/demux_posix_demuxer.cpp", # posix
path / "posix/demux_select_demuxer.cpp", # posix
path / "posix/demux_posix_timer_queue.cpp", # posix
path / "posix/demux_sockety.cpp", # posix
path / "posix/demux_self_piper.cpp", # posix
path / "posix/demux_pfileio.cpp", # posix
path / "posix/demux_ts_select_demuxer.cpp", # posix
)
)
includes.append(path / "posix")
poll_h = config_call("fbuild.config.c.posix.poll_h", phase.platform, phase.cxx.shared)
sys_epoll_h = config_call("fbuild.config.c.linux.sys_epoll_h", phase.platform, phase.cxx.shared)
sys_event_h = config_call("fbuild.config.c.bsd.sys_event_h", phase.platform, phase.cxx.shared)
port_h = config_call("fbuild.config.c.solaris.port_h", phase.platform, phase.cxx.shared)
if poll_h.header:
print("DEMUX: providing UNIX POLL")
srcs.extend(
(
# I've seen poll on linux and osx10.4 systems.
# conditionally compiled and used.
path / "poll/demux_poll_demuxer.cpp", # I've seen this on linux and osx10.4
path / "poll/demux_ts_poll_demuxer.cpp", # ditto
)
)
includes.append(path / "poll")
if sys_epoll_h.header:
print("DEMUX: providing LINUX EPOLL")
srcs.append(path / "epoll/demux_epoll_demuxer.cpp")
includes.append(path / "epoll")
if sys_event_h.header:
print("DEMUX: providing OSX KQUEUE")
srcs.append(path / "kqueue/demux_kqueue_demuxer.cpp")
includes.append(path / "kqueue")
if port_h.header:
print("DEMUX: providingd SOLARIS EVENT PORTS")
srcs.append(path / "evtport/demux_evtport_demuxer.cpp")
includes.append(path / "evtport")
srcs = Path.globall(srcs)
lp = len(path)
# print("demux: srcs = ", [str (src)[lp+1:] for src in srcs])
# print("demux: include paths = ", [str(inc) for inc in includes])
return Record(
static=buildsystem.build_cxx_static_lib(
phase,
dst,
srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=extra_libs,
),
shared=buildsystem.build_cxx_shared_lib(
phase,
dst,
srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=extra_libs,
),
)
def _print_cxx_bugs(ctx, platform, lang, p):
compiler = config_call('fbuild.config.cxx.compiler.bugs',
platform, lang.static)
p('HAVE_INCLASS_MEMBER_INITIALIZATION',
compiler.class_member_intialization)
def build_runtime(phase):
path = Path('src/pthread')
copy(ctx=phase.ctx,
src="src/config/target/flx_pthread_config.hpp",
dst=phase.ctx.buildroot / 'host/lib/rtl/flx_pthread_config.hpp')
buildsystem.copy_hpps_to_rtl(phase.ctx,
# portable
path / 'pthread_thread.hpp',
path / 'pthread_mutex.hpp',
path / 'pthread_counter.hpp',
path / 'pthread_waitable_bool.hpp',
path / 'pthread_condv.hpp',
path / 'pthread_semaphore.hpp',
path / 'pthread_monitor.hpp',
# win32 and posix
path / 'pthread_win_posix_condv_emul.hpp',
)
srcs = [copy(ctx=phase.ctx, src=f, dst=phase.ctx.buildroot / f) for f in [
path / 'pthread_win_posix_condv_emul.cpp', # portability hackery
path / 'pthread_mutex.cpp',
path / 'pthread_condv.cpp',
path / 'pthread_counter.cpp',
path / 'pthread_waitable_bool.cpp',
path / 'pthread_semaphore.cpp',
path / 'pthread_monitor.cpp',
path / 'pthread_thread_control.cpp',
path / 'pthread_win_thread.cpp',
path / 'pthread_posix_thread.cpp',
]]
includes = [phase.ctx.buildroot / 'host/lib/rtl', phase.ctx.buildroot / 'share/lib/rtl', 'src/rtl',]
macros = ['BUILD_PTHREAD']
flags = []
libs = []
external_libs = []
pthread_h = config_call('fbuild.config.c.posix.pthread_h',
phase.platform,
phase.cxx.shared)
dst = 'host/lib/rtl/flx_pthread'
if pthread_h.pthread_create:
flags.extend(pthread_h.flags)
libs.extend(pthread_h.libs)
external_libs.extend(pthread_h.external_libs)
return Record(
static=buildsystem.build_cxx_static_lib(phase, dst, srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags),
shared=buildsystem.build_cxx_shared_lib(phase, dst, srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags))
def _print_config(ctx, f, build, host, target):
def p(msg, *args):
if not args:
print(msg, file=f)
else:
print(msg, "=", file=f, *(repr(a) for a in args))
def pp(msg, *args):
p(" " + msg, *args)
# --------------------------------------------------------------------------
# version information
p("flx_version = " + repr(version.flx_version))
p("flx_version_major = " + repr(version.flx_version_major))
p("flx_version_minor = " + repr(version.flx_version_minor))
p("flx_version_patch = " + repr(version.flx_version_patch))
p("flx_version_release = " + repr(version.flx_version_release))
# --------------------------------------------------------------------------
# setup paths
p("src_dir", str(call("fbuildroot.src_dir", ctx)))
p("PREFIX", str(call("fbuildroot.prefix", ctx)))
p("FLXCC_CPP", "cpp ")
# --------------------------------------------------------------------------
# get all the platform information
supported_platforms = set()
for platforms in fbuild.builders.platform.archmap.values():
supported_platforms |= platforms
supported_platforms = sorted(supported_platforms)
windows_h = config_call("fbuild.config.c.win32.windows_h", target.platform, target.c.static)
p("HAVE_MSVC", bool(windows_h.header))
p("HAVE_GNU", "windows" not in target.platform)
# --------------------------------------------------------------------------
# phases
for phase_name, phase in (("build", build), ("host", host), ("target", target)):
for lang in "c", "cxx":
p("class " + phase_name.upper() + "_" + lang.upper() + ":")
p(" class options:")
platform = phase.platform
for name in supported_platforms:
pp(name.upper(), name in platform)
lang = phase[lang]
_print_compiler(ctx, lang, platform, pp)
_print_types(platform, lang, pp)
_print_c99_support(platform, lang, pp)
_print_posix_support(platform, lang, pp)
_print_windows_support(platform, lang, pp)
_print_math_support(platform, lang, pp)
_print_openmp_support(ctx, platform, lang, pp)
_print_cxx_bugs(ctx, platform, lang, pp)
_print_gcc_extensions(platform, lang, pp)
# --------------------------------------------------------------------------
# expose target_cxx to the top level config
for platform in supported_platforms:
p(platform.upper() + "=TARGET_CXX.options." + platform.upper())
# --------------------------------------------------------------------------
# figure out the global library loading scheme
p("SUPPORT_STATIC_LINKAGE", True)
p("SUPPORT_DYNAMIC_LOADING=TARGET_CXX.options.SUPPORT_DYNAMIC_LOADING")
p("if SUPPORT_DYNAMIC_LOADING:")
p(" DEFAULT_LINK_MODEL", "dynamic")
p("else:")
p(" DEFAULT_LINK_MODEL", "static")
def _print_types(platform, lang, p):
cxx_types = config_call('fbuild.config.cxx.cxx03.types',
platform, lang.static)
def write(name, type_):
if name == '_Bool':
name = 'cbool'
elif name == 'void*':
name = 'VOIDP'
name = name.replace(' ', '')
alias = cxx_types.structural_alias(type_)
if isinstance(type_, fbuild.config.c.IntType):
p('ALIAS_' + name, alias)
name = name.upper()
p('SIZEOF_' + name, type_.size)
p('ALIGNOF_' + name, type_.alignment)
# standard language type info
p('CHAR_IS_UNSIGNED', not cxx_types.char.signed)
p('HAVE_BOOL', bool(cxx_types.bool))
p('HAVE_LONGLONG', bool(cxx_types.long_long))
p('HAVE_LONGDOUBLE', bool(cxx_types.long_double))
max_align = 1
aligns = {1: 'char'}
for name, type_ in cxx_types.types():
if type_ is None:
continue
aligns.setdefault(type_.alignment, name)
max_align = max(max_align, type_.alignment)
write(name, type_)
p('MAX_ALIGN', max_align)
p('flx_aligns', aligns)
p('arith_conv', cxx_types.conversion_map())
c99_types = config_call('fbuild.config.c.stdlib.types',
platform, lang.static)
stddef_h = config_call('fbuild.config.c.stdlib.stddef_h',
platform, lang.static)
complex_h = config_call('fbuild.config.c.stdlib.complex_h',
platform, lang.static)
stdint_h = config_call('fbuild.config.c.stdlib.stdint_h',
platform, lang.static)
sys_types_h = config_call('fbuild.config.c.posix.sys_types_h',
platform, lang.static)
p('HAVE_STDINT', bool(stdint_h.header))
p('HAVE_SYS_TYPES', bool(sys_types_h.header))
# write out data for the types.
for name, type_ in set(chain(
cxx_types.types(),
c99_types.types(),
stddef_h.types(),
complex_h.types(),
stdint_h.types(),
sys_types_h.types())):
if type_ is None:
continue
write(name, type_)
if not stdint_h.header:
if c99_types.long_long:
p('ALIAS_intmax_t', 'long long')
p('ALIAS_uintmax_t', 'unsigned long long')
else:
p('ALIAS_intmax_t', 'long')
p('ALIAS_uintmax_t', 'unsigned long')
visited = set()
for name, type_ in cxx_types.int_types():
if type_ is not None and type_ not in visited:
visited.add(type_)
if type_.signed:
p('ALIAS_int%s_t' % (type_.size * 8), name)
else:
p('ALIAS_uint%s_t' % (type_.size * 8), name)
p('ALIAS_intptr_t', cxx_types.structural_alias(cxx_types.voidp))
p('ALIAS_uintptr_t',
'unsigned ' + cxx_types.structural_alias(cxx_types.voidp))
if not sys_types_h.ssize_t:
if c99_types.long_long and \
stddef_h.size_t.size == c99_types.long_long.size:
p('ALIAS_ssize_t', 'long long')
else:
p('ALIAS_ssize_t', 'long')
def _print_compiler(ctx, lang, platform, p):
# determine information about the compiler
p('HAVE_PIC', '-fPIC' in lang.shared.compiler.flags)
p('PIC', '-fPIC')
static = lang.static
shared = lang.shared
if 'windows' in platform:
p('SPEC_OBJ_FILENAME', '/Fo')
p('SPEC_EXE_FILENAME', '/Fe')
p('CCOBJ_STATIC_FLX', '"' + str(static.compiler.cl.exe) + '" /nologo /c ' +
' '.join(static.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cl.includes))
p('CCLINK_STATIC_LIB', '"'+str(static.lib_linker.exe) + '" ' +
' '.join(i for i in static.lib_linker.flags))
p('CCOBJ_DYNAMIC_FLX', '"' + str(shared.compiler.cl.exe) + '" /nologo /c ' +
' '.join(shared.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cl.includes))
p('CCLINK_STATIC', '"' + str(static.compiler.cl.exe) + '" /nologo ' +
' '.join(shared.exe_linker.flags) + ' ' +
' '.join('-L' + i for i in static.exe_linker.libpaths))
p('CCLINK_DYNAMIC_FLX', '"' + str(shared.compiler.cl.exe) + '" /nologo ' +
' '.join(shared.lib_linker.flags) + ' ' +
' '.join('-L' + i for i in shared.lib_linker.libpaths))
else:
p('SPEC_OBJ_FILENAME', '-o ')
p('SPEC_EXE_FILENAME', '-o ')
static_arch = static.compiler.cc.arch
p('CCOBJ_STATIC_FLX', str(static.compiler.cc.exe) + ' -c ' +
' '.join(static.compiler.flags) + ' ' +
' '.join('-I' + i for i in static.compiler.cc.includes) + ' ' +
' '.join('-m' + i for i in static.compiler.cc.machine_flags) + ' ' +
('-arch ' + static_arch if static_arch else '') + ' ' +
' '.join('-W' + i for i in static.compiler.cc.warnings))
p('CCLINK_STATIC_LIB', str(static.lib_linker.exe) + ' ' +
' '.join(i for i in static.lib_linker.flags))
p('CCLINK_STATIC', str(static.exe_linker.cc.exe) + ' ' +
' '.join(shared.exe_linker.flags) + ' ' +
' '.join('-m' + i for i in static.compiler.cc.machine_flags) + ' ' +
('-arch ' + static_arch if static_arch else '') + ' ' +
' '.join('-L' + i for i in static.exe_linker.cc.libpaths))
shared_arch = shared.compiler.cc.arch
p('CCOBJ_DYNAMIC_FLX', str(shared.compiler.cc.exe) + ' -c ' +
' '.join(shared.compiler.flags) + ' ' +
' '.join('-I' + i for i in shared.compiler.cc.includes) + ' ' +
('-arch ' + shared_arch if shared_arch else '') + ' ' +
' '.join('-m' + i for i in shared.compiler.cc.machine_flags) + ' ' +
' '.join('-W' + i for i in static.compiler.cc.warnings))
p('CCLINK_DYNAMIC_FLX', str(shared.lib_linker.cc.exe) + ' ' +
' '.join(shared.lib_linker.flags) + ' ' +
('-arch ' + shared_arch if shared_arch else '') + ' ' +
' '.join('-m' + i for i in shared.compiler.cc.machine_flags) + ' ' +
' '.join('-L' + i for i in shared.compiler.cc.libpaths))
p('EXT_STATIC_OBJ', fbuild.builders.platform.static_obj_suffix(ctx))
p('EXT_SHARED_OBJ', fbuild.builders.platform.shared_obj_suffix(ctx))
p('EXT_LIB', fbuild.builders.platform.static_lib_suffix(ctx))
p('EXT_SHLIB', fbuild.builders.platform.shared_lib_suffix(ctx))
p('EXT_EXE', fbuild.builders.platform.exe_suffix(ctx))
if 'windows' in platform:
p('OPTIMISE', ' '.join(static.compiler.cl.optimize_flags))
p('DEBUG_FLAGS', ' '.join(static.compiler.cl.debug_flags))
else:
p('OPTIMISE', ' '.join(static.compiler.cc.optimize_flags))
p('DEBUG_FLAGS', ' '.join(static.compiler.cc.debug_flags))
p('LITTLE_ENDIAN', config_call('fbuild.config.c.platform.arch',
platform, static).little_endian)
def _print_types(platform, lang, p):
cxx_types = config_call("fbuild.config.cxx.cxx03.types", platform, lang.static)
def write(name, type_):
if name == "_Bool":
name = "cbool"
elif name == "void*":
name = "VOIDP"
name = name.replace(" ", "")
alias = cxx_types.structural_alias(type_)
if isinstance(type_, fbuild.config.c.IntType):
p("ALIAS_" + name, alias)
name = name.upper()
p("SIZEOF_" + name, type_.size)
p("ALIGNOF_" + name, type_.alignment)
# standard language type info
p("CHAR_IS_UNSIGNED", not cxx_types.char.signed)
p("HAVE_BOOL", bool(cxx_types.bool))
p("HAVE_LONGLONG", bool(cxx_types.long_long))
p("HAVE_LONGDOUBLE", bool(cxx_types.long_double))
max_align = 1
aligns = {1: "char"}
for name, type_ in cxx_types.types():
if type_ is None:
continue
aligns.setdefault(type_.alignment, name)
max_align = max(max_align, type_.alignment)
write(name, type_)
p("MAX_ALIGN", max_align)
p("flx_aligns", aligns)
p("arith_conv", cxx_types.conversion_map())
c99_types = config_call("fbuild.config.c.stdlib.types", platform, lang.static)
stddef_h = config_call("fbuild.config.c.stdlib.stddef_h", platform, lang.static)
complex_h = config_call("fbuild.config.c.stdlib.complex_h", platform, lang.static)
stdint_h = config_call("fbuild.config.c.stdlib.stdint_h", platform, lang.static)
sys_types_h = config_call("fbuild.config.c.posix.sys_types_h", platform, lang.static)
p("HAVE_STDINT", bool(stdint_h.header))
p("HAVE_SYS_TYPES", bool(sys_types_h.header))
# write out data for the types.
for name, type_ in set(
chain(
cxx_types.types(),
c99_types.types(),
stddef_h.types(),
complex_h.types(),
stdint_h.types(),
sys_types_h.types(),
)
):
if type_ is None:
continue
write(name, type_)
if not stdint_h.header:
if c99_types.long_long:
p("ALIAS_intmax_t", "long long")
p("ALIAS_uintmax_t", "unsigned long long")
else:
p("ALIAS_intmax_t", "long")
p("ALIAS_uintmax_t", "unsigned long")
visited = set()
for name, type_ in cxx_types.int_types():
if type_ is not None and type_ not in visited:
visited.add(type_)
if type_.signed:
p("ALIAS_int%s_t" % (type_.size * 8), name)
else:
p("ALIAS_uint%s_t" % (type_.size * 8), name)
p("ALIAS_intptr_t", cxx_types.structural_alias(cxx_types.voidp))
p("ALIAS_uintptr_t", "unsigned " + cxx_types.structural_alias(cxx_types.voidp))
if not sys_types_h.ssize_t:
if c99_types.long_long and stddef_h.size_t.size == c99_types.long_long.size:
p("ALIAS_ssize_t", "long long")
else:
p("ALIAS_ssize_t", "long")
def build_runtime(host_phase, target_phase):
path = Path('src', 'rtl')
buildsystem.copy_hpps_to_rtl(
target_phase.ctx,
path / 'flx_rtl.hpp',
path / 'flx_rtl_shapes.hpp',
path / 'flx_compiler_support_headers.hpp',
path / 'flx_compiler_support_bodies.hpp',
path / 'flx_dynlink.hpp',
path / 'flx_i18n.hpp',
path / 'flx_ioutil.hpp',
path / 'flx_strutil.hpp',
path / 'flx_executil.hpp',
path / 'flx_sync.hpp',
path / 'flx_world.hpp',
path / 'flx_async_world.hpp',
path / 'flx_world_config.hpp',
path / 'plat_linux.hpp',
)
for f in Path.glob(path / "*.hpp"):
print("Copying " + f + " --> " + target_phase.ctx.buildroot / f)
copy(ctx=target_phase.ctx, src=f, dst=target_phase.ctx.buildroot / f)
srcs = [
copy(ctx=target_phase.ctx, src=f, dst=target_phase.ctx.buildroot / f)
for f in Path.glob(path / '*.cpp')
]
includes = [
target_phase.ctx.buildroot / 'host/lib/rtl',
target_phase.ctx.buildroot / 'share/lib/rtl'
]
macros = ['BUILD_RTL']
libs = [
call('buildsystem.flx_async.build_runtime', host_phase, target_phase),
call('buildsystem.flx_exceptions.build_runtime', target_phase),
call('buildsystem.flx_gc.build_runtime', host_phase, target_phase),
]
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h',
target_phase.platform, target_phase.cxx.static,
target_phase.cxx.shared)
if dlfcn_h.dlopen:
external_libs = dlfcn_h.external_libs
else:
external_libs = []
dst = 'host/lib/rtl/flx'
return Record(static=buildsystem.build_cxx_static_lib(
target_phase,
dst,
srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=external_libs),
shared=buildsystem.build_cxx_shared_lib(
target_phase,
dst,
srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=external_libs))
def build_runtime(phase):
path = Path('src/demux')
buildsystem.copy_hpps_to_rtl(phase.ctx,
#phase.ctx.buildroot / 'lib/rtl/flx_demux_config.hpp', # portable
# portable
path / 'flx_demux.hpp',
path / 'demux_demuxer.hpp',
path / 'demux_timer_queue.hpp',
path / 'demux_quitter.hpp',
# windows (monolithic)
path / 'win/demux_iocp_demuxer.hpp',
path / 'win/demux_overlapped.hpp',
path / 'win/demux_win_timer_queue.hpp',
path / 'win/demux_wself_piper.hpp',
# posix
path / 'posix/demux_posix_demuxer.hpp',
path / 'posix/demux_posix_timer_queue.hpp',
path / 'posix/demux_pfileio.hpp',
path / 'posix/demux_select_demuxer.hpp',
path / 'posix/demux_sockety.hpp',
path / 'posix/demux_self_piper.hpp',
path / 'posix/demux_ts_select_demuxer.hpp',
# linux, osx 10.3 (select impl), 10.4 real.
path / 'poll/demux_poll_demuxer.hpp',
path / 'poll/demux_ts_poll_demuxer.hpp',
# linux (>= 2.6)
path / 'epoll/demux_epoll_demuxer.hpp',
# osx (10.3 onwards)/bsd
path / 'kqueue/demux_kqueue_demuxer.hpp',
# solaris (9 onwards?)
path / 'evtport/demux_evtport_demuxer.hpp',
)
dst = 'host/lib/rtl/demux'
srcs = [path / '*.cpp']
includes = [
phase.ctx.buildroot / 'host/lib/rtl',
Path('src', 'pthread'),
Path('src', 'gc'),
path,
]
macros = ['BUILD_DEMUX']
libs = [call('buildsystem.flx_pthread.build_runtime', phase)]
extra_libs = []
if 'win32' in phase.platform:
print("DEMUX: providing WIN32 IO COMPLETION PORTS");
srcs.extend((
path / 'win/demux_iocp_demuxer.cpp', # windows
path / 'win/demux_overlapped.cpp', # windows
path / 'win/demux_wself_piper.cpp', # windows
path / 'win/demux_win_timer_queue.cpp', # windows
))
includes.append(path / 'win')
extra_libs.extend(('ws2_32', 'mswsock'))
if 'posix' in phase.platform:
print("DEMUX: providing POSIX SELECT");
srcs.extend((
path / 'posix/demux_posix_demuxer.cpp', # posix
path / 'posix/demux_select_demuxer.cpp', # posix
path / 'posix/demux_posix_timer_queue.cpp', # posix
path / 'posix/demux_sockety.cpp', # posix
path / 'posix/demux_self_piper.cpp', # posix
path / 'posix/demux_pfileio.cpp', # posix
path / 'posix/demux_ts_select_demuxer.cpp', # posix
))
includes.append(path / 'posix')
poll_h = config_call('fbuild.config.c.posix.poll_h', phase.platform, phase.cxx.shared)
sys_epoll_h = config_call('fbuild.config.c.linux.sys_epoll_h', phase.platform, phase.cxx.shared)
sys_event_h = config_call('fbuild.config.c.bsd.sys_event_h', phase.platform, phase.cxx.shared)
port_h = config_call('fbuild.config.c.solaris.port_h', phase.platform, phase.cxx.shared)
if poll_h.header:
print("DEMUX: providing UNIX POLL");
srcs.extend((
# I've seen poll on linux and osx10.4 systems.
# conditionally compiled and used.
path / 'poll/demux_poll_demuxer.cpp', # I've seen this on linux and osx10.4
path / 'poll/demux_ts_poll_demuxer.cpp', # ditto
))
includes.append(path / 'poll')
if sys_epoll_h.header:
print("DEMUX: providing LINUX EPOLL");
srcs.append(path / 'epoll/demux_epoll_demuxer.cpp')
includes.append(path / 'epoll')
if sys_event_h.header:
print("DEMUX: providing OSX KQUEUE");
srcs.append(path / 'kqueue/demux_kqueue_demuxer.cpp')
includes.append(path / 'kqueue')
if port_h.header:
print("DEMUX: providingd SOLARIS EVENT PORTS");
srcs.append(path / 'evtport/demux_evtport_demuxer.cpp')
includes.append(path / 'evtport')
srcs = Path.globall(srcs)
lp = len (path)
#print("demux: srcs = ", [str (src)[lp+1:] for src in srcs])
#print("demux: include paths = ", [str(inc) for inc in includes])
return Record(
static=buildsystem.build_cxx_static_lib(phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=extra_libs),
shared=buildsystem.build_cxx_shared_lib(phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=extra_libs))
def configure(ctx):
"""Configure Felix."""
build = config_build(ctx)
host = config_host(ctx, build)
target = config_target(ctx, host)
# Make sure the config directories exist.
#(ctx.buildroot / 'host/config').makedirs()
# copy the config directory for initial config
# this will be overwritten by subsequent steps if
# necessary
#
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/*.fpc').glob())
# most of these ones are actually platform independent
# just do the windows EXTERN to dllexport mapping
# which is controlled by compile time switches anyhow
# should probably move these out of config directory
# they're put in config in case there really are any
# platform mods.
buildsystem.copy_to(ctx, ctx.buildroot / 'host/lib/rtl',
Path('src/config/target/*.hpp').glob())
buildsystem.copy_to(ctx, ctx.buildroot / 'host/lib/rtl',
Path('src/config/target/*.h').glob())
types = config_call('fbuild.config.c.c99.types', target.platform,
target.c.static)
# this is a hack: assume we're running on Unix.
# later when Erick figures out how to fix this
# we'd copy the win32 subdirectory entries instead
if "posix" in target.platform:
print("COPYING POSIX RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/unix/*.fpc').glob())
if types.voidp.size == 4:
print("32 bit Unix")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/unix/unix32/*.fpc').glob())
else:
print("64 bit Unix")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/unix/unix64/*.fpc').glob())
if "linux" in target.platform:
print("COPYING LINUX RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/linux/*.fpc').glob())
# enable this on win32 **instead** of the above to copy fpc files
if "windows" in target.platform:
print("COPYING WIN32 RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/win32/*.fpc').glob())
# enable this on solaris to clobber any fpc files
# where the generic unix ones are inadequate
#buildsystem.copy_to(ctx,
# ctx.buildroot / 'config', Path('src/config/solaris/*.fpc').glob())
# enable this on osx to clobber any fpc files
# where the generic unix ones are inadequate
if 'macosx' in target.platform:
print("COPYING MACOSX RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/macosx/*.fpc').glob())
if 'cygwin' in target.platform:
print("COPYING CYWGIN (POSIX) RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/cygwin/*.fpc').glob())
if 'msys' in target.platform:
print("COPYING MSYS RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/msys/*.fpc').glob())
if 'solaris' in target.platform:
print("COPYING SOLARIS RESOURCE DATABASE")
buildsystem.copy_to(ctx, ctx.buildroot / 'host/config',
Path('src/config/solaris/*.fpc').glob())
# extract the configuration
iscr = call('buildsystem.iscr.Iscr', ctx)
# convert the config into something iscr can use
call('buildsystem.iscr.config_iscr_config', ctx, build, host, target)
# re-extract packages if any of them changed
ctx.scheduler.map(iscr, (src_dir(ctx) / 'lpsrc/*.pak').glob())
# overwrite or add *.fpc files to the config directory
call('buildsystem.post_config.copy_user_fpcs', ctx)
# set the toolchain
dst = ctx.buildroot / 'host/config/toolchain.fpc'
if 'macosx' in target.platform:
toolchain = "toolchain_" + hack_toolchain_name(str(
target.c.static)) + "_osx"
elif "windows" in target.platform:
toolchain = "toolchain_msvc_win32"
else:
toolchain = "toolchain_" + hack_toolchain_name(str(
target.c.static)) + "_linux"
print("**********************************************")
print("SETTING TOOLCHAIN " + toolchain)
print("**********************************************")
f = open(dst, "w")
f.write("toolchain: " + toolchain + "\n")
f.close()
# make Felix representation of whole build config
call('buildsystem.show_build_config.build', ctx)
return Record(build=build, host=host, target=target), iscr
def _print_cxx_bugs(ctx, platform, lang, p):
compiler = config_call('fbuild.config.cxx.compiler.bugs', platform,
lang.static)
p('HAVE_INCLASS_MEMBER_INITIALIZATION',
compiler.class_member_intialization)
def _print_c99_support(platform, lang, p):
stdio_h = config_call('fbuild.config.c.stdlib.stdio_h', platform,
lang.static)
p('HAVE_VSNPRINTF', bool(stdio_h.vsnprintf))
def _print_compiler(ctx, lang, platform, p):
# determine information about the compiler
p("HAVE_PIC", "-fPIC" in lang.shared.compiler.flags)
p("PIC", "-fPIC")
static = lang.static
shared = lang.shared
if "windows" in platform:
p("SPEC_OBJ_FILENAME", "/Fo")
p("SPEC_EXE_FILENAME", "/Fe")
p(
"CCOBJ_STATIC_FLX",
'"'
+ str(static.compiler.cl.exe)
+ '" /nologo /c '
+ " ".join(static.compiler.flags)
+ " "
+ " ".join("-I" + i for i in static.compiler.cl.includes),
)
p(
"CCOBJ_DYNAMIC_FLX",
'"'
+ str(shared.compiler.cl.exe)
+ '" /nologo /c '
+ " ".join(shared.compiler.flags)
+ " "
+ " ".join("-I" + i for i in static.compiler.cl.includes),
)
p(
"CCLINK_STATIC",
'"'
+ str(static.compiler.cl.exe)
+ '" /nologo '
+ " ".join(shared.exe_linker.flags)
+ " "
+ " ".join("-L" + i for i in static.exe_linker.libpaths),
)
p(
"CCLINK_DYNAMIC_FLX",
'"'
+ str(shared.compiler.cl.exe)
+ '" /nologo '
+ " ".join(shared.lib_linker.flags)
+ " "
+ " ".join("-L" + i for i in shared.lib_linker.libpaths),
)
else:
p("SPEC_OBJ_FILENAME", "-o ")
p("SPEC_EXE_FILENAME", "-o ")
static_arch = static.compiler.cc.arch
p(
"CCOBJ_STATIC_FLX",
str(static.compiler.cc.exe)
+ " -c "
+ " ".join(static.compiler.flags)
+ " "
+ " ".join("-I" + i for i in static.compiler.cc.includes)
+ " "
+ " ".join("-m" + i for i in static.compiler.cc.machine_flags)
+ " "
+ ("-arch " + static_arch if static_arch else "")
+ " "
+ " ".join("-W" + i for i in static.compiler.cc.warnings),
)
p(
"CCLINK_STATIC",
str(static.exe_linker.cc.exe)
+ " "
+ " ".join(shared.exe_linker.flags)
+ " "
+ " ".join("-m" + i for i in static.compiler.cc.machine_flags)
+ " "
+ ("-arch " + static_arch if static_arch else "")
+ " "
+ " ".join("-L" + i for i in static.exe_linker.cc.libpaths),
)
shared_arch = shared.compiler.cc.arch
p(
"CCOBJ_DYNAMIC_FLX",
str(shared.compiler.cc.exe)
+ " -c "
+ " ".join(shared.compiler.flags)
+ " "
+ " ".join("-I" + i for i in shared.compiler.cc.includes)
+ " "
+ ("-arch " + shared_arch if shared_arch else "")
+ " "
+ " ".join("-m" + i for i in shared.compiler.cc.machine_flags)
+ " "
+ " ".join("-W" + i for i in static.compiler.cc.warnings),
)
p(
"CCLINK_DYNAMIC_FLX",
str(shared.lib_linker.cc.exe)
+ " "
+ " ".join(shared.lib_linker.flags)
+ " "
+ ("-arch " + shared_arch if shared_arch else "")
+ " "
+ " ".join("-m" + i for i in shared.compiler.cc.machine_flags)
+ " "
+ " ".join("-L" + i for i in shared.compiler.cc.libpaths),
)
p("EXT_STATIC_OBJ", fbuild.builders.platform.static_obj_suffix(ctx))
p("EXT_SHARED_OBJ", fbuild.builders.platform.shared_obj_suffix(ctx))
p("EXT_LIB", fbuild.builders.platform.static_lib_suffix(ctx))
p("EXT_SHLIB", fbuild.builders.platform.shared_lib_suffix(ctx))
p("EXT_EXE", fbuild.builders.platform.exe_suffix(ctx))
if "windows" in platform:
p("OPTIMISE", " ".join(static.compiler.cl.optimize_flags))
p("DEBUG_FLAGS", " ".join(static.compiler.cl.debug_flags))
else:
p("OPTIMISE", " ".join(static.compiler.cc.optimize_flags))
p("DEBUG_FLAGS", " ".join(static.compiler.cc.debug_flags))
p("LITTLE_ENDIAN", config_call("fbuild.config.c.platform.arch", platform, static).little_endian)
def _print_c99_support(platform, lang, p):
stdio_h = config_call('fbuild.config.c.stdlib.stdio_h',
platform, lang.static)
p('HAVE_VSNPRINTF', bool(stdio_h.vsnprintf))
def _print_config(ctx, f, build, host, target):
def p(msg, *args):
if not args:
print(msg, file=f)
else:
print(msg, '=', file=f, *(repr(a) for a in args))
def pp(msg, *args):
p(' ' + msg, *args)
# --------------------------------------------------------------------------
# version information
p('flx_version = ' + repr (version.flx_version))
p('flx_version_major = ' + repr (version.flx_version_major))
p('flx_version_minor = ' + repr (version.flx_version_minor))
p('flx_version_patch = ' + repr (version.flx_version_patch))
p('flx_version_release = ' + repr (version.flx_version_release))
# --------------------------------------------------------------------------
# setup paths
p('src_dir', str(call('fbuildroot.src_dir', ctx)))
p('PREFIX', str(call('fbuildroot.prefix', ctx)))
p('FLXCC_CPP', 'cpp ')
# --------------------------------------------------------------------------
# get all the platform information
supported_platforms = set()
for platforms in fbuild.builders.platform.archmap.values():
supported_platforms |= platforms
supported_platforms = sorted(supported_platforms)
windows_h = config_call('fbuild.config.c.win32.windows_h',
target.platform, target.c.static)
p('HAVE_MSVC', bool(windows_h.header))
p('HAVE_GNU', 'windows' not in target.platform)
# --------------------------------------------------------------------------
# phases
for phase_name, phase in (
('build', build), ('host', host), ('target', target)):
for lang in 'c', 'cxx':
p('class ' + phase_name.upper() + '_' + lang.upper() + ':')
p(' class options:')
platform = phase.platform
for name in supported_platforms:
pp(name.upper(), name in platform)
lang = phase[lang]
_print_compiler(ctx, lang, platform, pp)
_print_types(platform, lang, pp)
_print_c99_support(platform, lang, pp)
_print_posix_support(platform, lang, pp)
_print_windows_support(platform, lang, pp)
_print_math_support(platform, lang, pp)
_print_openmp_support(ctx, platform, lang, pp)
_print_cxx_bugs(ctx, platform, lang, pp)
_print_gcc_extensions(platform, lang, pp)
# --------------------------------------------------------------------------
# expose target_cxx to the top level config
for platform in supported_platforms:
p(platform.upper() + '=TARGET_CXX.options.' + platform.upper())
# --------------------------------------------------------------------------
# figure out the global library loading scheme
p('SUPPORT_STATIC_LINKAGE', True)
p('SUPPORT_DYNAMIC_LOADING', True) #TARGET_CXX.options.SUPPORT_DYNAMIC_LOADING')
p('if SUPPORT_DYNAMIC_LOADING:')
p(' DEFAULT_LINK_MODEL', 'dynamic')
p('else:')
p(' DEFAULT_LINK_MODEL', 'static')
def _build_objs(host_phase, target_phase, builder, dstname):
"""
Build the object files for Judy1 or JudyL. Unfortunately the judy build
process is a little complicated because the same underlying code is used for
bit arrays and word arrays. The only distinguishing feature is if the macro
JUDY1 or JUDYL is defined. This function abstracts the handling of this
distinction.
"""
path = Path("src/judy/src")
includes = [path, path / "JudyCommon", path / dstname]
types = config_call("fbuild.config.c.c99.types", target_phase.platform, builder)
macros = [dstname.upper()]
if types.voidp.size == 8:
macros.append("JU_64BIT")
else:
macros.append("JU_32BIT")
kwargs = {}
if "iphone" in target_phase.platform:
kwargs["machine_flags"] = ["32"]
# First, copy all the common files into the Judy* directory.
srcs = []
srcs.extend(
copy_regex(
target_phase.ctx,
srcdir=path / "JudyCommon",
dstdir=path / dstname,
src_pattern=r"^Judy(.*\.c)",
dst_pattern=r"%s\1" % dstname,
exclude_pattern=r"("
r"JudyMalloc.c|"
r"JudyByCount.c|"
r"JudyPrevNext.c|"
r"JudyPrevNextEmpty.c|"
r"JudyTables.c|"
r"JudyPrintJP.c)",
)
)
# Create the tablegen.
tablegen = host_phase.c.static.build_exe(
path / dstname / dstname + "TableGen",
[copy(target_phase.ctx, src=path / "JudyCommon/JudyTables.c", dst=path / dstname / dstname + "TablesGen.c")],
includes=includes,
macros=macros,
ckwargs=kwargs,
lkwargs=kwargs,
)
# Create the table source.
srcs.append(
build_judytables(target_phase.ctx, tablegen, target_phase.ctx.buildroot / path / dstname / dstname + "Tables.c")
)
# Compile the objects.
objs = []
objs.extend(builder.build_objects(srcs, includes=includes, macros=macros))
objs.extend(
(
builder.compile(
path / "JudyCommon/JudyGet.c",
dst=path / dstname / "j__udyGet.c",
includes=includes,
macros=macros + ["JUDYGETINLINE"],
),
builder.compile(
path / "JudyCommon/JudyPrevNext.c",
dst=path / dstname / dstname + "Next.c",
includes=includes,
macros=macros + ["JUDYNEXT"],
),
builder.compile(
path / "JudyCommon/JudyPrevNextEmpty.c",
dst=path / dstname / dstname + "NextEmpty.c",
includes=includes,
macros=macros + ["JUDYNEXT"],
),
builder.compile(
path / "JudyCommon/JudyPrevNext.c",
dst=path / dstname / dstname + "Prev.c",
includes=includes,
macros=macros + ["JUDYPREV"],
),
builder.compile(
path / "JudyCommon/JudyPrevNextEmpty.c",
dst=path / dstname / dstname + "PrevEmpty.c",
includes=includes,
macros=macros + ["JUDYPREV"],
),
builder.compile(
path / "JudyCommon/JudyByCount.c",
path / dstname / dstname + "ByCount.c",
includes=includes,
macros=macros + ["NOSMARTJBB", "NOSMARTJBU", "NOSMARTJLB"],
),
)
)
return objs
def build_runtime(phase):
path = Path('src/demux')
buildsystem.copy_hpps_to_rtl(phase.ctx,
#phase.ctx.buildroot / 'config/target/flx_demux_config.hpp', # portable
# portable
path / 'flx_demux.hpp',
path / 'demux_demuxer.hpp',
path / 'demux_timer_queue.hpp',
path / 'demux_quitter.hpp',
# windows (monolithic)
path / 'win/demux_iocp_demuxer.hpp',
path / 'win/demux_overlapped.hpp',
path / 'win/demux_win_timer_queue.hpp',
path / 'win/demux_wself_piper.hpp',
# posix
path / 'posix/demux_posix_demuxer.hpp',
path / 'posix/demux_posix_timer_queue.hpp',
path / 'posix/demux_pfileio.hpp',
path / 'posix/demux_select_demuxer.hpp',
path / 'posix/demux_sockety.hpp',
path / 'posix/demux_self_piper.hpp',
path / 'posix/demux_ts_select_demuxer.hpp',
# linux, osx 10.3 (select impl), 10.4 real.
path / 'poll/demux_poll_demuxer.hpp',
path / 'poll/demux_ts_poll_demuxer.hpp',
# linux (>= 2.6)
path / 'epoll/demux_epoll_demuxer.hpp',
# osx (10.3 onwards)/bsd
path / 'kqueue/demux_kqueue_demuxer.hpp',
# solaris (9 onwards?)
path / 'evtport/demux_evtport_demuxer.hpp',
)
dst = 'lib/rtl/demux'
srcs = [path / '*.cpp']
includes = [
phase.ctx.buildroot / 'config/target',
Path('src', 'pthread'),
Path('src', 'gc'),
path,
]
macros = ['BUILD_DEMUX']
libs = [call('buildsystem.flx_pthread.build_runtime', phase)]
extra_libs = []
if 'win32' in phase.platform:
print("DEMUX: providing WIN32 IO COMPLETION PORTS");
srcs.extend((
path / 'win/demux_iocp_demuxer.cpp', # windows
path / 'win/demux_overlapped.cpp', # windows
path / 'win/demux_wself_piper.cpp', # windows
path / 'win/demux_win_timer_queue.cpp', # windows
))
includes.append(path / 'win')
extra_libs.extend(('ws2_32', 'mswsock'))
if 'posix' in phase.platform:
print("DEMUX: providing POSIX SELECT");
srcs.extend((
path / 'posix/demux_posix_demuxer.cpp', # posix
path / 'posix/demux_select_demuxer.cpp', # posix
path / 'posix/demux_posix_timer_queue.cpp', # posix
path / 'posix/demux_sockety.cpp', # posix
path / 'posix/demux_self_piper.cpp', # posix
path / 'posix/demux_pfileio.cpp', # posix
path / 'posix/demux_ts_select_demuxer.cpp', # posix
))
includes.append(path / 'posix')
poll_h = config_call('fbuild.config.c.posix.poll_h', phase.platform, phase.cxx.shared)
sys_epoll_h = config_call('fbuild.config.c.linux.sys_epoll_h', phase.platform, phase.cxx.shared)
sys_event_h = config_call('fbuild.config.c.bsd.sys_event_h', phase.platform, phase.cxx.shared)
port_h = config_call('fbuild.config.c.solaris.port_h', phase.platform, phase.cxx.shared)
if poll_h.header:
print("DEMUX: providing UNIX POLL");
srcs.extend((
# I've seen poll on linux and osx10.4 systems.
# conditionally compiled and used.
path / 'poll/demux_poll_demuxer.cpp', # I've seen this on linux and osx10.4
path / 'poll/demux_ts_poll_demuxer.cpp', # ditto
))
includes.append(path / 'poll')
if sys_epoll_h.header:
print("DEMUX: providing LINUX EPOLL");
srcs.append(path / 'epoll/demux_epoll_demuxer.cpp')
includes.append(path / 'epoll')
if sys_event_h.header:
print("DEMUX: providing OSX KQUEUE");
srcs.append(path / 'kqueue/demux_kqueue_demuxer.cpp')
includes.append(path / 'kqueue')
if port_h.header:
print("DEMUX: providingd SOLARIS EVENT PORTS");
srcs.append(path / 'evtport/demux_evtport_demuxer.cpp')
includes.append(path / 'evtport')
srcs = Path.globall(srcs)
lp = len (path)
#print("demux: srcs = ", [str (src)[lp+1:] for src in srcs])
#print("demux: include paths = ", [str(inc) for inc in includes])
return Record(
static=buildsystem.build_cxx_static_lib(phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.static for lib in libs],
external_libs=extra_libs),
shared=buildsystem.build_cxx_shared_lib(phase, dst, srcs,
includes=includes,
macros=macros,
libs=[lib.shared for lib in libs],
external_libs=extra_libs))
def configure(ctx):
"""Configure Felix."""
build = config_build(ctx)
host = config_host(ctx, build)
target = config_target(ctx, host)
# Make sure the config directories exist.
#(ctx.buildroot / 'host/config').makedirs()
# copy the config directory for initial config
# this will be overwritten by subsequent steps if
# necessary
#
buildsystem.copy_to(ctx, ctx.buildroot/'host/config', Path('src/config/*.fpc').glob())
# most of these ones are actually platform independent
# just do the windows EXTERN to dllexport mapping
# which is controlled by compile time switches anyhow
# should probably move these out of config directory
# they're put in config in case there really are any
# platform mods.
buildsystem.copy_to(ctx, ctx.buildroot/'host/lib/rtl',
Path('src/config/target/*.hpp').glob())
buildsystem.copy_to(ctx, ctx.buildroot/'host/lib/rtl',
Path('src/config/target/*.h').glob())
types = config_call('fbuild.config.c.c99.types',
target.platform, target.c.static)
# this is a hack: assume we're running on Unix.
# later when Erick figures out how to fix this
# we'd copy the win32 subdirectory entries instead
if "posix" in target.platform:
print("COPYING POSIX RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/unix/*.fpc').glob())
if types.voidp.size == 4:
print("32 bit Unix")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/unix/unix32/*.fpc').glob())
else:
print("64 bit Unix")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/unix/unix64/*.fpc').glob())
if "linux" in target.platform:
print("COPYING LINUX RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/linux/*.fpc').glob())
# enable this on win32 **instead** of the above to copy fpc files
if "windows" in target.platform:
print("COPYING WIN32 RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/win32/*.fpc').glob())
# enable this on solaris to clobber any fpc files
# where the generic unix ones are inadequate
#buildsystem.copy_to(ctx,
# ctx.buildroot / 'config', Path('src/config/solaris/*.fpc').glob())
# enable this on osx to clobber any fpc files
# where the generic unix ones are inadequate
if 'macosx' in target.platform:
print("COPYING MACOSX RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/macosx/*.fpc').glob())
if 'cygwin' in target.platform:
print("COPYING CYWGIN (POSIX) RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/cygwin/*.fpc').glob())
if 'msys' in target.platform:
print("COPYING MSYS RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/msys/*.fpc').glob())
if 'solaris' in target.platform:
print("COPYING SOLARIS RESOURCE DATABASE")
buildsystem.copy_to(ctx,
ctx.buildroot / 'host/config', Path('src/config/solaris/*.fpc').glob())
# extract the configuration
iscr = call('buildsystem.iscr.Iscr', ctx)
# convert the config into something iscr can use
call('buildsystem.iscr.config_iscr_config', ctx, build, host, target)
# re-extract packages if any of them changed
ctx.scheduler.map(iscr, (src_dir(ctx)/'lpsrc/*.pak').glob())
# overwrite or add *.fpc files to the config directory
call('buildsystem.post_config.copy_user_fpcs', ctx)
# set the toolchain
dst = ctx.buildroot / 'host/config/toolchain.fpc'
if 'macosx' in target.platform:
toolchain = "toolchain_"+hack_toolchain_name(str(target.c.static))+"_osx"
elif "windows" in target.platform:
toolchain= "toolchain_msvc_win32"
else:
toolchain = "toolchain_"+hack_toolchain_name(str(target.c.static))+"_linux"
print("**********************************************")
print("SETTING TOOLCHAIN " + toolchain)
print("**********************************************")
f = open(dst,"w")
f.write ("toolchain: "+toolchain+"\n")
f.close()
# make Felix representation of whole build config
call('buildsystem.show_build_config.build',ctx)
return Record(build=build, host=host, target=target), iscr
def build_runtime(phase):
path = Path('src/tre/tre')
alloca_h = config_call('fbuild.config.c.malloc.alloca_h', phase.platform, phase.c.static)
dlfcn_h = config_call('fbuild.config.c.posix.dlfcn_h', phase.platform, phase.c.static, phase.c.shared)
getopt_h = config_call('fbuild.config.c.gnu.getopt_h', phase.platform, phase.c.static)
inttypes_h = config_call('fbuild.config.c.posix.inttypes_h', phase.platform, phase.c.static)
libutf8_h = config_call('fbuild.config.c.libutf8.libutf8_h', phase.platform, phase.c.static)
memory_h = config_call('fbuild.config.c.bsd.memory_h', phase.platform, phase.c.static)
regex_h = config_call('fbuild.config.c.posix.regex_h', phase.platform, phase.c.static)
stdint_h = config_call('fbuild.config.c.c99.stdint_h', phase.platform, phase.c.static)
stdlib_h = config_call('fbuild.config.c.posix.stdlib_h', phase.platform, phase.c.static)
string_h = config_call('fbuild.config.c.c99.string_h', phase.platform, phase.c.static)
strings_h = config_call('fbuild.config.c.posix.strings_h', phase.platform, phase.c.static)
sys_stat_h = config_call('fbuild.config.c.posix.sys_stat_h', phase.platform, phase.c.static)
sys_types_h = config_call('fbuild.config.c.posix.sys_types_h', phase.platform, phase.c.static)
unistd_h = config_call('fbuild.config.c.posix.unistd_h', phase.platform, phase.c.static)
wchar_h = config_call('fbuild.config.c.posix.wchar_h', phase.platform, phase.c.static)
wctype_h = config_call('fbuild.config.c.posix.wctype_h', phase.platform, phase.c.static)
if 'win32' in phase.platform:
inline = '__inline'
else:
inline = None
patterns = {
'CRAY_STACKSEG_END': None,
'C_ALLOCA': None,
'ENABLE_NLS': 0,
'HAVE_ALLOCA': alloca_h.alloca is not None,
'HAVE_WCSLEN': wchar_h.wcslen is not None,
'NDEBUG': 1,
'HAVE_ALLOCA_H': alloca_h.header is not None,
'HAVE_CFLOCALECOPYCURRENT': None,
'HAVE_CFPREFERENCESCOPYAPPVALUE': None,
'HAVE_DCGETTEXT': None,
'HAVE_DLFCN_H': dlfcn_h.header is not None,
'HAVE_GETOPT_H': getopt_h.header is not None ,
'HAVE_GETOPT_LONG': getopt_h.getopt_long is not None,
'HAVE_GETTEXT': None,
'HAVE_ICONV': None,
'HAVE_INTTYPES_H': inttypes_h.header is not None,
'HAVE_ISASCII': 1,
'HAVE_ISBLANK': 1,
'HAVE_ISWASCII': wctype_h.iswascii is not None,
'HAVE_ISWBLANK': wctype_h.iswblank is not None,
'HAVE_ISWCTYPE': wctype_h.iswctype is not None,
'HAVE_ISWLOWER': wctype_h.iswlower is not None,
'HAVE_ISWUPPER': wctype_h.iswupper is not None,
'HAVE_LIBUTF8_H': libutf8_h.header is not None,
'HAVE_MBRTOWC': wchar_h.mbrtowc is not None,
'HAVE_MBSTATE_T': wchar_h.mbstate_t is not None,
'HAVE_MBTOWC': stdlib_h.mbtowc is not None,
'HAVE_MEMORY_H': memory_h.header is not None,
'HAVE_REGEX_H': regex_h.header is not None,
'HAVE_REG_ERRCODE_T': regex_h.reg_errcode_t is not None,
'HAVE_STDINT_H': stdint_h.header is not None,
'HAVE_STDLIB_H': stdlib_h.header is not None,
'HAVE_STRINGS_H': strings_h.header is not None,
'HAVE_STRING_H': string_h.header is not None,
'HAVE_SYS_STAT_H': sys_stat_h.header is not None,
'HAVE_SYS_TYPES_H': sys_types_h.header is not None,
'HAVE_TOWLOWER': wctype_h.towlower is not None,
'HAVE_TOWUPPER': wctype_h.towupper is not None,
'HAVE_UNISTD_H': unistd_h.header is not None,
'HAVE_WCHAR_H': wchar_h.header is not None,
'HAVE_WCHAR_T': wchar_h.wchar_t is not None,
'HAVE_WCSCHR': wchar_h.wcschr is not None,
'HAVE_WCSCPY': wchar_h.wcscpy is not None,
'HAVE_WCSNCPY': wchar_h.wcsncpy is not None,
'HAVE_WCSRTOMBS': wchar_h.wcsrtombs is not None,
'HAVE_WCSTOMBS': stdlib_h.wcstombs is not None,
'HAVE_WCTYPE': wctype_h.wctype is not None,
'HAVE_WCTYPE_H': wctype_h.header is not None,
'HAVE_WINT_T': wctype_h.wint_t is not None,
'NO_MINUS_C_MINUS_O': None,
'PACKAGE': '"tre"',
'PACKAGE_TARNAME': '"tre"',
'PACKAGE_VERSION': '"0.8.0"',
'STACK_DIRECTION': None,
'VERSION': '"0.8.0"',
'PACKAGE_BUGREPORT': '"*****@*****.**"',
'PACKAGE_NAME': '"TRE"',
'PACKAGE_STRING': '"TRE 0.8.0"',
'PACKAGE_TARFILE': 'tre',
'STDC_HEADERS': 1,
'TRE_APPROX': 1,
'TRE_DEBUG': None,
'TRE_MULTIBYTE': wchar_h.header is not None,
'TRE_REGEX_T_FIELD': 'value',
'TRE_SYSTEM_REGEX_H_PATH': None,
'TRE_USE_ALLOCA': alloca_h.alloca is not None,
'TRE_USE_SYSTEM_REGEX_H': None,
'TRE_VERSION': '"0.8.0"',
'TRE_VERSION_1': '0',
'TRE_VERSION_2': '8',
'TRE_VERSION_3': '0',
'TRE_WCHAR': wchar_h.header is not None,
'WCHAR_MAX': None,
'WCHAR_T_SIGNED': None,
'WCHAR_T_UNSIGNED': None,
'_FILE_OFFSET_BITS': None,
'_GNU_SOURCE': 1,
'_LARGE_FILES': None,
'_REGCOMP_INTERNAL': None,
'const': None,
'inline': inline,
}
fbuild.builders.text.autoconf_config_header(phase.ctx,
path / 'config.h',
path / 'config.h.in',
patterns)
fbuild.builders.text.autoconf_config_header(phase.ctx,
path / 'lib/tre-config.h',
path / 'lib/tre-config.h.in',
patterns)
buildsystem.copy_to(phase.ctx, phase.ctx.buildroot / 'lib/rtl/tre', [
path / 'lib/tre.h',
phase.ctx.buildroot / path / 'lib/tre-config.h'])
dst = 'lib/rtl/tre'
srcs = Path.glob('src/tre/tre/lib/*.c')
includes = [
phase.ctx.buildroot / 'config/target',
phase.ctx.buildroot / path,
phase.ctx.buildroot / path / 'lib',
path / 'gnulib/lib',
]
macros = ['HAVE_CONFIG_H', 'BUILD_TRE']
#Workaround link error : unresolved external symbol _snprintf
#referenced in function _tre_version.
if 'win32' in phase.platform:
macros.append('snprintf=_snprintf')
return Record(
static=buildsystem.build_c_static_lib(phase, dst, srcs,
includes=includes,
macros=macros),
shared=buildsystem.build_c_shared_lib(phase, dst, srcs,
includes=includes,
macros=macros))
def test(ctx):
"""Run the felix tests and other commands."""
# Make sure we're built.
phases, iscr, felix = build(ctx)
from buildsystem.flx import test_flx, compile_flx
failed = []
def test(src):
try:
passed = test_flx(phases.target, felix, src)
except fbuild.ConfigFailed as e:
ctx.logger.log(str(e))
passed = False
return src, passed
def test_compile(src):
try:
passed = compile_flx(phases.target, felix, src)
except fbuild.ConfigFailed as e:
ctx.logger.log(str(e))
passed = False
return src, passed
# Run the dynamic loading tests first
ctx.logger.log("\nRunning dynamic loading tests\n", color='red')
try:
lib1 = felix.compile('test/regress/drt/lib1.flx', static=False)
lib2 = felix.compile('test/regress/drt/lib2.flx', static=False)
print("lib1="+lib1)
print("lib2="+lib2)
except fbuild.ExecutionError as e:
ctx.logger.log(e, verbose=1)
else:
if not test_flx(phases.target, felix, 'test/regress/drt/main1.flx',
env={'lib1': lib1, 'lib2': lib2}):
failed.append('test/regress/drt/main1.flx')
srcs = [
# CORE
('regress_rt' , Path.globall('test/regress/rt/*.flx')),
('regress_nd' , Path.globall('test/regress/nd/*.flx')),
('regress_stl' , Path.globall('test/regress/stl/*.flx')),
('tut_embedding' , Path.globall('tut/embedding/*.flx')),
('tut_migration', Path.globall('tut/migration/*.flx')),
('tut_tutorial', Path.globall('tut/tutorial/*.flx')),
('collection' , Path.globall('test/collection/*.flx')),
#('drivers' , Path.globall('test/drivers/*.flx')),
('glob' , Path.globall('test/glob/*.flx')),
('judy' , Path.globall('test/judy/*.flx')),
('sqlite3' , Path.globall('test/sqlite/*.flx')),
('pthread' , Path.globall('test/pthread/*.flx')),
('stdlib' , Path.globall('test/stdlib/*.flx')),
('tre' , Path.globall('test/tre/*.flx')),
('web' , Path.globall('test/web/*.flx',exclude=['test/web/xml2-*.flx'])),
# ASYNC I/O
('faio',Path.globall('test/faio/*.flx',exclude=['test/faio/posix-*.flx','test/faio/win-*.flx'])),
]
gmp_h = config_call(
'fbuild.config.c.gmp.gmp_h',
phases.target.platform,
phases.target.c.static).header
if gmp_h: ctx.logger.log("gmp supported",color='green')
else: ctx.logger.log("gmp NOT supported",color='red')
mman_h = config_call(
'fbuild.config.c.posix04.sys_mman_h',
phases.target.platform,
phases.target.c.static).header
if mman_h: ctx.logger.log("mmap supported",color='green')
else: ctx.logger.log("mmap NOT supported",color='red')
libxml2_libxml_xmlexports_h = config_call(
'fbuild.config.c.xml2.libxml2_libxml_xmlexports_h',
phases.target.platform,
phases.target.c.static).header
if libxml2_libxml_xmlexports_h: ctx.logger.log("libxml2 supported",color='green')
else: ctx.logger.log("libxml2 NOT supported",color='red')
zmq_h = config_call(
'fbuild.config.c.zmq.zmq_h',
phases.target.platform,
phases.target.c.static).header
if zmq_h: ctx.logger.log("zmq supported",color='green')
else: ctx.logger.log("zmq NOT supported",color='red')
osrcs = [
# EXTERNAL LIBS
('windows' in phases.target.platform,'faio_win', Path.globall('test/faio/win-*.flx')),
('posix' in phases.target.platform, 'faio_posix', Path.globall('test/faio/posix-*.flx')),
(gmp_h,'gmp', Path.globall('test/gmp/*.flx')),
(mman_h,'mmap', Path.globall('test/mmap/*.flx')),
(libxml2_libxml_xmlexports_h,'xml2', Path.globall('test/web/xml2-*flx')),
]
osrcs_compileonly = [
(zmq_h,'zmq', Path.globall('test/zmq/*.flx')),
]
#--------------------------------
ctx.logger.log("\nRunning core tests\n", color='cyan')
for name,paths in srcs:
failed_srcs = []
ctx.logger.log("Running test "+name, color='cyan')
for src, passed in phases.target.ctx.scheduler.map(
test,
sorted(paths, reverse=True)):
if not passed:
failed_srcs.append(src)
failed.append(src)
if failed_srcs:
ctx.logger.log('\nOf '+str (len (paths))+' tests')
ctx.logger.log('\nThe following tests failed:')
for src in failed_srcs:
ctx.logger.log(' %s' % src, color='yellow')
else:
ctx.logger.log('All ' + str (len (paths))+' tests passed', color='cyan')
ctx.logger.log("\nRunning optional tests\n", color='cyan')
for flag,name,paths in osrcs:
if flag:
failed_srcs = []
ctx.logger.log("Running test "+name, color='cyan')
for src, passed in phases.target.ctx.scheduler.map(
test,
sorted(paths, reverse=True)):
if not passed:
failed_srcs.append(src)
failed.append(src)
if failed_srcs:
ctx.logger.log('\nOf '+str (len (paths))+' tests')
ctx.logger.log('\nThe following tests failed:')
for src in failed_srcs:
ctx.logger.log(' %s' % src, color='yellow')
else:
ctx.logger.log('All ' + str (len (paths))+' tests passed', color='cyan')
else:
ctx.logger.log("SKIPPING test "+name+" resource not availabe", color='red')
ctx.logger.log("\nRunning optional compiler only tests\n", color='cyan')
for flag,name,paths in osrcs_compileonly:
if flag:
failed_srcs = []
ctx.logger.log("Compiling test "+name, color='cyan')
for src, passed in phases.target.ctx.scheduler.map(
test_compile,
sorted(paths, reverse=True)):
if not passed:
failed_srcs.append(src)
failed.append(src)
if failed_srcs:
ctx.logger.log('\nOf '+str (len (paths))+' tests')
ctx.logger.log('\nThe following tests failed:')
for src in failed_srcs:
ctx.logger.log(' %s' % src, color='yellow')
else:
ctx.logger.log('All ' + str (len (paths))+' tests passed', color='cyan')
else:
ctx.logger.log("SKIPPING test "+name+" resource not availabe", color='red')
if failed:
ctx.logger.log('\n======================================')
ctx.logger.log('\nThe following tests failed:')
for src in failed:
ctx.logger.log(' %s' % src, color='yellow')
def build_runtime(phase):
path = Path('src/pthread')
copy(ctx=phase.ctx,
src="src/config/target/flx_pthread_config.hpp",
dst=phase.ctx.buildroot / 'host/lib/rtl/flx_pthread_config.hpp')
buildsystem.copy_hpps_to_rtl(
phase.ctx,
# portable
path / 'pthread_thread.hpp',
path / 'pthread_mutex.hpp',
path / 'pthread_counter.hpp',
path / 'pthread_waitable_bool.hpp',
path / 'pthread_condv.hpp',
path / 'pthread_semaphore.hpp',
path / 'pthread_monitor.hpp',
# win32 and posix
path / 'pthread_win_posix_condv_emul.hpp',
)
srcs = [
copy(ctx=phase.ctx, src=f, dst=phase.ctx.buildroot / f) for f in [
path / 'pthread_win_posix_condv_emul.cpp', # portability hackery
path / 'pthread_mutex.cpp',
path / 'pthread_condv.cpp',
path / 'pthread_counter.cpp',
path / 'pthread_waitable_bool.cpp',
path / 'pthread_semaphore.cpp',
path / 'pthread_monitor.cpp',
path / 'pthread_thread_control.cpp',
path / 'pthread_win_thread.cpp',
path / 'pthread_posix_thread.cpp',
]
]
includes = [
phase.ctx.buildroot / 'host/lib/rtl',
phase.ctx.buildroot / 'share/lib/rtl',
'src/rtl',
]
macros = ['BUILD_PTHREAD']
flags = []
libs = []
external_libs = []
pthread_h = config_call('fbuild.config.c.posix.pthread_h', phase.platform,
phase.cxx.shared)
dst = 'host/lib/rtl/flx_pthread'
if pthread_h.pthread_create:
flags.extend(pthread_h.flags)
libs.extend(pthread_h.libs)
external_libs.extend(pthread_h.external_libs)
return Record(
static=buildsystem.build_cxx_static_lib(phase,
dst,
srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags),
shared=buildsystem.build_cxx_shared_lib(phase,
dst,
srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags))
def build_runtime(phase):
path = Path("src/pthread")
buildsystem.copy_hpps_to_rtl(
phase.ctx,
phase.ctx.buildroot / "config/target/flx_pthread_config.hpp",
# portable
path / "pthread_thread.hpp",
path / "pthread_mutex.hpp",
path / "pthread_counter.hpp",
path / "pthread_waitable_bool.hpp",
path / "pthread_condv.hpp",
path / "pthread_semaphore.hpp",
path / "pthread_monitor.hpp",
path / "pthread_sleep_queue.hpp",
path / "pthread_work_fifo.hpp",
# win32 and posix
path / "pthread_win_posix_condv_emul.hpp",
)
dst = "lib/rtl/flx_pthread"
srcs = [
path / "pthread_win_posix_condv_emul.cpp", # portability hackery
path / "pthread_mutex.cpp",
path / "pthread_condv.cpp",
path / "pthread_counter.cpp",
path / "pthread_waitable_bool.cpp",
path / "pthread_semaphore.cpp",
path / "pthread_monitor.cpp",
path / "pthread_sleep_queue.cpp",
path / "pthread_work_fifo.cpp",
path / "pthread_thread_control.cpp",
]
includes = [phase.ctx.buildroot / "config/target", "src/rtl"]
macros = ["BUILD_PTHREAD"]
flags = []
libs = []
external_libs = []
if "win32" in phase.platform:
srcs.append(path / "pthread_win_thread.cpp")
if "posix" in phase.platform:
srcs.append(path / "pthread_posix_thread.cpp")
pthread_h = config_call("fbuild.config.c.posix.pthread_h", phase.platform, phase.cxx.shared)
if pthread_h.pthread_create:
flags.extend(pthread_h.flags)
libs.extend(pthread_h.libs)
external_libs.extend(pthread_h.external_libs)
return Record(
static=buildsystem.build_cxx_static_lib(
phase,
dst,
srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags,
),
shared=buildsystem.build_cxx_shared_lib(
phase,
dst,
srcs,
includes=includes,
macros=macros,
cflags=flags,
libs=libs,
external_libs=external_libs,
lflags=flags,
),
)
