Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c3dc0b57 authored by Adam Lesinski's avatar Adam Lesinski
Browse files

Build the split-select tool without C++11 support 

It was complicated to get the tool building on Windows, Linux,
and OSX with C++11 support.

OSX uses Clang to build C++11 binaries, which requires the libc++
standard library. Since most of the dependencies of this program
are built against libstdc++, this was difficult to resolve.

Now we build without C++11 support.

Change-Id: I4e537c113734508a8f480a1c402ed237de4f0e60
parent 425b1dc8

tools/aapt/AaptUtil.h

+37 −3
Original line number Diff line number Diff line
@@ -14,9 +14,11 @@ 
 * limitations under the License.

 */



#ifndef __AAPT_UTIL_H

#define __AAPT_UTIL_H

#ifndef H_AAPT_UTIL

#define H_AAPT_UTIL



#include <utils/KeyedVector.h>

#include <utils/SortedVector.h>

#include <utils/String8.h>

#include <utils/Vector.h>
@@ -25,6 +27,38 @@ namespace AaptUtil { 
android::Vector<android::String8> split(const android::String8& str, const char sep);

android::Vector<android::String8> splitAndLowerCase(const android::String8& str, const char sep);



template <typename KEY, typename VALUE>

void appendValue(android::KeyedVector<KEY, android::Vector<VALUE> >& keyedVector,

        const KEY& key, const VALUE& value);



template <typename KEY, typename VALUE>

void appendValue(android::KeyedVector<KEY, android::SortedVector<VALUE> >& keyedVector,

        const KEY& key, const VALUE& value);



//

// Implementations

//



template <typename KEY, typename VALUE>

void appendValue(android::KeyedVector<KEY, android::Vector<VALUE> >& keyedVector,

        const KEY& key, const VALUE& value) {

    ssize_t idx = keyedVector.indexOfKey(key);

    if (idx < 0) {

        idx = keyedVector.add(key, android::Vector<VALUE>());

    }

    keyedVector.editValueAt(idx).add(value);

}



template <typename KEY, typename VALUE>

void appendValue(android::KeyedVector<KEY, android::SortedVector<VALUE> >& keyedVector,

        const KEY& key, const VALUE& value) {

    ssize_t idx = keyedVector.indexOfKey(key);

    if (idx < 0) {

        idx = keyedVector.add(key, android::SortedVector<VALUE>());

    }

    keyedVector.editValueAt(idx).add(value);

}



} // namespace AaptUtil



#endif // __AAPT_UTIL_H
 
#endif // H_AAPT_UTIL

tools/split-select/Abi.cpp

+47 −31
Original line number Diff line number Diff line
@@ -16,42 +16,58 @@ 


#include "Abi.h"



using namespace android;



namespace split {

namespace abi {



static const std::vector<Variant> sNoneVariants = {};

static const std::vector<Variant> sArmVariants =

