![]() |
Libraries are created using the lib
rule, which
follows the common
syntax. For example:
lib helpers : helpers.cpp : <include>boost : : <include>. ;
In the most common case, the lib
creates a library
from the specified sources. Depending on the value of
<link> feature the library will be either static or
shared. There are two other cases. First is when the library is
installed somewhere in compiler's search paths, and should be
searched by the compiler (typically, using the -l
option). The second case is where the library is available as a
prebuilt file and the full path is known.
The syntax for these case is given below:
lib z : : <name>z <search>/home/ghost ; lib compress : : <file>/opt/libs/compress.a ;
The name
property specifies the name that should be
passed to the -l
option, and the file
property specifies the file location. The search
feature
specifies paths in which to search for the library. That feature can
be specified several times, or it can be omitted, in which case only
default compiler paths will be searched.
The difference between using the file
feature as
opposed to the name
feature together with the
search
feature is that file
is more
precise. A specific file will be used. On the other hand, the
search
feature only adds a library path, and the
name
feature gives the basic name of the library. The
search rules are specific to the linker. For example, given these
definition:
lib a : : <variant>release <file>/pool/release/a.so ; lib a : : <variant>debug <file>/pool/debug/a.so ; lib b : : <variant>release <file>/pool/release/b.so ; lib b : : <variant>debug <file>/pool/debug/b.so ;
It's possible to use release version of a
and debug
version of b
. Had we used the name
and
search
features, the linker would always pick either
release or debug versions.
For convenience, the following syntax is allowed:
lib z ; lib gui db aux ;
and is does exactly the same as:
lib z : : <name>z ; lib gui : : <name>gui ; lib db : : <name>db ; lib aux : : <name>aux ;
When a library uses another library you should put that other library in the list of sources. This will do the right thing in all cases. For portability, you should specify library dependencies even for searched and prebuilt libraries, othewise, static linking on Unix won't work. For example:
lib z ; lib png : z : <name>png ;
![]() |
Note |
---|---|
When a library (say, |
One feature of Boost.Build that is very important for libraries is usage requirements. For example, if you write:
lib helpers : helpers.cpp : : : <include>. ;
then the compiler include path for all targets that use
helpers
will contain the directory
where the target is defined.path to "helpers.cpp". The user
only needs to add helpers
to the list of sources,
and needn't consider the requirements its use imposes on a
dependent target. This feature greatly simplifies Jamfiles.
![]() |
Note |
---|---|
If you don't want shared libraries to include all libraries that are specified in sources (especially statically linked ones), you'd need to use the following: lib b : a.cpp ; lib a : a.cpp : <use>b : : <library>b ;
This specifies that |