1 files changed, 29 insertions, 31 deletions

diff --git a/src/fdt.zig b/src/fdt.zig
index 74c987b..67efb53 100644
--- a/src/fdt.zig
+++ b/src/fdt.zig
@@ -6,8 +6,6 @@ const std = @import("std");
 
 const slice = @import("slice.zig");
 
-const mem = std.mem;
-
 pub const ParseError = error{
     BadMagic,
     BadToken,
@@ -36,7 +34,7 @@ pub const Node = struct {
     subnodes: std.ArrayList(Node),
 
     pub fn unitAddr(self: Node) !?usize {
-        var nameSplit = mem.splitScalar(u8, self.name, '@');
+        var nameSplit = std.mem.splitScalar(u8, self.name, '@');
         _ = nameSplit.next();
         const unitAddrStr = nameSplit.next() orelse return null;
 
@@ -55,8 +53,8 @@ pub const PropertyDesc = struct {
 
     pub fn fromPtr(ptr: *PropertyDesc) PropertyDesc {
         return .{
-            .len = mem.bigToNative(u32, ptr.len),
-            .name_offset = mem.bigToNative(u32, ptr.name_offset),
+            .len = std.mem.bigToNative(u32, ptr.len),
+            .name_offset = std.mem.bigToNative(u32, ptr.name_offset),
         };
     }
 };
@@ -119,22 +117,22 @@ pub const Header = struct {
         const hdr = .{
             .raw_hdr = raw_hdr,
 
-            .magic = mem.bigToNative(u32, raw_hdr.magic),
-            .total_size = mem.bigToNative(u32, raw_hdr.total_size),
-            .offset_dt_struct = mem.bigToNative(u32, raw_hdr.offset_dt_struct),
-            .offset_dt_strings = mem.bigToNative(u32, raw_hdr.offset_dt_strings),
-            .offset_mem_reserve_map = mem.bigToNative(u32, raw_hdr.offset_mem_reserve_map),
-            .version = mem.bigToNative(u32, raw_hdr.version),
-            .last_compat_version = mem.bigToNative(u32, raw_hdr.last_compat_version),
+            .magic = std.mem.bigToNative(u32, raw_hdr.magic),
+            .total_size = std.mem.bigToNative(u32, raw_hdr.total_size),
+            .offset_dt_struct = std.mem.bigToNative(u32, raw_hdr.offset_dt_struct),
+            .offset_dt_strings = std.mem.bigToNative(u32, raw_hdr.offset_dt_strings),
+            .offset_mem_reserve_map = std.mem.bigToNative(u32, raw_hdr.offset_mem_reserve_map),
+            .version = std.mem.bigToNative(u32, raw_hdr.version),
+            .last_compat_version = std.mem.bigToNative(u32, raw_hdr.last_compat_version),
 
             // v2
-            .boot_cpuid_phys = mem.bigToNative(u32, raw_hdr.boot_cpuid_phys),
+            .boot_cpuid_phys = std.mem.bigToNative(u32, raw_hdr.boot_cpuid_phys),
 
             // v3
-            .size_dt_strings = mem.bigToNative(u32, raw_hdr.size_dt_strings),
+            .size_dt_strings = std.mem.bigToNative(u32, raw_hdr.size_dt_strings),
 
             // v17
-            .size_dt_struct = mem.bigToNative(u32, raw_hdr.size_dt_struct),
+            .size_dt_struct = std.mem.bigToNative(u32, raw_hdr.size_dt_struct),
         };
 
         if (hdr.magic != magic) {
@@ -156,7 +154,7 @@ pub const Header = struct {
         return @ptrCast(mem_reservations[0..i]);
     }
 
-    pub fn parseTree(self: *const Header, allocator: mem.Allocator) !Tree {
+    pub fn parseTree(self: *const Header, allocator: std.mem.Allocator) !Tree {
         var nodes = std.ArrayList(Node).init(allocator);
 
         var dt_struct_addr = @intFromPtr(self.raw_hdr) + @as(usize, self.offset_dt_struct);
@@ -164,7 +162,7 @@ pub const Header = struct {
         const dt_strings_addr = @intFromPtr(self.raw_hdr) + @as(usize, self.offset_dt_strings);
         const dt_strings: [*:0]const u8 = @ptrFromInt(dt_strings_addr);
 
-        while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(dt_struct_addr)).*) != token_end) {
+        while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(dt_struct_addr)).*) != token_end) {
             const parsed = try parseNode(allocator, dt_struct_addr, dt_strings);
             dt_struct_addr = parsed.addr;
             try nodes.insert(0, parsed.value);
@@ -180,7 +178,7 @@ pub fn findNode(nodes: []const Node, name: []const u8) slice.Filter(Node, []cons
 
 pub fn findNodeExact(nodes: []const Node, name: []const u8) ?struct { usize, Node } {
     for (nodes, 0..) |node, i| {
-        if (mem.eql(u8, node.name, name)) {
+        if (std.mem.eql(u8, node.name, name)) {
             return .{ i, node };
         }
     }
@@ -189,23 +187,23 @@ pub fn findNodeExact(nodes: []const Node, name: []const u8) ?struct { usize, Nod
 }
 
 fn nodeNameFilter(node: Node, name: []const u8) bool {
-    var it = mem.splitScalar(u8, node.name, '@');
+    var it = std.mem.splitScalar(u8, node.name, '@');
     const trueName = it.first();
-    return mem.eql(u8, trueName, name);
+    return std.mem.eql(u8, trueName, name);
 }
 
-fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(Node) {
+fn parseNode(allocator: std.mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(Node) {
     var props = std.StringHashMap([]const u8).init(allocator);
     var subnodes = std.ArrayList(Node).init(allocator);
 
     var addr = dt_struct_addr;
 
     // Skip Nop tokens
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
         addr += @sizeOf(u32);
     }
 
-    if (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_begin_node) {
+    if (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_begin_node) {
         return ParseError.ExpectedBeginNodeToken;
     }
 
@@ -213,13 +211,13 @@ fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]c
 
     const name: [*:0]u8 = @ptrFromInt(addr);
 
-    addr += mem.len(name) + 1;
+    addr += std.mem.len(name) + 1;
 
     // Skip zeroed alignment padding
-    addr += (4 - ((mem.len(name) + 1) % 4)) % 4;
+    addr += (4 - ((std.mem.len(name) + 1) % 4)) % 4;
 
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_end_node) {
-        switch (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*)) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_end_node) {
+        switch (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*)) {
             Header.token_prop => {
                 const parsed = try parseProperty(addr, dt_strings);
                 addr = parsed.addr;
@@ -247,7 +245,7 @@ fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]c
     return .{
         .addr = addr,
         .value = .{
-            .name = mem.span(name),
+            .name = std.mem.span(name),
             .props = props,
             .subnodes = subnodes,
         },
@@ -258,11 +256,11 @@ fn parseProperty(dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(
     var addr = dt_struct_addr;
 
     // Skip Nop tokens
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
         addr += @sizeOf(u32);
     }
 
-    if (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_prop) {
+    if (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_prop) {
         return ParseError.ExpectedPropToken;
     }
 
@@ -284,7 +282,7 @@ fn parseProperty(dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(
     return .{
         .addr = addr,
         .value = .{
-            .name = mem.span(name),
+            .name = std.mem.span(name),
             .value = value,
         },
     };