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

Commit 13f12e63 authored by Dennis Shen's avatar Dennis Shen Committed by Automerger Merge Worker
Browse files

Merge "aconfig: update c/c++ codegen" into main am: 21380611 

Original change: https://android-review.googlesource.com/c/platform/build/+/2657839



Change-Id: Ic410d4f2371557646267026fbedeb48248e3a056
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 735385ff 21380611

tools/aconfig/src/codegen_cpp.rs

+122 −75
Original line number Diff line number Diff line
@@ -42,7 +42,7 @@ where 
        cpp_namespace,

        package: package.to_string(),

        readwrite,

        for_prod: codegen_mode == CodegenMode::Production,

        for_test: codegen_mode == CodegenMode::Test,

        class_elements,

    };
@@ -102,7 +102,7 @@ pub struct Context { 
    pub cpp_namespace: String,

    pub package: String,

    pub readwrite: bool,

    pub for_prod: bool,

    pub for_test: bool,

    pub class_elements: Vec<ClassElement>,

}
@@ -111,7 +111,6 @@ pub struct ClassElement { 
    pub readwrite: bool,

    pub default_value: String,

    pub flag_name: String,

    pub uppercase_flag_name: String,

    pub device_config_namespace: String,

    pub device_config_flag: String,

}
@@ -125,7 +124,6 @@ fn create_class_element(package: &str, pf: &ProtoParsedFlag) -> ClassElement { 
            "false".to_string()

        },

        flag_name: pf.name().to_string(),

        uppercase_flag_name: pf.name().to_string().to_ascii_uppercase(),

        device_config_namespace: pf.namespace().to_string(),

        device_config_flag: codegen::create_device_config_ident(package, pf.name())

            .expect("values checked at flag parse time"),
@@ -157,19 +155,10 @@ public: 
    virtual bool enabled_ro() = 0;



    virtual bool enabled_rw() = 0;



    virtual void override_flag(std::string const&, bool) {}



    virtual void reset_overrides() {}

};



extern std::unique_ptr<flag_provider_interface> provider_;



extern std::string const DISABLED_RO;

extern std::string const DISABLED_RW;

extern std::string const ENABLED_RO;

extern std::string const ENABLED_RW;



inline bool disabled_ro() {

    return false;

}
@@ -186,14 +175,6 @@ inline bool enabled_rw() { 
    return provider_->enabled_rw();

}



inline void override_flag(std::string const& name, bool val) {

    return provider_->override_flag(name, val);

}



inline void reset_overrides() {

    return provider_->reset_overrides();

}



}

#endif

"#;
@@ -213,46 +194,59 @@ public: 


    virtual bool disabled_ro() = 0;



    virtual void disabled_ro(bool val) = 0;



    virtual bool disabled_rw() = 0;



    virtual void disabled_rw(bool val) = 0;



    virtual bool enabled_ro() = 0;



    virtual void enabled_ro(bool val) = 0;



    virtual bool enabled_rw() = 0;



    virtual void override_flag(std::string const&, bool) {}

    virtual void enabled_rw(bool val) = 0;



    virtual void reset_overrides() {}

    virtual void reset_flags() {}

};



extern std::unique_ptr<flag_provider_interface> provider_;



extern std::string const DISABLED_RO;

extern std::string const DISABLED_RW;

extern std::string const ENABLED_RO;

extern std::string const ENABLED_RW;



inline bool disabled_ro() {

    return provider_->disabled_ro();

}



inline void disabled_ro(bool val) {

    provider_->disabled_ro(val);

}



inline bool disabled_rw() {

    return provider_->disabled_rw();

}



inline void disabled_rw(bool val) {

    provider_->disabled_rw(val);

}



inline bool enabled_ro() {

    return provider_->enabled_ro();

}



inline void enabled_ro(bool val) {

    provider_->enabled_ro(val);

}



inline bool enabled_rw() {

    return provider_->enabled_rw();

}



