Cleanups

.gitignore

@@ -1,5 +1,6 @@
 *.a
 *.o
+*.la
 *.lo
 *.so
 .deps/

adb_parser/adb_db.cpp

@@ -38,7 +38,7 @@
 #include <vector>
 #include <stdio.h>
 #include <string>
-#include "common/algorithm.h"
+#include "common/tools_algorithm.h"
 #include "adb_db.h"
 
 #define CHECK_FIELD(field, node_w)                                                  \

adb_parser/adb_exceptionHolder.cpp

@@ -107,3 +107,28 @@ void ExceptionHolder::insertNewException(const string exceptionType, string exce
     ExceptionHolder::adbExceptionMap[exceptionType].push_back(exceptionTxt);
     ExceptionHolder::exceptionCounter += 1;
 }
+
+/**
+ * Function: Adb::printAdbExceptionMap
+ * This function will pring the content of the Adb Exception Map
+ **/
+string ExceptionHolder::printAdbExceptionMap()
+{
+    string errorStr = "";
+    vector<string> fatals = ExceptionHolder::adbExceptionMap[ExceptionHolder::FATAL_EXCEPTION];
+    for (vector<string>::iterator it = fatals.begin(); it != fatals.end(); ++it)
+    {
+        errorStr += "-" + ExceptionHolder::FATAL_EXCEPTION + "- " + *it + ";";
+    }
+    vector<string> errors = ExceptionHolder::adbExceptionMap[ExceptionHolder::ERROR_EXCEPTION];
+    for (vector<string>::iterator it = errors.begin(); it != errors.end(); ++it)
+    {
+        errorStr += "-" + ExceptionHolder::ERROR_EXCEPTION + "- " + *it + ";";
+    }
+    vector<string> warnings = ExceptionHolder::adbExceptionMap[ExceptionHolder::WARN_EXCEPTION];
+    for (vector<string>::iterator it = warnings.begin(); it != warnings.end(); ++it)
+    {
+        errorStr += "-" + ExceptionHolder::WARN_EXCEPTION + "- " + "- " + *it + ";";
+    }
+    return errorStr;
+}

adb_parser/adb_exceptionHolder.h

@@ -54,6 +54,7 @@ class ExceptionHolder
     static void insertNewException(const string exceptionType, string exceptionTxt);
     static ExceptionsMap getAdbExceptionsMap();
     static int getNumberOfExceptions();
+    static string printAdbExceptionMap();
 
 public:
     // VARIABLES

adb_parser/adb_instance.cpp

@@ -46,7 +46,7 @@
 
 #include <list>
 
-#include "common/algorithm.h"
+#include "common/tools_algorithm.h"
 #include "common/tools_regex.h"
 
 // Constants
@@ -78,7 +78,10 @@ AdbInstance::AdbInstance(AdbField* i_fieldDesc,
                          map<string, string> vars,
                          bool bigEndianArr,
                          bool isExprEval,
-                         unsigned char adabe_version) :
+                         unsigned char adabe_version,
+                         bool optimize_time,
+                         bool stop_on_partition,
+                         PartitionTree* next_partition_tree) :
     fieldDesc(i_fieldDesc),
     nodeDesc(i_nodeDesc),
     parent(i_parent),
@@ -89,6 +92,11 @@ AdbInstance::AdbInstance(AdbField* i_fieldDesc,
     // Re-initializations due to packing efficiency
     string array_name_suffix{fieldDesc->isArray() ? "[" + to_string(arrIdx + fieldDesc->lowBound) + "]" : ""};
     layout_item_name = i_fieldDesc->name + array_name_suffix;
+    if (optimize_time)
+    {
+        full_path = parent ? parent->full_path + "." + layout_item_name : layout_item_name;
+    }
+
 
     // TODO: the whole block below looks unnecesarry
     if (fieldDesc->offset == 0xffffffff)
@@ -103,12 +111,20 @@ AdbInstance::AdbInstance(AdbField* i_fieldDesc,
         }
     }
 
-    init_props(adabe_version);
+    if (stop_on_partition)
+    {
+        partition_tree = next_partition_tree;
+    }
 
     if (isExprEval)
     {
-        initInstOps(false);
-        eval_expressions(vars);
+        if (!stop_on_partition)
+        {
+            init_props(adabe_version);
+
+            initInstOps();
+            eval_expressions(vars);
+        }
     }
 }
 
@@ -117,16 +133,17 @@ void AdbInstance::initInstOps(bool is_root)
     AttrsMap& attrs_map = is_root ? nodeDesc->attrs : fieldDesc->attrs;
     inst_ops_props = new InstOpsProperties(attrs_map);
 
-    auto found_it = getInstanceAttrIterator("condition");
-    if (found_it != inst_ops_props->instAttrsMap.end() && parent->getInstanceAttr("is_conditional") == "1")
+    string value;
+    auto found = getInstanceAttr("condition", value);
+    if (found && parent->getInstanceAttr("is_conditional") == "1")
     {
-        inst_ops_props->condition.setCondition(found_it->second);
+        inst_ops_props->condition.setCondition(value);
     }
 
