aboutsummaryrefslogtreecommitdiff
path: root/build2/cc
diff options
context:
space:
mode:
authorBoris Kolpackov <boris@codesynthesis.com>2019-07-04 07:30:23 +0200
committerBoris Kolpackov <boris@codesynthesis.com>2019-07-04 07:30:23 +0200
commitee0456ed4a5f3f6686fbb0a433161d1f9d8535fe (patch)
tree697834b68df162a004a6e13113260a11e0236af6 /build2/cc
parentf52b47eea4c5de553d202669f91e6f4f14668592 (diff)
Remove libu{} target group
The semantics provided by libu{} is rarely required and as result was not yet documented. However, if you are using it, the new way to achieve the same result is to use both libue{} and libul{} explicitly, for example: exe{foo}: libue{foo} lib{foo}: libul{foo} {libue libul}{foo}: cxx{*}
Diffstat (limited to 'build2/cc')
-rw-r--r--build2/cc/link-rule.cxx31
-rw-r--r--build2/cc/types.hxx1
-rw-r--r--build2/cc/utility.cxx22
-rw-r--r--build2/cc/utility.hxx2
4 files changed, 24 insertions, 32 deletions
diff --git a/build2/cc/link-rule.cxx b/build2/cc/link-rule.cxx
index 6dfcfa9..9caac51 100644
--- a/build2/cc/link-rule.cxx
+++ b/build2/cc/link-rule.cxx
@@ -108,9 +108,7 @@ namespace build2
r.seen_obj = r.seen_obj || true;
}
- else if (p.is_a<libu> () ||
- p.is_a<libul> () ||
- p.is_a<libux> ())
+ else if (p.is_a<libul> () || p.is_a<libux> ())
{
// For a unility library we look at its prerequisites, recursively.
// Since these checks are not exactly light-weight, only do them if
@@ -136,7 +134,7 @@ namespace build2
const target* pg (nullptr);
const target* pt (p.search_existing ());
- if (p.is_a<libx> ())
+ if (p.is_a<libul> ())
{
if (pt != nullptr)
{
@@ -145,7 +143,7 @@ namespace build2
// considering the group's prerequisites.
//
if (const target* pm =
- link_member (pt->as<libx> (),
+ link_member (pt->as<libul> (),
a,
linfo {ot, lorder::a /* unused */},
true /* existing */))
@@ -170,13 +168,11 @@ namespace build2
pt = search_existing (p.prerequisite.key (tt));
}
}
- else
+ else if (!p.is_a<libue> ())
{
// See if we also/instead have a group.
//
- // @@ Why are we picking libu{} over libul{} (and below)?
- //
- pg = search_existing (p.prerequisite.key (libu::static_type));
+ pg = search_existing (p.prerequisite.key (libul::static_type));
if (pt == nullptr)
swap (pt, pg);
@@ -187,7 +183,7 @@ namespace build2
// If we are matching a target, use the original output type
// since that would be the member that we pick.
//
- otype pot (pt->is_a<libx> () ? ot : link_type (*pt).type);
+ otype pot (pt->is_a<libul> () ? ot : link_type (*pt).type);
match_result pr (match (a, *pt, pg, pot, true /* lib */));
// Do we need to propagate any other seen_* values? Hm, that
@@ -229,21 +225,20 @@ namespace build2
ltype lt (link_type (t));
- // If this is a library, link-up to our group (this is the target group
- // protocol which means this can be done whether we match or not).
+ // If this is a group member library, link-up to our group (this is the
+ // target group protocol which means this can be done whether we match
+ // or not).
//
// If we are called for the outer operation (see install rules), then
// use resolve_group() to delegate to inner.
//
- if (lt.library ())
+ if (lt.member_library ())
{
if (a.outer ())
resolve_group (a, t);
else if (t.group == nullptr)
t.group = &search (t,
- // @@ Why are we picking libu{} over libul{} (and above)?
- //
- lt.utility ? libu::static_type : lib::static_type,
+ lt.utility ? libul::static_type : lib::static_type,
t.dir, t.out, t.name);
}
@@ -447,9 +442,7 @@ namespace build2
// If this is the libu*{} group, then pick the appropriate member.
//
- const libx* ul;
- if ((ul = pt->is_a<libul> ()) ||
- (ul = pt->is_a<libu> ()))
+ if (const libul* ul = pt->is_a<libul> ())
{
pf = &link_member (*ul, a, li)->as<file> ();
}
diff --git a/build2/cc/types.hxx b/build2/cc/types.hxx
index 481c3c6..c297b19 100644
--- a/build2/cc/types.hxx
+++ b/build2/cc/types.hxx
@@ -81,6 +81,7 @@ namespace build2
bool library () const {return type != otype::e || utility;}
bool static_library () const {return type == otype::a || utility;}
bool shared_library () const {return type == otype::s && !utility;}
+ bool member_library () const {return type != otype::e;}
};
// Compile target types.
diff --git a/build2/cc/utility.cxx b/build2/cc/utility.cxx
index 2179c14..3271f7c 100644
--- a/build2/cc/utility.cxx
+++ b/build2/cc/utility.cxx
@@ -46,17 +46,15 @@ namespace build2
const target*
link_member (const bin::libx& x, action a, linfo li, bool exist)
{
- bool ul;
-
- if ((ul = x.is_a<libul> ()) || x.is_a<libu> ())
+ if (x.is_a<libul> ())
{
- // If this is a libul{} and we are linking an executable, then the
- // member choice should be dictated by the members of lib{} this
- // libul{} is "primarily" for. If both are being built, then it seems
- // natural to prefer static over shared since it could be faster (but
- // I am sure someone will probably want this configurable).
+ // For libul{} that is linked to an executable the member choice
+ // should be dictated by the members of lib{} this libul{} is
+ // "primarily" for. If both are being built, then it seems natural to
+ // prefer static over shared since it could be faster (but I am sure
+ // someone will probably want this configurable).
//
- if (ul && li.type == otype::e)
+ if (li.type == otype::e)
{
// Utility libraries are project-local which means the primarily
// target should be in the same project as us.
@@ -66,9 +64,9 @@ namespace build2
: otype::s;
}
- const target_type& tt (li.type == otype::a ? libua::static_type :
- li.type == otype::s ? libus::static_type :
- libue::static_type);
+ const target_type& tt (li.type == otype::a
+ ? libua::static_type
+ : libus::static_type);
// Called by the compile rule during execute.
//
diff --git a/build2/cc/utility.hxx b/build2/cc/utility.hxx
index 80ca741..6222b5f 100644
--- a/build2/cc/utility.hxx
+++ b/build2/cc/utility.hxx
@@ -58,7 +58,7 @@ namespace build2
}
// Given the link order return the library member to link. That is, liba{}
- // or libs{} for lib{} and libue{}, libua{} or libus{} for libu*{}.
+ // or libs{} for lib{} and libua{} or libus{} for libul{}.
//
// If existing is true, then only return the member target if it exists
// (currently only used and supported for utility libraries).