# Copyright Gennadiy Rozental
# Copyright 2006 Rene Rivera
# Copyright 2003, 2004, 2006 Vladimir Prus
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
# The STLPort is usable by means of 'stdlib' feature. When
# stdlib=stlport is specified, default version of STLPort will be used,
# while stdlib=stlport-4.5 will use specific version.
# The subfeature value 'hostios' means to use host compiler's iostreams.
#
# The specific version of stlport is selected by features:
# The feature selects between static and shared library
# The on selects STLPort with debug symbols
# and stl debugging.
# There's no way to use STLPort with debug symbols but without
# stl debugging.
# TODO: must implement selection of different STLPort installations based
# on used toolset.
# Also, finish various flags:
#
# This is copied from V1 toolset, "+" means "implemented"
#+flags $(CURR_TOOLSET) DEFINES off : _STLP_NO_OWN_IOSTREAMS=1 _STLP_HAS_NO_NEW_IOSTREAMS=1 ;
#+flags $(CURR_TOOLSET) DEFINES off : _STLP_NO_EXTENSIONS=1 ;
# flags $(CURR_TOOLSET) DEFINES off : _STLP_NO_ANACHRONISMS=1 ;
# flags $(CURR_TOOLSET) DEFINES global : _STLP_VENDOR_GLOBAL_CSTD=1 ;
# flags $(CURR_TOOLSET) DEFINES off : _STLP_NO_EXCEPTIONS=1 ;
# flags $(CURR_TOOLSET) DEFINES on : _STLP_DEBUG_ALLOC=1 ;
#+flags $(CURR_TOOLSET) DEFINES debug : _STLP_DEBUG=1 _STLP_DEBUG_UNINITIALIZED=1 ;
#+flags $(CURR_TOOLSET) DEFINES dynamic : _STLP_USE_DYNAMIC_LIB=1 ;
import feature : feature subfeature ;
import project ;
import "class" : new ;
import targets ;
import property-set ;
import common ;
import type ;
# Make this module into a project.
project.initialize $(__name__) ;
project stlport ;
# The problem: how to request to use host compiler's iostreams?
#
# Solution 1: Global 'stlport-iostream' feature.
# That's ugly. Subfeature make more sense for stlport-specific thing.
# Solution 2: Use subfeature with two values, one of which ("use STLPort iostream")
# is default.
# The problem is that such subfeature will appear in target paths, and that's ugly
# Solution 3: Use optional subfeature with only one value.
feature.extend stdlib : stlport ;
feature.compose stlport : /stlport//stlport ;
# STLport iostreams or native iostreams
subfeature stdlib stlport : iostream : hostios : optional propagated ;
# STLport extensions
subfeature stdlib stlport : extensions : noext : optional propagated ;
# STLport anachronisms -- NOT YET SUPPORTED
# subfeature stdlib stlport : anachronisms : on off ;
# STLport debug allocation -- NOT YET SUPPORTED
#subfeature stdlib stlport : debug-alloc : off on ;
# Declare a special target class to handle the creation of search-lib-target
# instances for STLport. We need a special class, because otherwise we'll have
# - declare prebuilt targets for all possible toolsets. And by the time 'init'
# is called we don't even know the list of toolsets that are registered
# - when host iostreams are used, we really should produce nothing. It would
# be hard/impossible to achieve this using prebuilt targets.
class stlport-target-class : basic-target
{
import feature project type errors generators ;
import set : difference ;
rule __init__ ( project : headers ? : libraries * : version ? )
{
basic-target.__init__ stlport : $(project) ;
self.headers = $(headers) ;
self.libraries = $(libraries) ;
self.version = $(version) ;
self.version.5 = [ MATCH "^(5[.][0123456789]+).*" : $(version) ] ;
local requirements ;
requirements += $(self.version) ;
requirements += runtime-debugging ;
requirements += toolset ;
requirements += runtime-link ;
self.requirements = [ property-set.create $(requirements) ] ;
}
rule generate ( property-set )
{
# Since this target is built with stlport, it will also
# have /stlport//stlport in requirements, which will
# cause a loop in main target references. Remove that property
# manually.
property-set = [ property-set.create
[ difference
[ $(property-set).raw ] :
/stlport//stlport
stlport
]
] ;
return [ basic-target.generate $(property-set) ] ;
}
rule construct ( name : source-targets * : property-set )
{
# Deduce the name of stlport library, based on toolset and
# debug setting.
local raw = [ $(property-set).raw ] ;
local hostios = [ feature.get-values : $(raw) ] ;
local toolset = [ feature.get-values : $(raw) ] ;
if $(self.version.5)
{
# Version 5.x
# STLport host IO streams no longer supported. So we always
# need libraries.
# name: stlport(stl)?[dg]?(_static)?.M.R
local name = stlport ;
if [ feature.get-values : $(raw) ] = "on"
{
name += stl ;
switch $(toolset)
{
case gcc* : name += g ;
case darwin* : name += g ;
case * : name += d ;
}
}
if [ feature.get-values : $(raw) ] = "static"
{
name += _static ;
}
# Starting with version 5.2.0, the STLport static libraries no
# longer include a version number in their name
local version.pre.5.2 = [ MATCH "^(5[.][01]+).*" : $(version) ] ;
if $(version.pre.5.2) || [ feature.get-values :
$(raw) ] != "static"
{
name += .$(self.version.5) ;
}
name = $(name:J=) ;
if [ feature.get-values : $(raw) ] = "on"
{
#~ Allow explicitly asking to install the STLport lib by
#~ referring to it directly:
#~ /stlport//stlport/on
#~ This allows for install packaging of all libs one might need
#~ for a standalone distribution.
import path : make : path-make ;
local runtime-link
= [ feature.get-values : $(raw) ] ;
local lib-file.props
= [ property-set.create $(raw) $(runtime-link) ] ;
local lib-file.prefix
= [ type.generated-target-prefix $(runtime-link:U)_LIB :
$(lib-file.props) ] ;
local lib-file.suffix
= [ type.generated-target-suffix $(runtime-link:U)_LIB :
$(lib-file.props) ] ;
lib-file.prefix
?= "" "lib" ;
lib-file.suffix
?= "" ;
local lib-file
= [ GLOB $(self.libraries) [ modules.peek : PATH ] :
$(lib-file.prefix)$(name).$(lib-file.suffix) ] ;
lib-file
= [ new file-reference [ path-make $(lib-file[1]) ] :
$(self.project) ] ;
lib-file
= [ $(lib-file).generate "" ] ;
local lib-file.requirements
= [ targets.main-target-requirements
[ $(lib-file.props).raw ] $(lib-file[-1])
: $(self.project) ] ;
return [ generators.construct $(self.project) $(name) : LIB :
$(lib-file.requirements) ] ;
}
else
{
#~ Otherwise, it is just regular library usage.
return [ generators.construct
$(self.project) $(name) : SEARCHED_LIB : $(property-set) ] ;
}
}
else if ! $(hostios) && $(toolset) != msvc
{
# We don't need libraries if host istreams are used. For
# msvc, automatic library selection will be used.
# name: stlport_(_stldebug)?
local name = stlport ;
name = $(name)_$(toolset) ;
if [ feature.get-values : $(raw) ] = "on"
{
name = $(name)_stldebug ;
}
return [ generators.construct
$(self.project) $(name) : SEARCHED_LIB : $(property-set) ] ;
}
else
{
return [ property-set.empty ] ;
}
}
rule compute-usage-requirements ( subvariant )
{
local usage-requirements =
$(self.headers)
$(self.libraries)
$(self.libraries)
;
local rproperties = [ $(subvariant).build-properties ] ;
# CONSIDER: should this "if" sequence be replaced with
# some use of 'property-map' class?
if [ $(rproperties).get ] = "on"
{
usage-requirements +=
_STLP_DEBUG=1
_STLP_DEBUG_UNINITIALIZED=1 ;
}
if [ $(rproperties).get ] = "shared"
{
usage-requirements +=
_STLP_USE_DYNAMIC_LIB=1 ;
}
if [ $(rproperties).get ] = noext
{
usage-requirements +=
_STLP_NO_EXTENSIONS=1 ;
}
if [ $(rproperties).get ] = hostios
{
usage-requirements +=
_STLP_NO_OWN_IOSTREAMS=1
_STLP_HAS_NO_NEW_IOSTREAMS=1 ;
}
if $(self.version.5)
{
# Version 5.x
if [ $(rproperties).get ] = "single"
{
# Since STLport5 doesn't normally support single-thread
# we force STLport5 into the multi-thread mode. Hence
# getting what other libs provide of single-thread code
# linking against a multi-thread lib.
usage-requirements +=
_STLP_THREADS=1 ;
}
}
return [ property-set.create $(usage-requirements) ] ;
}
}
rule stlport-target ( headers ? : libraries * : version ? )
{
local project = [ project.current ] ;
targets.main-target-alternative
[ new stlport-target-class $(project) : $(headers) : $(libraries)
: $(version)
] ;
}
local .version-subfeature-defined ;
# Initialize stlport support.
rule init (
version ? :
headers : # Location of header files
libraries * # Location of libraries, lib and bin subdirs of STLport.
)
{
# FIXME: need to use common.check-init-parameters here.
# At the moment, that rule always tries to define subfeature
# of the 'toolset' feature, while we need to define subfeature
# of stlport, so tweaks to check-init-parameters are needed.
if $(version)
{
if ! $(.version-subfeature-defined)
{
feature.subfeature stdlib stlport : version : : propagated ;
.version-subfeature-defined = true ;
}
feature.extend-subfeature stdlib stlport : version : $(version) ;
}
# Declare the main target for this STLPort version.
stlport-target $(headers) : $(libraries) : $(version) ;
}