1# Copyright Gennadiy Rozental 2# Copyright 2006 Rene Rivera 3# Copyright 2003, 2004, 2006 Vladimir Prus 4# Distributed under the Boost Software License, Version 1.0. 5# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 6 7# The STLPort is usable by means of 'stdlib' feature. When 8# stdlib=stlport is specified, default version of STLPort will be used, 9# while stdlib=stlport-4.5 will use specific version. 10# The subfeature value 'hostios' means to use host compiler's iostreams. 11# 12# The specific version of stlport is selected by features: 13# The <runtime-link> feature selects between static and shared library 14# The <runtime-debugging>on selects STLPort with debug symbols 15# and stl debugging. 16# There's no way to use STLPort with debug symbols but without 17# stl debugging. 18 19# TODO: must implement selection of different STLPort installations based 20# on used toolset. 21# Also, finish various flags: 22# 23# This is copied from V1 toolset, "+" means "implemented" 24#+flags $(CURR_TOOLSET) DEFINES <stlport-iostream>off : _STLP_NO_OWN_IOSTREAMS=1 _STLP_HAS_NO_NEW_IOSTREAMS=1 ; 25#+flags $(CURR_TOOLSET) DEFINES <stlport-extensions>off : _STLP_NO_EXTENSIONS=1 ; 26# flags $(CURR_TOOLSET) DEFINES <stlport-anachronisms>off : _STLP_NO_ANACHRONISMS=1 ; 27# flags $(CURR_TOOLSET) DEFINES <stlport-cstd-namespace>global : _STLP_VENDOR_GLOBAL_CSTD=1 ; 28# flags $(CURR_TOOLSET) DEFINES <exception-handling>off : _STLP_NO_EXCEPTIONS=1 ; 29# flags $(CURR_TOOLSET) DEFINES <stlport-debug-alloc>on : _STLP_DEBUG_ALLOC=1 ; 30#+flags $(CURR_TOOLSET) DEFINES <runtime-build>debug : _STLP_DEBUG=1 _STLP_DEBUG_UNINITIALIZED=1 ; 31#+flags $(CURR_TOOLSET) DEFINES <runtime-link>dynamic : _STLP_USE_DYNAMIC_LIB=1 ; 32 33 34import feature : feature subfeature ; 35import project ; 36import "class" : new ; 37import targets ; 38import property-set ; 39import common ; 40import type ; 41 42# Make this module into a project. 43project.initialize $(__name__) ; 44project stlport ; 45 46# The problem: how to request to use host compiler's iostreams? 47# 48# Solution 1: Global 'stlport-iostream' feature. 49# That's ugly. Subfeature make more sense for stlport-specific thing. 50# Solution 2: Use subfeature with two values, one of which ("use STLPort iostream") 51# is default. 52# The problem is that such subfeature will appear in target paths, and that's ugly 53# Solution 3: Use optional subfeature with only one value. 54 55feature.extend stdlib : stlport ; 56feature.compose <stdlib>stlport : <library>/stlport//stlport ; 57 58# STLport iostreams or native iostreams 59subfeature stdlib stlport : iostream : hostios : optional propagated ; 60 61# STLport extensions 62subfeature stdlib stlport : extensions : noext : optional propagated ; 63 64# STLport anachronisms -- NOT YET SUPPORTED 65# subfeature stdlib stlport : anachronisms : on off ; 66 67# STLport debug allocation -- NOT YET SUPPORTED 68#subfeature stdlib stlport : debug-alloc : off on ; 69 70# Declare a special target class to handle the creation of search-lib-target 71# instances for STLport. We need a special class, because otherwise we'll have 72# - declare prebuilt targets for all possible toolsets. And by the time 'init' 73# is called we don't even know the list of toolsets that are registered 74# - when host iostreams are used, we really should produce nothing. It would 75# be hard/impossible to achieve this using prebuilt targets. 76 77class stlport-target-class : basic-target 78{ 79 import feature project type errors generators ; 80 import set : difference ; 81 82 rule __init__ ( project : headers ? : libraries * : version ? ) 83 { 84 basic-target.__init__ stlport : $(project) ; 85 self.headers = $(headers) ; 86 self.libraries = $(libraries) ; 87 self.version = $(version) ; 88 self.version.5 = [ MATCH "^(5[.][0123456789]+).*" : $(version) ] ; 89 90 local requirements ; 91 requirements += <stdlib-stlport:version>$(self.version) ; 92 requirements += <relevant>runtime-debugging ; 93 requirements += <relevant>toolset ; 94 requirements += <relevant>runtime-link ; 95 self.requirements = [ property-set.create $(requirements) ] ; 96 } 97 98 rule generate ( property-set ) 99 { 100 # Since this target is built with <stdlib>stlport, it will also 101 # have <library>/stlport//stlport in requirements, which will 102 # cause a loop in main target references. Remove that property 103 # manually. 104 105 property-set = [ property-set.create 106 [ difference 107 [ $(property-set).raw ] : 108 <library>/stlport//stlport 109 <stdlib>stlport 110 ] 111 ] ; 112 return [ basic-target.generate $(property-set) ] ; 113 } 114 115 rule construct ( name : source-targets * : property-set ) 116 { 117 # Deduce the name of stlport library, based on toolset and 118 # debug setting. 119 local raw = [ $(property-set).raw ] ; 120 local hostios = [ feature.get-values <stdlib-stlport:iostream> : $(raw) ] ; 121 local toolset = [ feature.get-values <toolset> : $(raw) ] ; 122 123 if $(self.version.5) 124 { 125 # Version 5.x 126 127 # STLport host IO streams no longer supported. So we always 128 # need libraries. 129 130 # name: stlport(stl)?[dg]?(_static)?.M.R 131 local name = stlport ; 132 if [ feature.get-values <runtime-debugging> : $(raw) ] = "on" 133 { 134 name += stl ; 135 switch $(toolset) 136 { 137 case gcc* : name += g ; 138 case darwin* : name += g ; 139 case * : name += d ; 140 } 141 } 142 143 if [ feature.get-values <runtime-link> : $(raw) ] = "static" 144 { 145 name += _static ; 146 } 147 148 # Starting with version 5.2.0, the STLport static libraries no 149 # longer include a version number in their name 150 local version.pre.5.2 = [ MATCH "^(5[.][01]+).*" : $(version) ] ; 151 if $(version.pre.5.2) || [ feature.get-values <runtime-link> : 152 $(raw) ] != "static" 153 { 154 name += .$(self.version.5) ; 155 } 156 157 name = $(name:J=) ; 158 159 if [ feature.get-values <install-dependencies> : $(raw) ] = "on" 160 { 161 #~ Allow explicitly asking to install the STLport lib by 162 #~ referring to it directly: 163 #~ /stlport//stlport/<install-dependencies>on 164 #~ This allows for install packaging of all libs one might need 165 #~ for a standalone distribution. 166 import path : make : path-make ; 167 local runtime-link 168 = [ feature.get-values <runtime-link> : $(raw) ] ; 169 local lib-file.props 170 = [ property-set.create $(raw) <link>$(runtime-link) ] ; 171 local lib-file.prefix 172 = [ type.generated-target-prefix $(runtime-link:U)_LIB : 173 $(lib-file.props) ] ; 174 local lib-file.suffix 175 = [ type.generated-target-suffix $(runtime-link:U)_LIB : 176 $(lib-file.props) ] ; 177 lib-file.prefix 178 ?= "" "lib" ; 179 lib-file.suffix 180 ?= "" ; 181 local lib-file 182 = [ GLOB $(self.libraries) [ modules.peek : PATH ] : 183 $(lib-file.prefix)$(name).$(lib-file.suffix) ] ; 184 lib-file 185 = [ new file-reference [ path-make $(lib-file[1]) ] : 186 $(self.project) ] ; 187 lib-file 188 = [ $(lib-file).generate "" ] ; 189 local lib-file.requirements 190 = [ targets.main-target-requirements 191 [ $(lib-file.props).raw ] <file>$(lib-file[-1]) 192 : $(self.project) ] ; 193 return [ generators.construct $(self.project) $(name) : LIB : 194 $(lib-file.requirements) ] ; 195 } 196 else 197 { 198 #~ Otherwise, it is just regular library usage. 199 return [ generators.construct 200 $(self.project) $(name) : SEARCHED_LIB : $(property-set) ] ; 201 } 202 } 203 else if ! $(hostios) && $(toolset) != msvc 204 { 205 # We don't need libraries if host istreams are used. For 206 # msvc, automatic library selection will be used. 207 208 # name: stlport_<toolset>(_stldebug)? 209 local name = stlport ; 210 name = $(name)_$(toolset) ; 211 if [ feature.get-values <runtime-debugging> : $(raw) ] = "on" 212 { 213 name = $(name)_stldebug ; 214 } 215 216 return [ generators.construct 217 $(self.project) $(name) : SEARCHED_LIB : $(property-set) ] ; 218 } 219 else 220 { 221 return [ property-set.empty ] ; 222 } 223 } 224 225 rule compute-usage-requirements ( subvariant ) 226 { 227 local usage-requirements = 228 <include>$(self.headers) 229 <dll-path>$(self.libraries) 230 <library-path>$(self.libraries) 231 ; 232 233 local rproperties = [ $(subvariant).build-properties ] ; 234 # CONSIDER: should this "if" sequence be replaced with 235 # some use of 'property-map' class? 236 if [ $(rproperties).get <runtime-debugging> ] = "on" 237 { 238 usage-requirements += 239 <define>_STLP_DEBUG=1 240 <define>_STLP_DEBUG_UNINITIALIZED=1 ; 241 } 242 if [ $(rproperties).get <runtime-link> ] = "shared" 243 { 244 usage-requirements += 245 <define>_STLP_USE_DYNAMIC_LIB=1 ; 246 } 247 if [ $(rproperties).get <stdlib-stlport:extensions> ] = noext 248 { 249 usage-requirements += 250 <define>_STLP_NO_EXTENSIONS=1 ; 251 } 252 if [ $(rproperties).get <stdlib-stlport:iostream> ] = hostios 253 { 254 usage-requirements += 255 <define>_STLP_NO_OWN_IOSTREAMS=1 256 <define>_STLP_HAS_NO_NEW_IOSTREAMS=1 ; 257 } 258 if $(self.version.5) 259 { 260 # Version 5.x 261 if [ $(rproperties).get <threading> ] = "single" 262 { 263 # Since STLport5 doesn't normally support single-thread 264 # we force STLport5 into the multi-thread mode. Hence 265 # getting what other libs provide of single-thread code 266 # linking against a multi-thread lib. 267 usage-requirements += 268 <define>_STLP_THREADS=1 ; 269 } 270 } 271 272 return [ property-set.create $(usage-requirements) ] ; 273 } 274} 275 276rule stlport-target ( headers ? : libraries * : version ? ) 277{ 278 local project = [ project.current ] ; 279 280 targets.main-target-alternative 281 [ new stlport-target-class $(project) : $(headers) : $(libraries) 282 : $(version) 283 ] ; 284} 285 286local .version-subfeature-defined ; 287 288# Initialize stlport support. 289rule init ( 290 version ? : 291 headers : # Location of header files 292 libraries * # Location of libraries, lib and bin subdirs of STLport. 293 ) 294{ 295 # FIXME: need to use common.check-init-parameters here. 296 # At the moment, that rule always tries to define subfeature 297 # of the 'toolset' feature, while we need to define subfeature 298 # of <stdlib>stlport, so tweaks to check-init-parameters are needed. 299 if $(version) 300 { 301 if ! $(.version-subfeature-defined) 302 { 303 feature.subfeature stdlib stlport : version : : propagated ; 304 .version-subfeature-defined = true ; 305 } 306 feature.extend-subfeature stdlib stlport : version : $(version) ; 307 } 308 309 # Declare the main target for this STLPort version. 310 stlport-target $(headers) : $(libraries) : $(version) ; 311} 312 313