Add support for specifying compile options on exe/lib{} targets

It is now possible to specify compile option (*.poptions and *.coptions) on
the exe/lib{} targets (we call them "binary-specific compile options"). Such
options are propagated to obj/bmi{} targets that are synthesized for source
prerequisites of the binary. Note that this propagation does not apply to
obj/bmi{} prerequisites. For example:

exe{foo}: cxx{foo} obj{common}
{
  cxx.poptions += -DFOO
}

exe{bar}: cxx{bar} obj{common}
{
  cxx.poptions += -DBAR
}

obj{common}: cxx{common}
{
  cxx.poptions += -DCOMMON
}

In this example, cxx{foo} will be compiled with -DFOO, cxx{bar} -- with
-DBAR, and cxx{common} -- with -DCOMMON.

Note that if a source prerequisite is shared between several binaries, then
the values of the propagated compile options (or their absence) must match.
For instance, the following variant of the above example would result in an
error since cxx{common} would have contradictory cxx.poptions values:

exe{foo}: cxx{foo common}
{
  cxx.poptions += -DFOO
}

exe{bar}: cxx{bar common}
{
  cxx.poptions += -DBAR
}

As another example, here is how we can rewrite a typical library buildfile
(which requires different macros to distinguish between shared/static builds)
using this mechanism, in this case, to build two libraries in the same scope:

./: lib{foo}: {hxx cxx}{*-foo}
./: lib{bar}: {hxx cxx}{*-bar}

cxx.poptions =+ "-I$out_root" "-I$src_root"

lib{foo}:
{
  cxx.poptions += -DFOO
  cxx.export.poptions = "-I$out_root" "-I$src_root"
}

liba{foo}:
{
  cxx.poptions += -DLIBFOO_STATIC_BUILD
  cxx.export.poptions += -DLIBFOO_STATIC
}

libs{foo}:
{
  cxx.poptions += -DLIBFOO_SHARED_BUILD
  cxx.export.poptions += -DLIBFOO_SHARED
}

lib{bar}:
{
  cxx.poptions += -DBAR
  cxx.export.poptions = "-I$out_root" "-I$src_root"
}

liba{bar}:
{
  cxx.poptions += -DLIBBAR_STATIC_BUILD
  cxx.export.poptions += -DLIBBAR_STATIC
}

libs{bar}:
{
  cxx.poptions += -DLIBBAR_SHARED_BUILD
  cxx.export.poptions += -DLIBBAR_SHARED
}

The exact semantics of this mechanism is as-if the binary-specific compile
options were set on the synthesized obj/bmi{} targets at the end of the
buildfile.

One nuance to keep in mind is that target type/pattern-specific
assign/append/prepend specified for obj/bmi{} will not be in effect for
options specified on lib/exe{}. For example:

cxx.poptions += -DSCOPE
obj{*}: cxx.poptions += -DTARGET
exe{foo}: cxx.poptions += -DFOO

Here the effective cxx.poptions for exe{foo} prerequisites will be
-DSCOPE -DFOO since exe{foo} does not match the obj{*} pattern. As result,
if using this mechanism, remember to include the binary target types in
obj{} patterns. For example:

{obj exe}{*}: cxx.poptions += -DTARGET

0 files changed, 0 insertions, 0 deletions