enums in SVD are always children of peripherals (#71)

* enums in SVD are always children of peripherals

* make SVD enums anonymous for now

tools/regz/src/Database.zig

@@ -435,8 +435,7 @@ pub fn createEnum(
         size: ?u64 = null,
     },
 ) !EntityId {
-    assert(db.entityIs("type.peripheral", parent_id) or
-        db.entityIs("type.field", parent_id));
+    assert(db.entityIs("type.peripheral", parent_id));
 
     const id = db.createEntity();
     errdefer db.destroyEntity(id);

tools/regz/src/svd.zig

@@ -363,8 +363,17 @@ fn loadEnumeratedValues(ctx: *Context, node: xml.Node, field_id: EntityId) !void
     const db = ctx.db;
 
     assert(db.entityIs("type.field", field_id));
-    const id = try db.createEnum(field_id, .{
-        .name = node.getValue("name"),
+    const peripheral_id = peripheral_id: {
+        var id = field_id;
+        break :peripheral_id while (db.attrs.parent.get(id)) |parent_id| : (id = parent_id) {
+            if (.peripheral == db.getEntityType(parent_id).?)
+                break parent_id;
+        } else return error.NoPeripheralFound;
+    };
+
+    const id = try db.createEnum(peripheral_id, .{
+        // TODO: find solution to potential name collisions for enums at the peripheral level.
+        //.name = node.getValue("name"),
         .size = db.attrs.size.get(field_id),
     });
     errdefer db.destroyEntity(id);
@@ -440,6 +449,7 @@ pub const DimableIdentifier = struct {
 /// pattern: [0-9]+\-[0-9]+|[A-Z]-[A-Z]|[_0-9a-zA-Z]+(,\s*[_0-9a-zA-Z]+)+
 pub const DimIndex = struct {};
 
+const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const expectError = std.testing.expectError;
 
@@ -1110,15 +1120,20 @@ test "svd.field with enum value" {
     var db = try Database.initFromSvd(std.testing.allocator, doc);
     defer db.deinit();
 
+    const peripheral_id = try db.getEntityIdByName("type.peripheral", "TEST_PERIPHERAL");
     const field_id = try db.getEntityIdByName("type.field", "TEST_FIELD");
-    const enum_id = try db.getEntityIdByName("type.enum", "TEST_ENUM");
+
+    // TODO: figure out a name collision avoidance mechanism for SVD. For now
+    // we'll make all SVD enums anonymous
+    const enum_id = db.attrs.@"enum".get(field_id).?;
+    try expect(!db.attrs.name.contains(enum_id));
 
     // field
     try expectAttr(db, "enum", enum_id, field_id);
 
     // enum
     try expectAttr(db, "size", 8, enum_id);
-    try expectAttr(db, "parent", field_id, enum_id);
+    try expectAttr(db, "parent", peripheral_id, enum_id);
 
     const enum_field1_id = try db.getEntityIdByName("type.enum_field", "TEST_ENUM_FIELD1");
     try expectEqual(@as(u32, 0), db.types.enum_fields.get(enum_field1_id).?);
@@ -1168,6 +1183,7 @@ test "svd.peripheral with dimElementGroup" {
 }
 
 test "svd.peripheral with dimElementgroup, dimIndex set" {
+    std.testing.log_level = .err;
     const text =
         \\<device>
         \\  <name>TEST_DEVICE</name>
@@ -1238,6 +1254,7 @@ test "svd.register with dimElementGroup" {
 }
 
 test "svd.register with dimElementGroup, dimIncrement != size" {
+    std.testing.log_level = .err;
     const text =
         \\<device>
         \\  <name>TEST_DEVICE</name>