inline void override_flag(std::string const& name, bool val) {

    return provider_->override_flag(name, val);

inline void enabled_rw(bool val) {

    provider_->enabled_rw(val);

}



inline void reset_overrides() {

    return provider_->reset_overrides();

inline void reset_flags() {

    return provider_->reset_flags();

}



}
@@ -306,28 +300,20 @@ public: 
using namespace server_configurable_flags;



#include <unordered_map>

#include <unordered_set>

#include <cassert>



namespace com::android::aconfig::test {

class flag_provider : public flag_provider_interface {

private:

    std::unordered_map<std::string, bool> overrides_;

    std::unordered_set<std::string> flag_names_;



public:



    flag_provider()

        : overrides_(),

          flag_names_() {

        flag_names_.insert(DISABLED_RO);

        flag_names_.insert(DISABLED_RW);

        flag_names_.insert(ENABLED_RO);

        flag_names_.insert(ENABLED_RW);

    }

        : overrides_()

    {}



    virtual bool disabled_ro() override {

        auto it = overrides_.find(DISABLED_RO);

        auto it = overrides_.find("disabled_ro");

        if (it != overrides_.end()) {

            return it->second;

        } else {
@@ -335,8 +321,12 @@ public: 
        }

    }



    virtual void disabled_ro(bool val) override {

        overrides_["disabled_ro"] = val;

    }



    virtual bool disabled_rw() override {

        auto it = overrides_.find(DISABLED_RW);

        auto it = overrides_.find("disabled_rw");

        if (it != overrides_.end()) {

            return it->second;

        } else {
@@ -347,8 +337,12 @@ public: 
        }

    }



    virtual void disabled_rw(bool val) override {

        overrides_["disabled_rw"] = val;

    }



    virtual bool enabled_ro() override {

        auto it = overrides_.find(ENABLED_RO);

        auto it = overrides_.find("enabled_ro");

        if (it != overrides_.end()) {

            return it->second;

        } else {
@@ -356,8 +350,12 @@ public: 
        }

    }



    virtual void enabled_ro(bool val) override {

        overrides_["enabled_ro"] = val;

    }



    virtual bool enabled_rw() override {

        auto it = overrides_.find(ENABLED_RW);

        auto it = overrides_.find("enabled_rw");

        if (it != overrides_.end()) {

            return it->second;

        } else {
@@ -368,12 +366,11 @@ public: 
        }

    }



    virtual void override_flag(std::string const& flag, bool val) override {

        assert(flag_names_.count(flag));

        overrides_[flag] = val;

    virtual void enabled_rw(bool val) override {

        overrides_["enabled_rw"] = val;

    }



    virtual void reset_overrides() override {

    virtual void reset_flags() override {

        overrides_.clear();

    }

};
@@ -386,18 +383,12 @@ public: 
#include "com_android_aconfig_test_flag_provider.h"



namespace com::android::aconfig::test {



    std::string const DISABLED_RO = "com.android.aconfig.test.disabled_ro";

    std::string const DISABLED_RW = "com.android.aconfig.test.disabled_rw";

    std::string const ENABLED_RO = "com.android.aconfig.test.enabled_ro";

    std::string const ENABLED_RW = "com.android.aconfig.test.enabled_rw";



    std::unique_ptr<flag_provider_interface> provider_ =

        std::make_unique<flag_provider>();

}

"#;



    const C_EXPORTED_HEADER_EXPECTED: &str = r#"

    const C_EXPORTED_PROD_HEADER_EXPECTED: &str = r#"

#ifndef com_android_aconfig_test_c_HEADER_H

#define com_android_aconfig_test_c_HEADER_H
@@ -405,22 +396,45 @@ namespace com::android::aconfig::test { 
extern "C" {

#endif



extern const char* com_android_aconfig_test_DISABLED_RO;

extern const char* com_android_aconfig_test_DISABLED_RW;

extern const char* com_android_aconfig_test_ENABLED_RO;

extern const char* com_android_aconfig_test_ENABLED_RW;

bool com_android_aconfig_test_disabled_ro();



bool com_android_aconfig_test_disabled_rw();



bool com_android_aconfig_test_enabled_ro();



bool com_android_aconfig_test_enabled_rw();



#ifdef __cplusplus

}

#endif

#endif

"#;



    const C_EXPORTED_TEST_HEADER_EXPECTED: &str = r#"

#ifndef com_android_aconfig_test_c_HEADER_H

#define com_android_aconfig_test_c_HEADER_H



#ifdef __cplusplus

extern "C" {

#endif



bool com_android_aconfig_test_disabled_ro();



void set_com_android_aconfig_test_disabled_ro(bool val);



bool com_android_aconfig_test_disabled_rw();



void set_com_android_aconfig_test_disabled_rw(bool val);



bool com_android_aconfig_test_enabled_ro();



void set_com_android_aconfig_test_enabled_ro(bool val);



bool com_android_aconfig_test_enabled_rw();



void com_android_aconfig_test_override_flag(const char* name, bool val);

void set_com_android_aconfig_test_enabled_rw(bool val);



void com_android_aconfig_test_reset_overrides();

void com_android_aconfig_test_reset_flags();



#ifdef __cplusplus

}
@@ -428,38 +442,65 @@ void com_android_aconfig_test_reset_overrides(); 
#endif

"#;



    const C_SOURCE_FILE_EXPECTED: &str = r#"

    const C_PROD_SOURCE_FILE_EXPECTED: &str = r#"

#include "com_android_aconfig_test_c.h"

#include "com_android_aconfig_test.h"

#include <string>



const char* com_android_aconfig_test_DISABLED_RO = "com.android.aconfig.test.disabled_ro";

const char* com_android_aconfig_test_DISABLED_RW = "com.android.aconfig.test.disabled_rw";

const char* com_android_aconfig_test_ENABLED_RO = "com.android.aconfig.test.enabled_ro";

const char* com_android_aconfig_test_ENABLED_RW = "com.android.aconfig.test.enabled_rw";

bool com_android_aconfig_test_disabled_ro() {

    return com::android::aconfig::test::disabled_ro();

}



bool com_android_aconfig_test_disabled_rw() {

    return com::android::aconfig::test::disabled_rw();

}



bool com_android_aconfig_test_enabled_ro() {

    return com::android::aconfig::test::enabled_ro();

}



bool com_android_aconfig_test_enabled_rw() {

    return com::android::aconfig::test::enabled_rw();

}

"#;



    const C_TEST_SOURCE_FILE_EXPECTED: &str = r#"

#include "com_android_aconfig_test_c.h"

#include "com_android_aconfig_test.h"



bool com_android_aconfig_test_disabled_ro() {

    return com::android::aconfig::test::disabled_ro();

}



void set_com_android_aconfig_test_disabled_ro(bool val) {

    com::android::aconfig::test::disabled_ro(val);

}



bool com_android_aconfig_test_disabled_rw() {

    return com::android::aconfig::test::disabled_rw();

}



void set_com_android_aconfig_test_disabled_rw(bool val) {

    com::android::aconfig::test::disabled_rw(val);

}



bool com_android_aconfig_test_enabled_ro() {

    return com::android::aconfig::test::enabled_ro();

}



void set_com_android_aconfig_test_enabled_ro(bool val) {

    com::android::aconfig::test::enabled_ro(val);

}



bool com_android_aconfig_test_enabled_rw() {

    return com::android::aconfig::test::enabled_rw();

}



void com_android_aconfig_test_override_flag(const char* name, bool val) {

    com::android::aconfig::test::override_flag(std::string(name), val);

void set_com_android_aconfig_test_enabled_rw(bool val) {

    com::android::aconfig::test::enabled_rw(val);

}



void com_android_aconfig_test_reset_overrides() {

    com::android::aconfig::test::reset_overrides();

void com_android_aconfig_test_reset_flags() {

    com::android::aconfig::test::reset_flags();

}

"#;

    fn test_generate_cpp_code(mode: CodegenMode) {
@@ -516,7 +557,10 @@ void com_android_aconfig_test_reset_overrides() { 
        assert_eq!(

            None,

            crate::test::first_significant_code_diff(

                C_EXPORTED_HEADER_EXPECTED,

                match mode {

                    CodegenMode::Production => C_EXPORTED_PROD_HEADER_EXPECTED,

                    CodegenMode::Test => C_EXPORTED_TEST_HEADER_EXPECTED,

                },

                generated_files_map.get(&target_file_path).unwrap()

            )

        );
@@ -526,7 +570,10 @@ void com_android_aconfig_test_reset_overrides() { 
        assert_eq!(

            None,

            crate::test::first_significant_code_diff(

                C_SOURCE_FILE_EXPECTED,

                match mode {

                    CodegenMode::Production => C_PROD_SOURCE_FILE_EXPECTED,

                    CodegenMode::Test => C_TEST_SOURCE_FILE_EXPECTED,

                },

                generated_files_map.get(&target_file_path).unwrap()

            )

        );

tools/aconfig/templates/c_exported_header.template

+9 −8
Original line number Diff line number Diff line
@@ -6,15 +6,16 @@ extern "C" \{ 
#endif



{{ for item in class_elements }}

extern const char* {header}_{item.uppercase_flag_name};

{{ endfor -}}



{{ for item in class_elements}}

bool {header}_{item.flag_name}();{{ endfor }}

bool {header}_{item.flag_name}();



void {header}_override_flag(const char* name, bool val);

{{ if for_test }}

void set_{header}_{item.flag_name}(bool val);

{{ -endif }}

{{ endfor - }}



void {header}_reset_overrides();

{{ if for_test }}

void {header}_reset_flags();

{{ -endif }}



#ifdef __cplusplus

}

tools/aconfig/templates/c_source_file.template

+9 −10
Original line number Diff line number Diff line 
#include "{header}_c.h"

#include "{header}.h"

#include <string>



{{ for item in class_elements}}

const char* {header}_{item.uppercase_flag_name} = "{item.device_config_flag}";

{{ endfor - }}



{{ for item in class_elements}}

bool {header}_{item.flag_name}() \{

    return {cpp_namespace}::{item.flag_name}();

}

{{ endfor }}



void {header}_override_flag(const char* name, bool val) \{

     {cpp_namespace}::override_flag(std::string(name), val);

{{ if for_test }}

void set_{header}_{item.flag_name}(bool val) \{

    {cpp_namespace}::{item.flag_name}(val);

}

{{ -endif }}

{{ endfor -}}



void {header}_reset_overrides() \{

     {cpp_namespace}::reset_overrides();

{{ if for_test }}

void {header}_reset_flags() \{

     {cpp_namespace}::reset_flags();

}

{{ -endif }}

tools/aconfig/templates/cpp_exported_header.template

+21 −13
Original line number Diff line number Diff line
@@ -11,35 +11,43 @@ public: 
    virtual ~flag_provider_interface() = default;

    {{ for item in class_elements}}

    virtual bool {item.flag_name}() = 0;



    {{ if for_test }}

    virtual void {item.flag_name}(bool val) = 0;

    {{ -endif }}

    {{ endfor }}

    virtual void override_flag(std::string const&, bool) \{}



    virtual void reset_overrides() \{}

    {{ if for_test }}

    virtual void reset_flags() \{}

    {{ -endif }}

};



extern std::unique_ptr<flag_provider_interface> provider_;

{{ for item in class_elements}}

extern std::string const {item.uppercase_flag_name};{{ endfor }}



{{ for item in class_elements}}

inline bool {item.flag_name}() \{

    {{ if for_prod }}

    {{ if for_test }}

    return provider_->{item.flag_name}();

    {{ -else- }}

    {{ if not item.readwrite- }}

    return {item.default_value};

    {{ -else- }}

    return provider_->{item.flag_name}();

    {{ -endif }}

    {{ -else- }}

    return provider_->{item.flag_name}();

    {{ -endif }}

}

{{ endfor }}

inline void override_flag(std::string const& name, bool val) \{

    return provider_->override_flag(name, val);

}



inline void reset_overrides() \{

    return provider_->reset_overrides();

{{ if for_test }}

inline void {item.flag_name}(bool val) \{

    provider_->{item.flag_name}(val);

}

{{ -endif }}

{{ endfor }}



{{ if for_test }}

inline void reset_flags() \{

    return provider_->reset_flags();

}

{{ -endif }}

}

#endif

tools/aconfig/templates/cpp_source_file.template

+0 −2
Original line number Diff line number Diff line
@@ -3,8 +3,6 @@ 
#include "{header}_flag_provider.h"



namespace {cpp_namespace} \{

{{ for item in class_elements}}

std::string const {item.uppercase_flag_name} = "{item.device_config_flag}";{{ endfor }}

std::unique_ptr<flag_provider_interface> provider_ =

    std::make_unique<flag_provider>();

}