From ee0456ed4a5f3f6686fbb0a433161d1f9d8535fe Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Thu, 4 Jul 2019 07:30:23 +0200 Subject: 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{*} --- build2/cc/link-rule.cxx | 31 ++++++++++++------------------- build2/cc/types.hxx | 1 + build2/cc/utility.cxx | 22 ++++++++++------------ build2/cc/utility.hxx | 2 +- 4 files changed, 24 insertions(+), 32 deletions(-) (limited to 'build2/cc') 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 () || - p.is_a () || - p.is_a ()) + else if (p.is_a () || p.is_a ()) { // 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 ()) + if (p.is_a ()) { if (pt != nullptr) { @@ -145,7 +143,7 @@ namespace build2 // considering the group's prerequisites. // if (const target* pm = - link_member (pt->as (), + link_member (pt->as (), 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 ()) { // 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 () ? ot : link_type (*pt).type); + otype pot (pt->is_a () ? 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 ()) || - (ul = pt->is_a ())) + if (const libul* ul = pt->is_a ()) { pf = &link_member (*ul, a, li)->as (); } 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 ()) || x.is_a ()) + if (x.is_a ()) { - // 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). -- cgit v1.1