fdt: moved header structs to fdt namespace.

Signed-off-by: Bartłomiej Burdukiewicz <bartlomiej.burdukiewicz@gmail.com>
dev-0x7C6 · Aug 3, 2022 · 6aaa362 · 6aaa362
1 parent ab3b234
commit 6aaa362
Show file tree

Hide file tree

Showing 3 changed files with 34 additions and 33 deletions.
diff --git a/src/fdt/fdt-header.hpp b/src/fdt/fdt-header.hpp
@@ -5,27 +5,29 @@
 constexpr auto FDT_MAGIC_VALUE = 0xD00DFEED;
 constexpr auto FDT_SUPPORT_ABOVE = 16;
 
-enum class FDT_TOKEN : u32 {
-    BEGIN_NODE = 0x00000001,
-    END_NODE = 0x00000002,
-    PROPERTY = 0x00000003,
-    NOP = 0x00000004,
-    END = 0x00000009,
+namespace fdt {
+
+enum class token : u32 {
+    begin_node = 0x01,
+    end_node = 0x02,
+    property = 0x03,
+    nop = 0x04,
+    end = 0x09,
 };
 
-constexpr auto name(const FDT_TOKEN token) -> const char * {
-    switch (token) {
-        case FDT_TOKEN::BEGIN_NODE: return "begin_node";
-        case FDT_TOKEN::END_NODE: return "end_node";
-        case FDT_TOKEN::PROPERTY: return "property";
-        case FDT_TOKEN::NOP: return "nop";
-        case FDT_TOKEN::END: return "end";
+constexpr auto name(const token value) noexcept -> const char * {
+    switch (value) {
+        case token::begin_node: return "begin_node";
+        case token::end_node: return "end_node";
+        case token::property: return "property";
+        case token::nop: return "nop";
+        case token::end: return "end";
     }
 
     return nullptr;
 }
 
-struct fdt_header {
+struct header {
     u32 magic;
     u32 totalsize;
     u32 off_dt_struct;
@@ -38,10 +40,11 @@ struct fdt_header {
     u32 size_dt_struct;
 };
 
-struct fdt_property_header {
+struct property {
     u32 len;
     u32 nameoff;
 };
 
-static_assert(sizeof(fdt_header) == 40);
-static_assert(sizeof(fdt_property_header) == 8);
+static_assert(sizeof(header) == 40);
+static_assert(sizeof(property) == 8);
+}; // namespace fdt
diff --git a/src/fdt/fdt-parser.cpp b/src/fdt/fdt-parser.cpp
@@ -8,8 +8,8 @@ fdt_parser::fdt_parser(const char *data, u64 size, iface_fdt_generator &generato
         , m_size(size)
         , m_default_root_node(default_root_node)
         , m_handle_special_properties(handle_special_properties) {
-    if (size >= sizeof(fdt_header)) {
-        auto header = read_data_32be<fdt_header>(data);
+    if (size >= sizeof(fdt::header)) {
+        auto header = read_data_32be<fdt::header>(data);
         if (FDT_MAGIC_VALUE != header.magic || size != header.totalsize)
             return;
 
@@ -21,7 +21,7 @@ fdt_parser::fdt_parser(const char *data, u64 size, iface_fdt_generator &generato
     }
 }
 
-void fdt_parser::parse(const fdt_header header, iface_fdt_generator &generator) {
+void fdt_parser::parse(const fdt::header header, iface_fdt_generator &generator) {
     const auto dt_struct = m_data + header.off_dt_struct;
     const auto dt_strings = m_data + header.off_dt_strings;
 
@@ -32,29 +32,28 @@ void fdt_parser::parse(const fdt_header header, iface_fdt_generator &generator)
 
     for (auto iter = dt_struct; iter < dt_struct + header.size_dt_struct;) {
         auto seek_and_align = [&iter](const std::size_t size) {
-            const auto value = size % sizeof(FDT_TOKEN);
+            const auto value = size % sizeof(fdt::token);
             if (value)
-                return iter += size + sizeof(FDT_TOKEN) - value;
+                return iter += size + sizeof(fdt::token) - value;
 
             return iter += size;
         };
 
-        const auto token = static_cast<FDT_TOKEN>(u32_be(iter));
+        const auto token = static_cast<fdt::token>(u32_be(iter));
         seek_and_align(sizeof(token));
 
-        if (FDT_TOKEN::BEGIN_NODE == token) {
+        if (fdt::token::begin_node == token) {
             const auto size = std::strlen(iter);
             auto name = QString::fromUtf8(iter, size);
             seek_and_align(size);
             generator.begin_node(size ? name : m_default_root_node);
         }
 
-        if (FDT_TOKEN::END_NODE == token) {
+        if (fdt::token::end_node == token)
             generator.end_node();
-        }
 
-        if (FDT_TOKEN::PROPERTY == token) {
-            const auto header = read_data_32be<fdt_property_header>(iter);
+        if (fdt::token::property == token) {
+            const auto header = read_data_32be<fdt::property>(iter);
             seek_and_align(sizeof(header));
 
             fdt_property property;
@@ -65,12 +64,11 @@ void fdt_parser::parse(const fdt_header header, iface_fdt_generator &generator)
             generator.insert_property(property);
 
             for (auto &&handle : m_handle_special_properties)
-                if (handle.name == property.name) {
+                if (handle.name == property.name)
                     handle.callback(property, generator);
-                }
         }
 
-        if (FDT_TOKEN::END == token)
+        if (fdt::token::end == token)
             break;
     }
 }
diff --git a/src/fdt/fdt-parser.hpp b/src/fdt/fdt-parser.hpp
@@ -25,10 +25,10 @@ class fdt_parser {
     constexpr bool is_valid() noexcept { return m_header.has_value(); }
 
 private:
-    void parse(const fdt_header header, iface_fdt_generator &generator);
+    void parse(const fdt::header header, iface_fdt_generator &generator);
 
 private:
-    std::optional<fdt_header> m_header;
+    std::optional<fdt::header> m_header;
     const QString m_default_root_node;
     const std::vector<fdt_handle_special_property> &m_handle_special_properties;