Feat/3dblox parser path assertions

src/odb/include/odb/db.h

@@ -117,6 +117,7 @@ class dbChipBumpInst;
 class dbChipConn;
 class dbChipInst;
 class dbChipNet;
+class dbChipPath;
 class dbChipRegion;
 class dbChipRegionInst;
 class dbDatabase;
@@ -7265,6 +7266,10 @@ class dbChip : public dbObject
 
   dbSet<dbMarkerCategory> getMarkerCategories() const;
 
+  dbSet<dbChipPath> getChipPaths() const;
+
+  dbChipPath* findChipPath(const char* name) const;
+
   // User Code Begin dbChip
 
   ChipType getChipType() const;
@@ -7441,6 +7446,34 @@ class dbChipNet : public dbObject
   // User Code End dbChipNet
 };
 
+class dbChipPath : public dbObject
+{
+ public:
+  const char* getName() const;
+
+  // User Code Begin dbChipPath
+  struct Entry
+  {
+    std::vector<dbChipInst*> chip_inst_path;  // hierarchical path to the region
+    dbChipRegionInst* region;
+    bool negated;  // do not touch this region, i.e., the path must be connected
+                   // without crossing this region
+  };
+
+  dbChip* getChip() const;
+
+  std::vector<Entry> getEntries() const;
+
+  void addEntry(const std::vector<dbChipInst*>& chip_inst_path,
+                dbChipRegionInst* region,
+                bool negated);
+
+  static dbChipPath* create(dbChip* chip, const char* name);
+
+  static void destroy(dbChipPath* path);
+  // User Code End dbChipPath
+};
+
 class dbChipRegion : public dbObject
 {
  public:

src/odb/include/odb/dbCompare.inc

@@ -521,6 +521,15 @@ struct less<odb::dbChipNet*>
   }
 };
 
+template <>
+struct less<odb::dbChipPath*>
+{
+  bool operator()(const odb::dbChipPath* lhs, const odb::dbChipPath* rhs) const
+  {
+    return odb::compare_by_id(lhs, rhs);
+  }
+};
+
 template <>
 struct less<odb::dbChipRegion*>
 {

src/odb/include/odb/dbObject.h

@@ -67,6 +67,7 @@ enum dbObjectType
   dbChipConnObj,
   dbChipInstObj,
   dbChipNetObj,
+  dbChipPathObj,
   dbChipRegionObj,
   dbChipRegionInstObj,
   dbDatabaseObj,

src/odb/src/3dblox/3dblox.cpp

@@ -188,6 +188,15 @@ void ThreeDBlox::readDbx(const std::string& dbx_file)
     createConnection(connection);
   }
   calculateSize(chip);
+  for (const auto& [_, assertion] : data.path_assertions) {
+    dbChipPath* chip_path = dbChipPath::create(chip, assertion.name.c_str());
+    for (const auto& entry : assertion.entries) {
+      // Resolve the dotted path string to a live DB object
+      std::vector<dbChipInst*> path_insts;
+      dbChipRegionInst* region_inst = resolvePath(entry.region, path_insts);
+      chip_path->addEntry(path_insts, region_inst, entry.negated);
+    }
+  }
 }
 
 void ThreeDBlox::check()

src/odb/src/3dblox/baseParser.cpp

@@ -187,7 +187,19 @@ std::string BaseParser::trim(const std::string& str)
   return str.substr(start, end - start + 1);
 }
 
+template <typename T>
+void BaseParser::extractValue(const YAML::Node& node, T& value)
+{
+  try {
+    value = node.as<T>();
+  } catch (const YAML::Exception& e) {
+    logError("Error parsing value: " + std::string(e.what()));
+  }
+}
+
 // Explicit template instantiations for common types
+template void BaseParser::extractValue<std::string>(const YAML::Node& node,
+                                                    std::string& value);
 template void BaseParser::extractValue<std::string>(const YAML::Node& node,
                                                     const std::string& key,
                                                     std::string& value);

src/odb/src/3dblox/baseParser.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include <map>
 #include <string>
 #include <vector>
 