-    found_it = getInstanceAttrIterator("size_condition");
-    if (found_it != inst_ops_props->instAttrsMap.end())
+    found = getInstanceAttr("size_condition", value);
+    if (found)
     {
-        string cond_size = found_it->second;
+        string cond_size = value;
         if (cond_size.substr(0, 10) == "$(parent).")
         {
             cond_size.erase(0, 10);
@@ -171,6 +188,11 @@ u_int32_t AdbInstance::calcArrOffset(bool bigEndianArr)
     return o_offset;
 }
 
+bool AdbInstance::stop_on_partition() const
+{
+    return partition_tree != nullptr;
+}
+
 void AdbInstance::eval_expressions(AttrsMap& parent_vars)
 {
     static mstflint::common::regex::regex EXP_REGEX(EXP_PATTERN);
@@ -402,6 +424,10 @@ bool AdbInstance::isPartOfArray()
  **/
 string AdbInstance::fullName(size_t skipLevel)
 {
+    if (full_path.size() > 0)
+    {
+        return full_path;
+    }
     list<string> fnList;
     AdbInstance* p = parent;
 
@@ -562,19 +588,19 @@ void AdbInstance::set_is_diff(bool val)
 }
 
 /**
- * Function: AdbInstance::fullName
+ * Function: AdbInstance::dwordAddr
  **/
-u_int32_t AdbInstance::dwordAddr()
+u_int32_t AdbInstance::dwordAddr(uint8_t alignment)
 {
-    return (offset >> 5) << 2;
+    return (offset / alignment) << 2;
 }
 
 /**
- * Function: AdbInstance::fullName
+ * Function: AdbInstance::startBit
  **/
-u_int32_t AdbInstance::startBit()
+u_int32_t AdbInstance::startBit(uint8_t alignment)
 {
-    return offset % 32;
+    return offset % alignment;
 }
 
 /**
@@ -660,6 +686,19 @@ vector<AdbInstance*> AdbInstance::findChild(const string& childName, bool isCase
     return childList;
 }
 
+/**
+ * Function: AdbInstance::get_root
+ **/
+AdbInstance* AdbInstance::get_root()
+{
+    auto current_layout_item = this;
+    while (current_layout_item->parent)
+    {
+        current_layout_item = current_layout_item->parent;
+    }
+    return current_layout_item;
+}
+
 /**
  * Function: AdbInstance::getAttr
  **/
@@ -800,7 +839,9 @@ AttrsMap AdbInstance::getVarsMap()
  **/
 bool AdbInstance::isEnumExists()
 {
-    return inst_ops_props ? inst_ops_props->instAttrsMap.contains("enum") : fieldDesc->attrs.count("enum");
+    return inst_ops_props ? inst_ops_props->instAttrsMap.contains("enum") :
+           fieldDesc ? fieldDesc->attrs.count("enum") :
+                                         false;
 }
 
 /**

adb_parser/adb_instance.h

@@ -51,6 +51,7 @@ using namespace xmlCreator;
 typedef map<string, string> AttrsMap;
 class AdbField;
 class AdbNode;
+struct PartitionTree;
 class LayoutItemAttrsMap
 {
 public:
@@ -144,6 +145,13 @@ class AdbInstance
         }
     };
 
+    struct LayoutPartitionProps
+    {
+        PartitionTree* partition_tree;
+
+        LayoutPartitionProps(PartitionTree* tree);
+    };
+
 public:
     // Methods
     AdbInstance() = default;
@@ -154,10 +162,15 @@ class AdbInstance
                 map<string, string> vars,
                 bool bigEndianArr,
                 bool isExprEval,
-                unsigned char adabe_version = 1);
+                unsigned char adabe_version = 1,
+                bool optimize_time = false,
+                bool stop_on_partition = false,
+                PartitionTree* next_partition_tree = nullptr);
+
     ~AdbInstance();
     void init_props(unsigned char adabe_version);
     u_int32_t calcArrOffset(bool bigEndianArr);
+    bool stop_on_partition() const;
     void eval_expressions(AttrsMap& i_vars);
     static string evalExpr(string expr, AttrsMap* vars);
     const string& get_field_name();
@@ -174,9 +187,9 @@ class AdbInstance
     bool is_wo() const;
     bool is_diff() const;
     void set_is_diff(bool val);
-    u_int32_t dwordAddr();
-    u_int32_t startBit();
     bool isEnumExists();
+    u_int32_t dwordAddr(uint8_t alignment = 32);
+    u_int32_t startBit(uint8_t alignment = 32);
     bool enumToInt(const string& name, u_int64_t& val); // false means no enum value found
     bool intToEnum(u_int64_t val, string& valName);     // false means no enum name found
     map<string, u_int64_t> getEnumMap();
@@ -189,6 +202,7 @@ class AdbInstance
     // DB like access methods
     AdbInstance* getChildByPath(const string& path, bool isCaseSensitive = true);
     vector<AdbInstance*> findChild(const string& name, bool isCaseSensitive = true, bool by_inst_name = false);
+    AdbInstance* get_root();
     string getInstanceAttr(const string& attrName) const;
     bool getInstanceAttr(const string& attrName, string& value);
     LayoutItemAttrsMap::iterator getInstanceAttrIterator(const string& attrName);
@@ -210,6 +224,7 @@ class AdbInstance
 
     // Members
     string layout_item_name{}; // instance name
+    string full_path{};
     vector<AdbInstance*> subItems{};
     AdbField* fieldDesc{nullptr};
     AdbNode* nodeDesc{nullptr};
@@ -221,6 +236,7 @@ class AdbInstance
     u_int32_t size{0};            // in bits
     u_int32_t maxLeafSize{0};     // in bits for DS alignment check
     InstancePropertiesMask inst_props{};
+    PartitionTree* partition_tree{nullptr};
 };
 
 #endif