        {Variant::armeabi, Variant::armeabi_v7a, Variant::arm64_v8a};

static const std::vector<Variant> sIntelVariants = {Variant::x86, Variant::x86_64};

static const std::vector<Variant> sMipsVariants = {Variant::mips, Variant::mips64};

static Vector<Variant> buildVariants(Variant v1, Variant v2) {

    Vector<Variant> v;

    v.add(v1);

    v.add(v2);

    return v;

}



static Vector<Variant> buildVariants(Variant v1, Variant v2, Variant v3) {

    Vector<Variant> v;

    v.add(v1);

    v.add(v2);

    v.add(v3);

    return v;

}



static const Vector<Variant> sNoneVariants;

static const Vector<Variant> sArmVariants = buildVariants(Variant_armeabi, Variant_armeabi_v7a, Variant_arm64_v8a);

static const Vector<Variant> sIntelVariants = buildVariants(Variant_x86, Variant_x86_64);

static const Vector<Variant> sMipsVariants = buildVariants(Variant_mips, Variant_mips64);



Family getFamily(Variant variant) {

    switch (variant) {

        case Variant::none:

            return Family::none;

        case Variant::armeabi:

        case Variant::armeabi_v7a:

        case Variant::arm64_v8a:

            return Family::arm;

        case Variant::x86:

        case Variant::x86_64:

            return Family::intel;

        case Variant::mips:

        case Variant::mips64:

            return Family::mips;

        case Variant_none:

            return Family_none;

        case Variant_armeabi:

        case Variant_armeabi_v7a:

        case Variant_arm64_v8a:

            return Family_arm;

        case Variant_x86:

        case Variant_x86_64:

            return Family_intel;

        case Variant_mips:

        case Variant_mips64:

            return Family_mips;

    }

    return Family::none;

    return Family_none;

}



const std::vector<Variant>& getVariants(Family family) {

const Vector<Variant>& getVariants(Family family) {

    switch (family) {

        case Family::none:

        case Family_none:

            return sNoneVariants;

        case Family::arm:

        case Family_arm:

            return sArmVariants;

        case Family::intel:

        case Family_intel:

            return sIntelVariants;

        case Family::mips:

        case Family_mips:

            return sMipsVariants;

    }

    return sNoneVariants;
@@ -59,21 +75,21 @@ const std::vector<Variant>& getVariants(Family family) { 


const char* toString(Variant variant) {

    switch (variant) {

        case Variant::none:

        case Variant_none:

            return "";

        case Variant::armeabi:

        case Variant_armeabi:

            return "armeabi";

        case Variant::armeabi_v7a:

        case Variant_armeabi_v7a:

            return "armeabi-v7a";

        case Variant::arm64_v8a:

        case Variant_arm64_v8a:

            return "arm64-v8a";

        case Variant::x86:

        case Variant_x86:

            return "x86";

        case Variant::x86_64:

        case Variant_x86_64:

            return "x86_64";

        case Variant::mips:

        case Variant_mips:

            return "mips";

        case Variant::mips64:

        case Variant_mips64:

            return "mips64";

    }

    return "";

tools/split-select/Abi.h

+16 −16
Original line number Diff line number Diff line
@@ -17,31 +17,31 @@ 
#ifndef H_ANDROID_SPLIT_ABI

#define H_ANDROID_SPLIT_ABI



#include <vector>

#include <utils/Vector.h>



namespace split {

namespace abi {



enum class Variant {

    none = 0,

    armeabi,

    armeabi_v7a,

    arm64_v8a,

    x86,

    x86_64,

    mips,

    mips64,

enum Variant {

    Variant_none = 0,

    Variant_armeabi,

    Variant_armeabi_v7a,

    Variant_arm64_v8a,

    Variant_x86,

    Variant_x86_64,

    Variant_mips,

    Variant_mips64,

};



enum class Family {

    none,

    arm,

    intel,

    mips,

enum Family {

    Family_none,

    Family_arm,

    Family_intel,

    Family_mips,

};



Family getFamily(Variant variant);

const std::vector<Variant>& getVariants(Family family);

const android::Vector<Variant>& getVariants(Family family);

const char* toString(Variant variant);



} // namespace abi

tools/split-select/Android.mk

+1 −6
Original line number Diff line number Diff line
@@ -17,10 +17,6 @@ 
# This tool is prebuilt if we're doing an app-only build.

ifeq ($(TARGET_BUILD_APPS)$(filter true,$(TARGET_BUILD_PDK)),)



# TODO(adamlesinski): Enable OS X builds when I figure out how

# to build with clang and libc++

ifneq ($(HOST_OS),darwin)



# ==========================================================

# Setup some common variables for the different build

# targets here.
@@ -55,7 +51,7 @@ hostStaticLibs := \ 
    libexpat \

    libziparchive-host



cFlags := -std=c++11 -Wall -Werror

cFlags := -Wall -Werror



ifeq ($(HOST_OS),linux)

    hostLdLibs += -lrt -ldl -lpthread
@@ -115,5 +111,4 @@ LOCAL_CFLAGS += $(cFlags) 


include $(BUILD_HOST_EXECUTABLE)



endif # Not OS X

endif # No TARGET_BUILD_APPS or TARGET_BUILD_PDK

tools/split-select/Grouper.cpp

+10 −16
Original line number Diff line number Diff line
@@ -16,25 +16,17 @@ 


#include "Grouper.h"



#include "aapt/AaptUtil.h"

#include "SplitDescription.h"



#include <utils/KeyedVector.h>

#include <utils/Vector.h>



using namespace android;

using AaptUtil::appendValue;



namespace split {



template <typename Key, typename Value>

static void addToVector(KeyedVector<Key, SortedVector<Value> >& group,

        const Key& key, const Value& value) {

    ssize_t idx = group.indexOfKey(key);

    if (idx < 0) {

        idx = group.add(key, SortedVector<Value>());

    }

    group.editValueAt(idx).add(value);

}



Vector<SortedVector<SplitDescription> >

groupByMutualExclusivity(const Vector<SplitDescription>& splits) {

    Vector<SortedVector<SplitDescription> > groups;
@@ -43,20 +35,22 @@ groupByMutualExclusivity(const Vector<SplitDescription>& splits) { 
    KeyedVector<SplitDescription, SortedVector<SplitDescription> > densityGroups;

    KeyedVector<SplitDescription, SortedVector<SplitDescription> > abiGroups;

    KeyedVector<SplitDescription, SortedVector<SplitDescription> > localeGroups;

    for (const SplitDescription& split : splits) {

    const size_t splitCount = splits.size();

    for (size_t i = 0; i < splitCount; i++) {

        const SplitDescription& split = splits[i];

        if (split.config.density != 0) {

            SplitDescription key(split);

            key.config.density = 0;

            key.config.sdkVersion = 0; // Ignore density so we can support anydpi.

            addToVector(densityGroups, key, split);

        } else if (split.abi != abi::Variant::none) {

            appendValue(densityGroups, key, split);

        } else if (split.abi != abi::Variant_none) {

            SplitDescription key(split);

            key.abi = abi::Variant::none;

            addToVector(abiGroups, key, split);

            key.abi = abi::Variant_none;

            appendValue(abiGroups, key, split);

        } else if (split.config.locale != 0) {

            SplitDescription key(split);

            key.config.clearLocale();

            addToVector(localeGroups, key, split);

            appendValue(localeGroups, key, split);

        } else {

            groups.add();

            groups.editTop().add(split);