Jamroot

   1 # Copyright Vladimir Prus 2002-2006.
   2 # Copyright Dave Abrahams 2005-2006.
   3 # Copyright Rene Rivera 2005-2007.
   4 # Copyright Douglas Gregor 2005.
   5 #
   6 # Distributed under the Boost Software License, Version 1.0.
   7 #    (See accompanying file LICENSE_1_0.txt or copy at
   8 #          http://www.boost.org/LICENSE_1_0.txt)
   9
  10 # Usage:
  11 #
  12 #   bjam [options] [properties] [install|stage]
  13 #
  14 #   Builds and installs Boost.
  15 #
  16 # Targets and Related Options:
  17 #
  18 #   install                 Install headers and compiled library files to the
  19 #   =======                 configured locations (below).
  20 #
  21 #   --prefix=<PREFIX>       Install architecture independent files here.
  22 #                           Default; C:\Boost on Win32
  23 #                           Default; /usr/local on Unix. Linux, etc.
  24 #
  25 #   --exec-prefix=<EPREFIX> Install architecture dependent files here.
  26 #                           Default; <PREFIX>
  27 #
  28 #   --libdir=<DIR>          Install library files here.
  29 #                           Default; <EPREFIX>/lib
  30 #
  31 #   --includedir=<HDRDIR>   Install header files here.
  32 #                           Default; <PREFIX>/include
  33 #
  34 #   stage                   Build and install only compiled library files
  35 #   =====                   to the stage directory.
  36 #
  37 #   --stagedir=<STAGEDIR>   Install library files here
  38 #                           Default; ./stage
  39 #
  40 # Other Options:
  41 #
  42 #   --build-type=<type>     Build the specified pre-defined set of variations
  43 #                           of the libraries. Note, that which variants get
  44 #                           built depends on what each library supports.
  45 #
  46 #                               minimal (default) - Builds the single
  47 #                               "release" version of the libraries. This
  48 #                               release corresponds to specifying:
  49 #                               "release <threading>multi <link>shared
  50 #                               <link>static <runtime-link>shared" as the
  51 #                               Boost.Build variant to build.
  52 #
  53 #                               complete - Attempts to build all possible
  54 #                               variations.
  55 #
  56 #   --build-dir=DIR         Build in this location instead of building
  57 #                           within the distribution tree. Recommended!
  58 #
  59 #   --show-libraries        Displays the list of Boost libraries that require
  60 #                           build and installation steps, then exit.
  61 #
  62 #   --layout=<layout>       Determines whether to choose library names
  63 #                           and header locations such that multiple
  64 #                           versions of Boost or multiple compilers can
  65 #                           be used on the same system.
  66 #
  67 #                               versioned (default) - Names of boost
  68 #                               binaries include the Boost version
  69 #                               number and the name and version of the
  70 #                               compiler.  Boost headers are installed
  71 #                               in a subdirectory of <HDRDIR> whose
  72 #                               name contains the Boost version
  73 #                               number.
  74 #
  75 #                               system - Binaries names do not include
  76 #                               the Boost version number or the name
  77 #                               and version number of the compiler.
  78 #                               Boost headers are installed directly
  79 #                               into <HDRDIR>.  This option is
  80 #                               intended for system integrators who
  81 #                               are building distribution packages.
  82 #
  83 #   --buildid=ID            Adds the specified ID to the name of built
  84 #                           libraries.  The default is to not add anything.
  85 #
  86 #   --help                  This message.
  87 #
  88 #   --with-<library>        Build and install the specified <library>
  89 #                           If this option is used, only libraries
  90 #                           specified using this option will be built.
  91 #
  92 #   --without-<library>     Do not build, stage, or install the specified
  93 #                           <library>. By default, all libraries are built.
  94 #
  95 # Properties:
  96 #
  97 #   toolset=toolset         Indicates the toolset to build with.
  98 #
  99 #   variant=debug|release   Select the build variant
 100 #
 101 #   link=static|shared      Whether to build static or shared libraries
 102 #
 103 #   threading=single|multi  Whether to build single or multithreaded binaries
 104 #
 105 #   runtime-link=static|shared
 106 #                           Whether to link to static or shared C and C++ runtime.
 107 #
 108
 109 # TODO:
 110 #  - handle boost version
 111 #  - handle python options such as pydebug
 112
 113 import generate ;
 114 import modules ;
 115 import set ;
 116 import stage ;
 117 import package ;
 118 import path ;
 119 import common ;
 120 import os ;
 121 import regex ;
 122 import errors ;
 123 import "class" : new ;
 124 import common ;
 125 import sequence ;
 126 import symlink ;
 127
 128 path-constant BOOST_ROOT : . ;
 129 constant BOOST_VERSION : 1.39.0 ;
 130 constant BOOST_JAMROOT_MODULE : $(__name__) ;
 131
 132 local version-tag = [ MATCH "^([^.]+)[.]([^.]+)[.]([^.]+)" : $(BOOST_VERSION) ]
 133     ;
 134 if $(version-tag[3]) = 0
 135 {
 136     version-tag = $(version-tag[1-2]) ;
 137 }
 138
 139 constant BOOST_VERSION_TAG : $(version-tag:J="_") ;
 140
 141 # Option to choose how many variants to build. The default is "minimal".
 142 local build-type = [ MATCH "^--build-type=(.*)" : [ modules.peek : ARGV ] ] ;
 143 build-type ?= minimal ;
 144 if ! ( $(build-type) in minimal complete )
 145 {
 146     build-type = minimal ;
 147 }
 148
 149 # Specify the build variants keyed on the build-type.
 150 local default-build,minimal =
 151     release
 152     <threading>multi
 153     <link>shared <link>static
 154     <runtime-link>shared
 155     ;
 156 local default-build,complete =
 157     debug release
 158     <threading>single <threading>multi
 159     <link>shared <link>static
 160     <runtime-link>shared <runtime-link>static
 161     ;
 162
 163 # Set the default build.
 164 local default-build = $(default-build,$(build-type)) ;
 165
 166 # We only use the default build when building at the root to avoid having it
 167 # impact the default regression testing of "debug".
 168 # TODO: Consider having a "testing" build type instead of this check.
 169 if $(__file__:D) != ""
 170 {
 171     default-build = debug ;
 172 }
 173
 174
 175 rule handle-static-runtime ( properties * )
 176 {
 177     # This property combination is dangerous. Ideally, we would add a constraint
 178     # to default build, so that user can build this property combination only if
 179     # requested directly. But we do not have any 'constraint' system for
 180     # default-build, so we disable such builds in requirements.
 181
 182     # For CW, static runtime is needed so that std::locale works.
 183     if <link>shared in $(properties) && <runtime-link>static in $(properties) &&
 184         ! ( <toolset>cw in $(properties) )
 185     {
 186         return <build>no ;
 187     }
 188 }
 189
 190
 191 project boost
 192     : requirements <include>.
 193       # Disable auto-linking for all targets here, primarily because it caused
 194       # troubles with V2.
 195       <define>BOOST_ALL_NO_LIB=1
 196       # Used to encode variant in target name. See the 'tag' rule below.
 197       <tag>@$(__name__).tag
 198       <conditional>@handle-static-runtime
 199     : usage-requirements <include>.
 200     : build-dir bin.v2
 201     : default-build $(default-build)
 202     ;
 203
 204
 205 # Setup convenient aliases for all libraries.
 206
 207 all-libraries = [ MATCH .*libs/(.*)/build/.* : [ glob libs/*/build/Jamfile.v2 ]
 208     [ glob libs/*/build/Jamfile ] ]
 209     ;
 210
 211 all-libraries = [ sequence.unique $(all-libraries) ] ;
 212
 213
 214 local rule explicit-alias ( id : targets + )
 215 {
 216     alias $(id) : $(targets) ;
 217     explicit $(id) ;
 218 }
 219
 220
 221 # First, the complicated libraries: where the target name in Jamfile is
 222 # different from its directory name.
 223 explicit-alias prg_exec_monitor : libs/test/build//boost_prg_exec_monitor ;
 224 explicit-alias test_exec_monitor : libs/test/build//boost_test_exec_monitor ;
 225 explicit-alias unit_test_framework : libs/test/build//boost_unit_test_framework ;
 226 explicit-alias bgl-vis : libs/graps/build//bgl-vis ;
 227 explicit-alias serialization : libs/serialization/build//boost_serialization ;
 228 explicit-alias wserialization : libs/serialization/build//boost_wserialization ;
 229 for local l in $(all-libraries)
 230 {
 231     if ! $(l) in test graph serialization
 232     {
 233         explicit-alias $(l) : libs/$(l)/build//boost_$(l) ;
 234     }
 235 }
 236
 237 alias headers : : : : <include>. ;
 238
 239
 240 # Decides which libraries are to be installed by looking at --with-<library>
 241 # --without-<library> arguments. Returns the list of directories under "libs"
 242 # which must be built and installed.
 243 #
 244 rule libraries-to-install ( existing-libraries * )
 245 {
 246    local argv = [ modules.peek : ARGV ] ;
 247    local with-parameter = [ MATCH --with-(.*) : $(argv) ] ;
 248    local without-parameter = [ MATCH --without-(.*) : $(argv) ] ;
 249
 250    # Do some checks.
 251    if $(with-parameter) && $(without-parameter)
 252    {
 253        ECHO "error: both --with-<library> and --without-<library> specified" ;
 254        EXIT ;
 255    }
 256
 257    local wrong = [ set.difference $(with-parameter) : $(existing-libraries) ] ;
 258    if $(wrong)
 259    {
 260        ECHO "error: wrong library name '$(wrong[1])' in the --with-<library> option." ;
 261        EXIT ;
 262    }
 263    local wrong = [ set.difference $(without-parameter) : $(existing-libraries) ] ;
 264    if $(wrong)
 265    {
 266        ECHO "error: wrong library name '$(wrong[1])' in the --without-<library> option." ;
 267        EXIT ;
 268    }
 269
 270    if $(with-parameter)
 271    {
 272        return [ set.intersection $(existing-libraries) : $(with-parameter) ] ;
 273    }
 274    else
 275    {
 276        return [ set.difference $(existing-libraries) : $(without-parameter) ] ;
 277    }
 278 }
 279
 280
 281 # What kind of layout are we doing?
 282 layout = [ MATCH "^--layout=(.*)" : [ modules.peek : ARGV ] ] ;
 283 layout ?= versioned ;
 284 layout-$(layout) = true ;
 285
 286
 287 # Possible stage only location.
 288 local stage-locate = [ MATCH "^--stagedir=(.*)" : [ modules.peek : ARGV ] ] ;
 289 stage-locate ?= stage ;
 290 path-constant BOOST_STAGE_LOCATE : $(stage-locate) ;
 291
 292
 293 # Python location.
 294 local python-root = [ MATCH "^--with-python-root=(.*)" : [ modules.peek : ARGV ]
 295     ] ;
 296 PYTHON_ROOT ?= $(python-root) ;
 297
 298
 299 # Select the libraries to install.
 300 libraries = [ libraries-to-install $(all-libraries) ] ;
 301
 302 if --show-libraries in [ modules.peek : ARGV ]
 303 {
 304     ECHO "The following libraries require building:" ;
 305     for local l in $(libraries)
 306     {
 307         ECHO "    - $(l)" ;
 308     }
 309     EXIT ;
 310 }
 311
 312 # Custom build ID.
 313 local build-id = [ MATCH "^--buildid=(.*)" : [ modules.peek : ARGV ] ] ;
 314 if $(build-id)
 315 {
 316     constant BUILD_ID : [ regex.replace $(build-id) "[*\\/:.\"\' ]" "_" ] ;
 317 }
 318
 319
 320 # This rule is called by Boost.Build to determine the name of target. We use it
 321 # to encode the build variant, compiler name and boost version in the target
 322 # name.
 323 #
 324 rule tag ( name : type ? : property-set )
 325 {
 326     if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
 327     {
 328         if $(layout) = versioned
 329         {
 330             local result = [ common.format-name
 331                 <base> <toolset> <threading> <runtime> -$(BOOST_VERSION_TAG)
 332                 -$(BUILD_ID)
 333                 : $(name) : $(type) : $(property-set) ] ;
 334
 335             # Optionally add version suffix. On NT, library with version suffix
 336             # will not be recognized by linkers. On CYGWIN, we get strage
 337             # duplicate symbol errors when library is generated with version
 338             # suffix. On OSX, version suffix is not needed -- the linker expects
 339             # the libFoo.1.2.3.dylib format. AIX linkers do not accept version
 340             # suffixes either. Pgi compilers can not accept library with version
 341             # suffix.
 342             if $(type) = SHARED_LIB &&
 343               ( ! ( [ $(property-set).get <target-os> ] in windows cygwin darwin aix ) &&
 344                 ! ( [ $(property-set).get <toolset> ] in pgi ) )
 345             {
 346                 result = $(result).$(BOOST_VERSION)  ;
 347             }
 348
 349             return $(result) ;
 350         }
 351         else
 352         {
 353             local result = [ common.format-name
 354                 <base>
 355                 -$(BUILD_ID)
 356                 : $(name) : $(type) : $(property-set) ] ;
 357
 358             # Optionally add version suffix. On NT, library with version suffix
 359             # will not be recognized by linkers. On CYGWIN, we get strage
 360             # duplicate symbol errors when library is generated with version
 361             # suffix. On OSX, version suffix is not needed -- the linker expects
 362             # the libFoo.1.2.3.dylib format. AIX linkers do not accept version
 363             # suffixes either. Pgi compilers can not accept library with version
 364             # suffix.
 365             if $(type) = SHARED_LIB &&
 366               ( ! ( [ $(property-set).get <target-os> ] in windows cygwin darwin aix ) &&
 367                 ! ( [ $(property-set).get <toolset> ] in pgi ) )
 368             {
 369                 result = $(result).$(BOOST_VERSION)  ;
 370             }
 371
 372             return $(result) ;
 373         }
 374     }
 375 }
 376
 377
 378 # Install to system location.
 379
 380 install-requirements = <install-source-root>$(BOOST_ROOT)/boost ;
 381
 382 if $(layout-versioned)
 383 {
 384     install-requirements += <install-header-subdir>boost-$(BOOST_VERSION_TAG)/boost ;
 385 }
 386 else
 387 {
 388     install-requirements += <install-header-subdir>boost ;
 389 }
 390 if [ modules.peek : NT ]
 391 {
 392     install-requirements += <install-default-prefix>C:/Boost ;
 393 }
 394 else if [ modules.peek : UNIX ]
 395 {
 396     install-requirements += <install-default-prefix>/usr/local ;
 397 }
 398
 399 local headers =
 400     # The .SUNWCCh files are present in tr1 include directory and have to be installed,
 401     # see http://lists.boost.org/Archives/boost/2007/05/121430.php
 402     [ path.glob-tree $(BOOST_ROOT)/boost : *.hpp *.ipp *.h *.inc *.SUNWCCh : CVS .svn ]
 403     [ path.glob-tree $(BOOST_ROOT)/boost/compatibility/cpp_c_headers : c* : CVS .svn ]
 404     [ path.glob boost/tr1/tr1 : * : bcc32 sun CVS .svn ]
 405           ;
 406
 407 # Complete install.
 408 package.install install-proper
 409     : $(install-requirements) <install-no-version-symlinks>on
 410     :
 411     : libs/$(libraries)/build
 412     : $(headers)
 413     ;
 414 explicit install-proper ;
 415
 416 # Install just library.
 417 install stage-proper
 418     : libs/$(libraries)/build
 419     : <location>$(stage-locate)/lib
 420       <install-dependencies>on <install-type>LIB
 421       <install-no-version-symlinks>on
 422     ;
 423 explicit stage-proper ;
 424
 425
 426 if $(layout-versioned) && ( [ modules.peek : NT ] || [ modules.peek : UNIX ] )
 427 {
 428     rule make-unversioned-links ( project name ? : property-set : sources * )
 429     {
 430         local result ;
 431         local filtered ;
 432         local pattern ;
 433         local nt = [ modules.peek : NT ] ;
 434
 435         # Collect the libraries that have the version number in 'filtered'.
 436         for local s in $(sources)
 437         {
 438             local m ;
 439             if $(nt)
 440             {
 441                 m = [ MATCH "(.*[.]lib)" : [ $(s).name ] ] ;
 442             }
 443             else
 444             {
 445                 m = [ MATCH "(.*[.]so[.0-9]+)" "(.*[.]dylib)" "(.*[.]a)" :
 446                     [ $(s).name ] ] ;
 447             }
 448             if $(m)
 449             {
 450                 filtered += $(s) ;
 451             }
 452         }
 453
 454         # Create links without version.
 455         for local s in $(filtered)
 456         {
 457             local name = [ $(s).name ] ;
 458             local ea = [ $(s).action ] ;
 459             local ep = [ $(ea).properties ] ;
 460             local a  = [ new non-scanning-action $(s) : symlink.ln : $(ep) ] ;
 461
 462             local noversion-file ;
 463             if $(nt)
 464             {
 465                 noversion-file = [ MATCH "(.*)-[0-9_]+(.*[.]lib)" : $(name) ] ;
 466             }
 467             else
 468             {
 469                 noversion-file =
 470                   [ MATCH "(.*)-[0-9_]+(.*[.]so)[.0-9]*" : $(name) ]
 471                   [ MATCH "(.*)-[0-9_]+(.*[.]dylib)" : $(name) ]
 472                   [ MATCH "(.*)-[0-9_]+(.*[.]a)" : $(name) ]
 473                   [ MATCH "(.*)-[0-9_]+(.*[.]dll[.]a)" : $(name) ] ;
 474             }
 475
 476             local new-name =
 477                $(noversion-file[1])$(noversion-file[2]) ;
 478             result += [ new file-target $(new-name) exact : [ $(s).type ] : $(project)
 479                     : $(a) ] ;
 480
 481         }
 482         return $(result) ;
 483     }
 484
 485     generate stage-unversioned : stage-proper :
 486         <generating-rule>@make-unversioned-links ;
 487     explicit stage-unversioned ;
 488
 489     generate install-unversioned : install-proper :
 490         <generating-rule>@make-unversioned-links ;
 491     explicit install-unversioned ;
 492 }
 493 else
 494 {
 495     # Create do-nothing aliases.
 496     alias stage-unversioned ;
 497     explicit stage-unversioned ;
 498     alias install-unversioned ;
 499     explicit install-unversioned ;
 500 }
 501
 502 alias install : install-proper install-unversioned ;
 503 alias stage : stage-proper stage-unversioned ;
 504 explicit install ;
 505 explicit stage ;
 506
 507
 508 # Just build the libraries, don't install them anywhere. This is what happens
 509 # with just "bjam --v2".
 510 alias build_all : libs/$(libraries)/build ;
 511
 512
 513 # This rule should be called from libraries' Jamfiles and will create two
 514 # targets, "install" and "stage", that will install or stage that library. The
 515 # --prefix option is respected, but --with and --without options, naturally, are
 516 # ignored.
 517 #
 518 # - libraries -- list of library targets to install.
 519 #
 520 rule boost-install ( libraries * )
 521 {
 522     package.install install
 523         : <dependency>/boost//install-proper-headers $(install-requirements)
 524         : # No binaries
 525         : $(libraries)
 526         : # No headers, it is handled by the dependency.
 527     ;
 528
 529     install stage : $(libraries) : <location>$(BOOST_STAGE_LOCATE) ;
 530
 531     local c = [ project.current ] ;
 532     local project-module = [ $(c).project-module ] ;
 533     module $(project-module)
 534     {
 535         explicit stage ;
 536         explicit install ;
 537     }
 538 }
 539
 540
 541 # Make project ids of all libraries known.
 542 for local l in $(all-libraries)
 543 {
 544     use-project /boost/$(l) : libs/$(l)/build ;
 545 }