@@ -28,6 +27,8 @@ class BaseParser
   // YAML helper methods
   template <typename T>
   void extractValue(const YAML::Node& node, const std::string& key, T& value);
+  template <typename T>
+  void extractValue(const YAML::Node& node, T& value);
   void parseCoordinate(Coordinate& coord, const YAML::Node& coord_node);
   void parseCoordinates(std::vector<Coordinate>& coords,
                         const YAML::Node& coords_node);

src/odb/src/3dblox/dbxParser.cpp

@@ -63,6 +63,9 @@ void DbxParser::parseYamlContent(DbxData& data, const std::string& content)
     if (root["Connection"]) {
       parseConnections(data.connections, root["Connection"]);
     }
+    if (root["Path"]) {
+      parsePaths(data.path_assertions, root["Path"]);
+    }
 
   } catch (const YAML::Exception& e) {
     logError("DBX YAML parsing error: " + std::string(e.what()));
@@ -233,4 +236,65 @@ void DbxParser::parseConnection(Connection& connection,
   }
 }
 
+void DbxParser::parsePaths(std::map<std::string, PathAssertion>& paths,
+                           const YAML::Node& paths_node)
+{
+  paths.clear();
+  const std::string prefix = "Path";
+  for (const auto& path_pair : paths_node) {
+    PathAssertion path;
+    extractValue(path_pair.first, path.name);
+
+    // Validate name format: must be "PathN" where N is a positive integer.
+    if (path.name.size() <= prefix.size() || !path.name.starts_with(prefix)
+        || path.name.find_first_not_of("0123456789", prefix.size())
+               != std::string::npos
+        || path.name[prefix.size()] == '0') {
+      logError("DBX Path assertion name '" + path.name
+               + "' must follow the format 'PathN' (e.g. Path1, Path2)");
+      continue;
+    }
+
+    const YAML::Node& path_node = path_pair.second;
+    parsePath(path, path_node);
+    paths[path.name] = path;
+  }
+}
+
+void DbxParser::parsePath(PathAssertion& path, const YAML::Node& path_node)
+{
+  if (!path_node.IsSequence()) {
+    logError("DBX Path assertion '" + path.name + "' must be a YAML sequence");
+  }
+
+  const std::string prefix = "NOT ";
+  for (const auto& entry_node : path_node) {
+    std::string raw;
+    extractValue(entry_node, raw);
+
+    raw = trim(raw);
+    if (raw.empty()) {
+      continue;
+    }
+
+    PathAssertionEntry entry;
+    if (raw.substr(0, prefix.size()) == prefix) {
+      entry.negated = true;
+      raw = trim(raw.substr(prefix.size()));
+    }
+
+    if (raw.find(".regions.") == std::string::npos) {
+      logError("DBX Path assertion entry '" + raw + "' in '" + path.name
+               + "' must contain '.regions.' (e.g. HBM_1.regions.r1)");
+    }
+
+    entry.region = raw;
+    path.entries.push_back(entry);
+  }
+
+  if (path.entries.empty()) {
+    logError("DBX Path assertion '" + path.name + "' has no valid entries");
+  }
+}
+
 }  // namespace odb

src/odb/src/3dblox/dbxParser.h

@@ -39,6 +39,9 @@ class DbxParser : public BaseParser
                         const YAML::Node& connections_node);
   void parseConnection(Connection& connection,
                        const YAML::Node& connection_node);
+  void parsePaths(std::map<std::string, PathAssertion>& paths,
+                  const YAML::Node& paths_node);
+  void parsePath(PathAssertion& path, const YAML::Node& path_node);
 };
 
 }  // namespace odb

src/odb/src/3dblox/objects.h

@@ -9,6 +9,18 @@
 
 namespace odb {
 
+struct PathAssertionEntry
+{
+  std::string region;    // e.g. "HBM_1.regions.r1"
+  bool negated = false;  // true when prefixed with "NOT"
+};
+
+struct PathAssertion
+{
+  std::string name;  // e.g. "Path1"
+  std::vector<PathAssertionEntry> entries;
+};
+
 struct Coordinate
 {
   double x, y;
@@ -121,6 +133,7 @@ struct DbxData
   DesignDef design;
   std::map<std::string, ChipletInst> chiplet_instances;
   std::map<std::string, Connection> connections;
+  std::map<std::string, PathAssertion> path_assertions;
 };
 
 struct BumpMapEntry

src/odb/src/codeGenerator/gen.py

@@ -165,6 +165,7 @@ def add_field_attributes(
                 and not template_class_name.isdigit()
                 and template_class_name not in {"true", "false"}
                 and "no-template" not in field.flags
+                and template_class_name.startswith("_")
                 and klass.name != template_class_name[1:]
                 and klass.name + "::" != template_class_name[: len(klass.name) + 2]
             )

src/odb/src/codeGenerator/helper.py

@@ -162,16 +162,36 @@ def is_template_type(type_name: str) -> bool:
     return closed_bracket >= open_bracket
 
 
-def _is_comma_divided(type_name: str) -> bool:
-    return "," in type_name
+def _split_top_level_commas(type_name: str) -> List[str]:
+    """Split by commas at angle-bracket depth 0."""
+    parts = []
+    depth = 0
+    start = 0
+    for i, ch in enumerate(type_name):
+        if ch == "<":
+            depth += 1
+        elif ch == ">":
+            depth -= 1
+        elif ch == "," and depth == 0:
+            parts.append(type_name[start:i].strip())
+            start = i + 1
+    parts.append(type_name[start:].strip())
+    return [p for p in parts if p]
 
 
 def get_template_types(type_name: str) -> List[str]:
+    # Check for top-level commas first (bracket-aware)
+    parts = _split_top_level_commas(type_name)
+    if len(parts) > 1:
+        result = []
+        for part in parts:
+            if part.isdigit() or part in {"true", "false"}:
+                continue
+            result.extend(get_template_types(part))
+        return result
+    # Single type — if it is a template, peel the outer layer
     if is_template_type(type_name):
         return get_template_types(get_template_type(type_name))
-    if _is_comma_divided(type_name):
-        types = [t.strip() for t in type_name.split(",")]
-        return [t for t in types if not (t.isdigit() or t in {"true", "false"})]
     return [type_name]
 
 

src/odb/src/codeGenerator/schema.json

@@ -504,6 +504,15 @@
       "tbl_name":"chip_net_tbl_",
       "schema":"kSchemaChipRegion",
       "flags": ["no-serial"]
+    },
+    {
+      "parent":"dbChip",
+      "child":"dbChipPath",
+      "type":"1_n",
+      "tbl_name":"chip_path_tbl_",
+      "schema":"kSchemaChipPath",
+      "hash": true,
+      "flags": ["no-serial"]
     }
   ]
 }

src/odb/src/codeGenerator/schema/chip/dbChipPath.json

@@ -0,0 +1,30 @@
+{
+    "name": "dbChipPath",
+    "type": "dbObject",
+    "fields": [
+        {
+            "name": "name_",
+            "type": "char *",
+            "default": "nullptr",
+            "flags": [
+                "no-set"
+            ]
+        },
+        {
+            "name": "entries_",
+            "type": "std::vector<std::tuple<std::vector<dbId<_dbChipInst>>, dbId<_dbChipRegionInst>, bool>>",
+            "flags": [
+                "private",
+                "no-cmp"
+            ]
+        }
+    ],
+    "h_includes": [
+        "odb/dbId.h"
+    ],
+    "cpp_includes": [
+        "dbChip.h",
+        "dbChipRegionInst.h",
+        "dbChipInst.h"
+    ]
+}

src/odb/src/db/CMakeLists.txt

@@ -97,6 +97,7 @@ add_library(db
     dbChipConn.cpp
     dbChipInst.cpp
     dbChipNet.cpp
+    dbChipPath.cpp
     dbChipRegion.cpp
     dbChipRegionInst.cpp
     dbDatabase.cpp