From 92cdc4a1d88d324d3f82242d7525cdf824dc0292 Mon Sep 17 00:00:00 2001 From: Vesim Date: Thu, 5 Nov 2026 02:19:54 +0100 Subject: [PATCH 1/2] feat(zlinter): enable no_deprecated --- build.zig | 9 ++-- core/src/allocator.zig | 12 ++--- core/src/core/usb.zig | 6 +-- core/src/cpus/cortex_m.zig | 12 ++--- core/src/microzig.zig | 2 +- core/test/backings.zig | 2 +- drivers/src/base/DatagramDevice.zig | 4 +- drivers/src/base/I2C_Device.zig | 4 +- drivers/src/base/StreamDevice.zig | 4 +- drivers/src/display/colors.zig | 2 +- drivers/src/input/keyboard_matrix.zig | 2 +- drivers/src/wireless/cyw43439/ioctl.zig | 2 +- examples/nordic/nrf5x/src/usb_cdc.zig | 2 +- examples/raspberrypi/rp2xxx/build.zig | 14 +++--- examples/raspberrypi/rp2xxx/src/board_id.zig | 2 +- examples/raspberrypi/rp2xxx/src/dma.zig | 2 +- .../raspberrypi/rp2xxx/src/flash_program.zig | 2 +- .../raspberrypi/rp2xxx/src/net/tcp_client.zig | 2 +- .../rp2xxx/src/rp2040_only/random.zig | 2 +- .../raspberrypi/rp2xxx/src/ssd1306_oled.zig | 2 +- .../raspberrypi/rp2xxx/src/stepper_driver.zig | 2 +- .../rp2xxx/src/stepper_driver_dumb.zig | 2 +- examples/raspberrypi/rp2xxx/src/uart_log.zig | 2 +- examples/raspberrypi/rp2xxx/src/usb_cdc.zig | 4 +- examples/raspberrypi/rp2xxx/src/usb_hid.zig | 2 +- examples/texasinstruments/mspm0/build.zig | 2 +- .../texasinstruments/mspm0/src/uart_log.zig | 2 +- examples/wch/ch32h/build.zig | 2 +- examples/wch/ch32v/src/usb_cdc.zig | 2 +- modules/foundation-libc/src/libc.zig | 4 +- .../foundation-libc/src/modules/assert.zig | 2 +- .../foundation-libc/src/modules/string.zig | 2 +- modules/foundation-libc/test/build.zig | 2 +- modules/network/build.zig | 2 +- modules/network/src/root.zig | 2 +- modules/rtt/src/rtt.zig | 2 +- modules/virtual-io/src/root.zig | 2 +- port/espressif/esp/src/cpus/esp_riscv.zig | 2 +- port/espressif/esp/src/hal/atomic.zig | 2 +- port/espressif/esp/src/hal/radio/osi.zig | 8 ++-- .../gd32/src/hals/GD32VF103/pins.zig | 2 +- port/microchip/atmega/src/chips.zig | 2 +- port/nxp/lpc/src/hals/LPC176x5x.zig | 2 +- port/nxp/mcx/src/mcxn947/scripts/generate.zig | 6 +-- port/raspberrypi/rp2xxx/src/cpus/hazard3.zig | 2 +- port/raspberrypi/rp2xxx/src/hal/atomic.zig | 2 +- port/raspberrypi/rp2xxx/src/hal/pins.zig | 2 +- .../src/hal/pio/assembler/Expression.zig | 2 +- .../src/hal/pio/assembler/tokenizer.zig | 2 +- port/raspberrypi/rp2xxx/src/hal/uart.zig | 2 +- .../raspberrypi/rp2xxx/tools/rp2040-flash.zig | 8 ++-- port/stmicro/stm32/build.zig | 2 +- port/stmicro/stm32/src/generate.zig | 12 ++--- .../stmicro/stm32/src/hals/STM32F103/pins.zig | 4 +- .../stmicro/stm32/src/hals/STM32F103/util.zig | 4 +- .../stmicro/stm32/src/hals/common/pins_v2.zig | 2 +- port/stmicro/stm32/src/hals/common/util.zig | 4 +- port/texasinstruments/msp430/build.zig | 4 +- port/texasinstruments/mspm0/src/hal/Uart.zig | 4 +- port/texasinstruments/tm4c/build.zig | 4 +- port/wch/ch32h/src/cpus/main.zig | 2 +- port/wch/ch32v/src/cpus/main.zig | 2 +- port/wch/ch32v/src/hals/ch32v003/pins.zig | 2 +- port/wch/ch32v/src/hals/pins.zig | 2 +- sim/aviron/build.zig | 32 ++++++------- sim/aviron/src/lib/decoder.zig | 4 +- sim/aviron/src/testconfig.zig | 2 +- sim/aviron/src/testrunner.zig | 8 ++-- sim/aviron/tools/generate_tables.zig | 14 +++--- tools/esp-image/src/elf2image.zig | 4 +- tools/generate_linker_script.zig | 4 +- tools/linter/src/main.zig | 12 ++--- tools/parts_db.zig | 4 +- tools/printer/src/DebugInfo.zig | 2 +- tools/printer/src/Elf.zig | 40 ++++++++-------- tools/printer/src/root.zig | 4 +- tools/printer/tests/test.zig | 2 +- tools/regz/src/Database.zig | 4 +- tools/regz/src/analysis.zig | 2 +- tools/regz/src/atdf.zig | 4 +- tools/regz/src/embassy.zig | 28 +++++------ tools/regz/src/gen.zig | 22 ++++----- tools/regz/src/patch.zig | 2 +- tools/regz/src/svd.zig | 24 +++++----- tools/release/src/Archive.zig | 30 ++++++------ tools/release/src/Manifest.zig | 4 +- tools/release/src/hash_test.zig | 8 ++-- tools/release/src/main.zig | 18 +++---- tools/release/src/tar.zig | 48 +++++++++---------- tools/uf2/build.zig | 27 +++++------ tools/uf2/src/uf2.zig | 6 +-- 91 files changed, 289 insertions(+), 289 deletions(-) diff --git a/build.zig b/build.zig index b595bf50e..7f39f7207 100644 --- a/build.zig +++ b/build.zig @@ -67,6 +67,7 @@ pub fn build(b: *Build) void { .exclude_dirs = &.{b.path("tools/sorcerer")}, }); builder.addRule(.{ .builtin = .no_hidden_allocations }, .{}); + builder.addRule(.{ .builtin = .no_deprecated }, .{}); builder.addRule(.{ .builtin = .require_fmt }, .{}); break :step builder.build(); }); @@ -161,7 +162,7 @@ pub fn MicroBuild(port_select: PortSelect) type { var field_names: [count][]const u8 = undefined; var field_types: [count]type = undefined; - var field_attrs: [count]std.builtin.Type.Struct.FieldAttributes = undefined; + var field_attrs: [count]std.lang.Type.Struct.FieldAttributes = undefined; if (count > 0) { var i: usize = 0; @@ -238,7 +239,7 @@ pub fn MicroBuild(port_select: PortSelect) type { /// The optimization level that should be used. Usually `ReleaseSmall` or `Debug` is a good choice. /// Also using `std.Build.standardOptimizeOption` is a good idea. - optimize: std.builtin.OptimizeMode, + optimize: std.lang.Optimize, /// The root source file for the application. This is your `src/main.zig` file. root_source_file: LazyPath, @@ -286,7 +287,7 @@ pub fn MicroBuild(port_select: PortSelect) type { strip_unused_symbols: bool = true, /// Unwind tables option for the firmware executable. - unwind_tables: ?std.builtin.UnwindTables = null, + unwind_tables: ?std.lang.UnwindTables = null, /// Error tracing option for the firmware executable. error_tracing: ?bool = null, @@ -759,7 +760,7 @@ pub fn MicroBuild(port_select: PortSelect) type { }, }) catch @panic("OOM"), }; - } else if (target.cpu.arch.isRISCV() and target.ptrBitWidth() == 32) { + } else if (target.cpu.arch.isRiscv() and target.ptrBitWidth() == 32) { return .{ .name = "riscv32", .root_source_file = mb.core_dep.namedLazyPath("cpu_riscv32"), diff --git a/core/src/allocator.zig b/core/src/allocator.zig index a9a915a9a..be68f98e5 100644 --- a/core/src/allocator.zig +++ b/core/src/allocator.zig @@ -1273,7 +1273,7 @@ test "oom - near exhaustion still works" { const a = alloc.allocator(); // Allocate until near exhaustion - var allocations: std.ArrayListUnmanaged([]u8) = .empty; + var allocations: std.ArrayList([]u8) = .empty; defer allocations.deinit(testing.allocator); while (true) { @@ -1467,7 +1467,7 @@ test "stress - random alloc/free pattern" { var prng = std.Random.DefaultPrng.init(12345); const random = prng.random(); - var allocations: std.ArrayListUnmanaged([]u8) = .empty; + var allocations: std.ArrayList([]u8) = .empty; defer allocations.deinit(testing.allocator); // Perform random operations @@ -1520,7 +1520,7 @@ test "stress - many small allocations" { var alloc = try Alloc.init_with_buffer(&buffer); const a = alloc.allocator(); - var allocations: std.ArrayListUnmanaged([]u8) = .empty; + var allocations: std.ArrayList([]u8) = .empty; defer allocations.deinit(testing.allocator); // Allocate many small chunks @@ -1556,7 +1556,7 @@ test "fallback - allocation delegates when primary exhausted" { const a = alloc1.allocator(); // Exhaust primary - var primary_allocations: std.ArrayListUnmanaged([]u8) = .empty; + var primary_allocations: std.ArrayList([]u8) = .empty; defer primary_allocations.deinit(testing.allocator); while (true) { @@ -1588,7 +1588,7 @@ test "fallback - free delegates correctly" { const mem1 = try a.alloc(u8, 32); // Exhaust primary to force fallback use - var temp_allocs: std.ArrayListUnmanaged([]u8) = .empty; + var temp_allocs: std.ArrayList([]u8) = .empty; defer temp_allocs.deinit(testing.allocator); while (true) { @@ -1621,7 +1621,7 @@ test "fallback - chain of allocators" { const a = alloc1.allocator(); - var all_allocations: std.ArrayListUnmanaged([]u8) = .empty; + var all_allocations: std.ArrayList([]u8) = .empty; defer all_allocations.deinit(testing.allocator); // Should be able to allocate from all three buffers diff --git a/core/src/core/usb.zig b/core/src/core/usb.zig index a21e9e554..ff545073d 100644 --- a/core/src/core/usb.zig +++ b/core/src/core/usb.zig @@ -270,14 +270,14 @@ pub fn DeviceController(config: Config, driver_args: config.DriverArgs()) type { var size = @sizeOf(descriptor.Configuration); var field_names: [driver_info.field_names.len][:0]const u8 = undefined; var field_types: [driver_info.field_names.len]type = undefined; - var field_attrs: [driver_info.field_names.len]std.builtin.Type.Struct.FieldAttributes = undefined; + var field_attrs: [driver_info.field_names.len]std.lang.Type.Struct.FieldAttributes = undefined; var ep_handler_types: [2][16]type = @splat(@splat(void)); var ep_handler_names: [2][16][:0]const u8 = undefined; var ep_handler_drivers: [2][16]?usize = @splat(@splat(null)); var itf_handlers: []const DriverEnum = &.{}; var driver_alloc_names: []const [:0]const u8 = &.{}; var driver_alloc_types: []const type = &.{}; - var driver_alloc_attrs: []const std.builtin.Type.Struct.FieldAttributes = &.{}; + var driver_alloc_attrs: []const std.lang.Type.Struct.FieldAttributes = &.{}; for (driver_info.field_names, driver_info.field_types, 0..) |driver_field_name, driver_field_type, drv_id| { // Get descriptor type for the current driver @@ -291,7 +291,7 @@ pub fn DeviceController(config: Config, driver_args: config.DriverArgs()) type { if (result.alloc_bytes) |len| { driver_alloc_names = driver_alloc_names ++ &[_][:0]const u8{driver_field_name}; driver_alloc_types = driver_alloc_types ++ &[_]type{[len]u8}; - driver_alloc_attrs = driver_alloc_attrs ++ &[_]std.builtin.Type.Struct.FieldAttributes{.{ .@"align" = result.alloc_align }}; + driver_alloc_attrs = driver_alloc_attrs ++ &[_]std.lang.Type.Struct.FieldAttributes{.{ .@"align" = result.alloc_align }}; } else { assert(result.alloc_align == null); } diff --git a/core/src/cpus/cortex_m.zig b/core/src/cpus/cortex_m.zig index a9b8dff5a..8bf8b62c5 100644 --- a/core/src/cpus/cortex_m.zig +++ b/core/src/cpus/cortex_m.zig @@ -563,7 +563,7 @@ pub const atomic = struct { } /// Atomic load - pub fn load(comptime T: type, ptr: *const T, comptime ordering: std.builtin.AtomicOrder) T { + pub fn load(comptime T: type, ptr: *const T, comptime ordering: std.lang.AtomicOrder) T { if (has_native_atomics) { return @atomicLoad(T, ptr, ordering); } else { @@ -575,7 +575,7 @@ pub const atomic = struct { } /// Atomic store - pub fn store(comptime T: type, ptr: *T, value: T, comptime ordering: std.builtin.AtomicOrder) void { + pub fn store(comptime T: type, ptr: *T, value: T, comptime ordering: std.lang.AtomicOrder) void { if (has_native_atomics) { @atomicStore(T, ptr, value, ordering); } else { @@ -592,8 +592,8 @@ pub const atomic = struct { ptr: *T, expected_value: T, new_value: T, - comptime success_ordering: std.builtin.AtomicOrder, - comptime failure_ordering: std.builtin.AtomicOrder, + comptime success_ordering: std.lang.AtomicOrder, + comptime failure_ordering: std.lang.AtomicOrder, ) ?T { if (has_native_atomics) { return @cmpxchgWeak(T, ptr, expected_value, new_value, success_ordering, failure_ordering); @@ -614,9 +614,9 @@ pub const atomic = struct { pub fn rmw( comptime T: type, ptr: *T, - comptime op: std.builtin.AtomicRmwOp, + comptime op: std.lang.AtomicRmwOp, operand: T, - comptime ordering: std.builtin.AtomicOrder, + comptime ordering: std.lang.AtomicOrder, ) T { if (has_native_atomics) { return @atomicRmw(T, ptr, op, operand, ordering); diff --git a/core/src/microzig.zig b/core/src/microzig.zig index 7a84c437b..a8f3e9cf7 100644 --- a/core/src/microzig.zig +++ b/core/src/microzig.zig @@ -187,7 +187,7 @@ fn microzig_main() callconv(.c) noreturn { }; var buf: [msg_base.len + max_error_size]u8 = undefined; - const msg = std.fmt.bufPrint(&buf, "{s}{s}", .{ msg_base, @errorName(err) }) catch @panic(msg_base); + const msg = std.mem.print(&buf, "{s}{s}", .{ msg_base, @errorName(err) }) catch @panic(msg_base); @panic(msg); } else { @panic(msg_base); diff --git a/core/test/backings.zig b/core/test/backings.zig index 0a08dc5df..c32abbbca 100644 --- a/core/test/backings.zig +++ b/core/test/backings.zig @@ -3,7 +3,7 @@ const std = @import("std"); const microzig = @import("../build.zig"); fn root_dir() []const u8 { - return std.fs.path.dirname(@src().file) orelse unreachable; + return std.Io.Dir.path.dirname(@src().file) orelse unreachable; } const cpu = microzig.Cpu{ diff --git a/drivers/src/base/DatagramDevice.zig b/drivers/src/base/DatagramDevice.zig index c94a40669..aea6f14fd 100644 --- a/drivers/src/base/DatagramDevice.zig +++ b/drivers/src/base/DatagramDevice.zig @@ -142,7 +142,7 @@ pub const VTable = struct { /// A device implementation that can be used to write unit tests for datagram devices. pub const TestDevice = struct { arena: std.heap.ArenaAllocator, - packets: std.array_list.Managed([]u8), + packets: std.array_list.Managed([]u8), // zlinter-disable-current-line no_deprecated // If empty, reads are supported, but don't yield data. // If `null`, reads are not supported. @@ -164,7 +164,7 @@ pub const TestDevice = struct { pub fn init(input: ?[]const []const u8, write_enabled: bool) TestDevice { return TestDevice{ .arena = std.heap.ArenaAllocator.init(std.testing.allocator), - .packets = std.array_list.Managed([]u8).init(std.testing.allocator), + .packets = .init(std.testing.allocator), .input_sequence = input, .input_sequence_pos = 0, diff --git a/drivers/src/base/I2C_Device.zig b/drivers/src/base/I2C_Device.zig index 885ae9b10..b2cc60589 100644 --- a/drivers/src/base/I2C_Device.zig +++ b/drivers/src/base/I2C_Device.zig @@ -131,7 +131,7 @@ pub const VTable = struct { /// A device implementation that can be used to write unit tests for datagram devices. pub const TestDevice = struct { arena: std.heap.ArenaAllocator, - packets: std.array_list.Managed([]u8), + packets: std.array_list.Managed([]u8), // zlinter-disable-current-line no_deprecated // If empty, reads are supported, but don't yield data. // If `null`, reads are not supported. @@ -152,7 +152,7 @@ pub const TestDevice = struct { pub fn init(input: ?[]const []const u8, write_enabled: bool) TestDevice { return TestDevice{ .arena = std.heap.ArenaAllocator.init(std.testing.allocator), - .packets = std.array_list.Managed([]u8).init(std.testing.allocator), + .packets = .init(std.testing.allocator), .input_sequence = input, .input_sequence_pos = 0, diff --git a/drivers/src/base/StreamDevice.zig b/drivers/src/base/StreamDevice.zig index 40ea66a32..d62b4b392 100644 --- a/drivers/src/base/StreamDevice.zig +++ b/drivers/src/base/StreamDevice.zig @@ -177,7 +177,7 @@ pub const Reader = struct { /// A device implementation that can be used to write unit tests for datagram devices. pub const TestDevice = struct { input: ?std.Io.Reader, - output: ?std.array_list.Managed(u8), + output: ?std.array_list.Managed(u8), // zlinter-disable-current-line no_deprecated connected: bool, @@ -189,7 +189,7 @@ pub const TestDevice = struct { .input = if (input) |bytes| .fixed(bytes) else null, .output = if (write_enabled) - std.array_list.Managed(u8).init(std.testing.allocator) + std.array_list.Managed(u8).init(std.testing.allocator) // zlinter-disable-current-line no_deprecated else null, }; diff --git a/drivers/src/display/colors.zig b/drivers/src/display/colors.zig index a91bb1692..01613b076 100644 --- a/drivers/src/display/colors.zig +++ b/drivers/src/display/colors.zig @@ -10,7 +10,7 @@ pub const BlackWhite = enum(u1) { white = 1, }; -pub fn RGB565_Generic(desired_endianness: std.builtin.Endian) type { +pub fn RGB565_Generic(desired_endianness: std.lang.Endian) type { return struct { const Self = @This(); diff --git a/drivers/src/input/keyboard_matrix.zig b/drivers/src/input/keyboard_matrix.zig index 1c2b7cd21..bb7ad2278 100644 --- a/drivers/src/input/keyboard_matrix.zig +++ b/drivers/src/input/keyboard_matrix.zig @@ -39,7 +39,7 @@ pub fn KeyboardMatrix(comptime options: Options) type { /// A set that can store if each key is set or not. pub const Set = struct { - pressed: std.StaticBitSet(key_count) = .empty, + pressed: std.bit_set.Static(key_count) = .empty, /// Adds a key to the set. pub fn add(set: *Set, key: Key) void { diff --git a/drivers/src/wireless/cyw43439/ioctl.zig b/drivers/src/wireless/cyw43439/ioctl.zig index 95fe8576e..6d987463b 100644 --- a/drivers/src/wireless/cyw43439/ioctl.zig +++ b/drivers/src/wireless/cyw43439/ioctl.zig @@ -225,7 +225,7 @@ pub const Response = struct { } var evt: EventPacket = undefined; @memcpy(std.mem.asBytes(&evt), buf[0..@sizeOf(EventPacket)]); - std.mem.byteSwapAllFields(EventPacket, &evt); + std.mem.byteSwap(EventPacket, &evt); if (evt.eth.ether_type != 0x886c) return null; if (!mem.eql(u8, &evt.hdr.oui, &.{ 0x00, 0x10, 0x18 })) return null; diff --git a/examples/nordic/nrf5x/src/usb_cdc.zig b/examples/nordic/nrf5x/src/usb_cdc.zig index 0a5cbc99e..38144fc2c 100644 --- a/examples/nordic/nrf5x/src/usb_cdc.zig +++ b/examples/nordic/nrf5x/src/usb_cdc.zig @@ -98,7 +98,7 @@ var usb_tx_buff: [1024]u8 = undefined; /// NOTE: After each USB chunk transfer, we have to call the USB task so that bus TX events can be /// handled pub fn usb_cdc_write(serial: *USB_Serial, comptime fmt: []const u8, args: anytype) void { - var tx = std.fmt.bufPrint(&usb_tx_buff, fmt, args) catch &.{}; + var tx = std.mem.print(&usb_tx_buff, fmt, args) catch &.{}; while (tx.len > 0) { tx = tx[serial.write(tx)..]; diff --git a/examples/raspberrypi/rp2xxx/build.zig b/examples/raspberrypi/rp2xxx/build.zig index a16987076..a96c00a51 100644 --- a/examples/raspberrypi/rp2xxx/build.zig +++ b/examples/raspberrypi/rp2xxx/build.zig @@ -107,17 +107,17 @@ pub fn build(b: *std.Build) void { .{ .name = "flash-program", .file = "src/flash_program.zig" }, }; - var available_examples: std.array_list.Managed(Example) = .init(b.allocator); - available_examples.appendSlice(specific_examples) catch @panic("out of memory"); + var available_examples: std.ArrayList(Example) = .empty; + available_examples.appendSlice(b.allocator, specific_examples) catch @panic("out of memory"); for (chip_agnostic_examples) |example| { - available_examples.append(.{ + available_examples.append(b.allocator, .{ .target = raspberrypi.pico, .name = b.fmt("pico_{s}", .{example.name}), .file = example.file, .imports = example.imports, }) catch @panic("out of memory"); - available_examples.append(.{ + available_examples.append(b.allocator, .{ .target = raspberrypi.pico2_arm, .name = b.fmt("pico2_arm_{s}", .{example.name}), .file = example.file, @@ -125,7 +125,7 @@ pub fn build(b: *std.Build) void { }) catch @panic("out of memory"); if (example.works_with_riscv) { - available_examples.append(.{ + available_examples.append(b.allocator, .{ .target = raspberrypi.pico2_riscv, .name = b.fmt("pico2_riscv_{s}", .{example.name}), .file = example.file, @@ -154,7 +154,7 @@ pub fn build(b: *std.Build) void { }); // Import net module for some examples - if (std.mem.indexOf(u8, example.name, "_net-") != null) { + if (std.mem.find(u8, example.name, "_net-") != null) { const net_dep = b.dependency("net", .{ .target = b.resolveTargetQuery(fw.target.zig_target), .optimize = optimize, @@ -170,7 +170,7 @@ pub fn build(b: *std.Build) void { // Import freertos module for some examples, kind of a hack // probably list of required modules should be specified in each example independently - if (std.mem.indexOf(u8, example.name, "_freertos-") != null) { + if (std.mem.find(u8, example.name, "_freertos-") != null) { var port_name: []const u8 = "Unknown"; // FIXME: hacky way to select port based on target name (it doesn't take RP2350_RISCV into account) diff --git a/examples/raspberrypi/rp2xxx/src/board_id.zig b/examples/raspberrypi/rp2xxx/src/board_id.zig index 1c5ab22a0..5b3e450c4 100644 --- a/examples/raspberrypi/rp2xxx/src/board_id.zig +++ b/examples/raspberrypi/rp2xxx/src/board_id.zig @@ -17,7 +17,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/dma.zig b/examples/raspberrypi/rp2xxx/src/dma.zig index cb83fe190..70d607d61 100644 --- a/examples/raspberrypi/rp2xxx/src/dma.zig +++ b/examples/raspberrypi/rp2xxx/src/dma.zig @@ -28,7 +28,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/flash_program.zig b/examples/raspberrypi/rp2xxx/src/flash_program.zig index 68c35899f..ffc729d69 100644 --- a/examples/raspberrypi/rp2xxx/src/flash_program.zig +++ b/examples/raspberrypi/rp2xxx/src/flash_program.zig @@ -21,7 +21,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/net/tcp_client.zig b/examples/raspberrypi/rp2xxx/src/net/tcp_client.zig index ae034deac..558e31ddf 100644 --- a/examples/raspberrypi/rp2xxx/src/net/tcp_client.zig +++ b/examples/raspberrypi/rp2xxx/src/net/tcp_client.zig @@ -132,7 +132,7 @@ const Client = struct { // ref: https://github.com/lwip-tcpip/lwip/blob/6ca936f6b588cee702c638eee75c2436e6cf75de/src/include/lwip/opt.h#L1310 var buf: [net.lwip.TCP_SND_BUF + 128]u8 = @splat('-'); // add some header to the buf - _ = std.fmt.bufPrint( + _ = std.mem.print( &buf, "hello from rpi pi pico {}", .{self.send_count}, diff --git a/examples/raspberrypi/rp2xxx/src/rp2040_only/random.zig b/examples/raspberrypi/rp2xxx/src/rp2040_only/random.zig index 3b0f5d422..dbfe2a8d9 100644 --- a/examples/raspberrypi/rp2xxx/src/rp2040_only/random.zig +++ b/examples/raspberrypi/rp2xxx/src/rp2040_only/random.zig @@ -21,7 +21,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/ssd1306_oled.zig b/examples/raspberrypi/rp2xxx/src/ssd1306_oled.zig index 26f2fc60c..787230d39 100644 --- a/examples/raspberrypi/rp2xxx/src/ssd1306_oled.zig +++ b/examples/raspberrypi/rp2xxx/src/ssd1306_oled.zig @@ -49,7 +49,7 @@ pub fn main() void { var aa = std.heap.ArenaAllocator.init(fba.allocator()); defer aa.deinit(); var temp_buf: [7]u8 = undefined; - const str = std.fmt.bufPrint(&temp_buf, "Try #{}", .{i}) catch unreachable; + const str = std.mem.print(&temp_buf, "Try #{}", .{i}) catch unreachable; var counter_buf: [80]u8 = undefined; const text_centered = center_to_screen(&counter_buf, str); diff --git a/examples/raspberrypi/rp2xxx/src/stepper_driver.zig b/examples/raspberrypi/rp2xxx/src/stepper_driver.zig index e0d08747f..5d7e0ae70 100644 --- a/examples/raspberrypi/rp2xxx/src/stepper_driver.zig +++ b/examples/raspberrypi/rp2xxx/src/stepper_driver.zig @@ -18,7 +18,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/stepper_driver_dumb.zig b/examples/raspberrypi/rp2xxx/src/stepper_driver_dumb.zig index bb27f0b21..0f71445ce 100644 --- a/examples/raspberrypi/rp2xxx/src/stepper_driver_dumb.zig +++ b/examples/raspberrypi/rp2xxx/src/stepper_driver_dumb.zig @@ -18,7 +18,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/uart_log.zig b/examples/raspberrypi/rp2xxx/src/uart_log.zig index a271c066b..3dff1da5a 100644 --- a/examples/raspberrypi/rp2xxx/src/uart_log.zig +++ b/examples/raspberrypi/rp2xxx/src/uart_log.zig @@ -17,7 +17,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/raspberrypi/rp2xxx/src/usb_cdc.zig b/examples/raspberrypi/rp2xxx/src/usb_cdc.zig index edb307f0b..8ecbabf49 100644 --- a/examples/raspberrypi/rp2xxx/src/usb_cdc.zig +++ b/examples/raspberrypi/rp2xxx/src/usb_cdc.zig @@ -46,7 +46,7 @@ comptime { _ = microzig.export_startup(); } -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} @@ -106,7 +106,7 @@ var usb_tx_buff: [1024]u8 = undefined; /// NOTE: After each USB chunk transfer, we have to call the USB task so that bus TX events can be /// handled pub fn usb_cdc_write(serial: *USB_Serial, comptime fmt: []const u8, args: anytype) void { - var tx = std.fmt.bufPrint(&usb_tx_buff, fmt, args) catch &.{}; + var tx = std.mem.print(&usb_tx_buff, fmt, args) catch &.{}; while (tx.len > 0) { tx = tx[serial.write(tx)..]; diff --git a/examples/raspberrypi/rp2xxx/src/usb_hid.zig b/examples/raspberrypi/rp2xxx/src/usb_hid.zig index 90bc4d18e..e15480b61 100644 --- a/examples/raspberrypi/rp2xxx/src/usb_hid.zig +++ b/examples/raspberrypi/rp2xxx/src/usb_hid.zig @@ -138,7 +138,7 @@ var usb_controller: usb.DeviceController(.{ .reset = "", }}) = .init; -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); @breakpoint(); while (true) {} diff --git a/examples/texasinstruments/mspm0/build.zig b/examples/texasinstruments/mspm0/build.zig index d85880cc6..7cecc78e4 100644 --- a/examples/texasinstruments/mspm0/build.zig +++ b/examples/texasinstruments/mspm0/build.zig @@ -9,7 +9,7 @@ pub fn build(b: *std.Build) void { const mz_dep = b.dependency("microzig", .{}); const mb = MicroBuild.init(b, mz_dep) orelse return; - inline for (comptime std.meta.fieldNames(@TypeOf(mb.ports.mspm0.chips))) |field_name| { + inline for (comptime @typeInfo(@TypeOf(mb.ports.mspm0.chips)).@"struct".field_names) |field_name| { const target = @field(mb.ports.mspm0.chips, field_name); inline for ([_][]const u8{ diff --git a/examples/texasinstruments/mspm0/src/uart_log.zig b/examples/texasinstruments/mspm0/src/uart_log.zig index 79d143ec4..fbb0da9d5 100644 --- a/examples/texasinstruments/mspm0/src/uart_log.zig +++ b/examples/texasinstruments/mspm0/src/uart_log.zig @@ -2,7 +2,7 @@ const std = @import("std"); const microzig = @import("microzig"); const mspm0 = microzig.hal; -pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.lang.StackTrace, _: ?usize) noreturn { std.log.err("panic: {s}", .{message}); while (true) @breakpoint(); } diff --git a/examples/wch/ch32h/build.zig b/examples/wch/ch32h/build.zig index cba146ed0..98fc5f397 100644 --- a/examples/wch/ch32h/build.zig +++ b/examples/wch/ch32h/build.zig @@ -5,7 +5,7 @@ const MicroBuild = microzig.MicroBuild(.{ .ch32h = true, }); -fn add_example(b: *std.Build, mb: anytype, comptime name: []const u8, optimize: std.builtin.OptimizeMode) void { +fn add_example(b: *std.Build, mb: anytype, comptime name: []const u8, optimize: std.lang.Optimize) void { const v3f = mb.add_firmware(.{ .name = "v3f", .root_source_file = b.path("src/ch32h417_only/" ++ name ++ "_v3f.zig"), diff --git a/examples/wch/ch32v/src/usb_cdc.zig b/examples/wch/ch32v/src/usb_cdc.zig index 0854fdef2..67d056269 100644 --- a/examples/wch/ch32v/src/usb_cdc.zig +++ b/examples/wch/ch32v/src/usb_cdc.zig @@ -91,7 +91,7 @@ var usb_tx_buff: [1024]u8 = undefined; // Transfer data to host // NOTE: After each USB chunk transfer, we have to call the USB task so that bus TX events can be handled pub fn usb_cdc_write(serial: *USB_Serial, comptime fmt: []const u8, args: anytype) void { - const text = std.fmt.bufPrint(&usb_tx_buff, fmt, args) catch &.{}; + const text = std.mem.print(&usb_tx_buff, fmt, args) catch &.{}; var write_buff = text; while (write_buff.len > 0) { write_buff = write_buff[serial.write(write_buff)..]; diff --git a/modules/foundation-libc/src/libc.zig b/modules/foundation-libc/src/libc.zig index 5571bdf04..8cb03133e 100644 --- a/modules/foundation-libc/src/libc.zig +++ b/modules/foundation-libc/src/libc.zig @@ -53,7 +53,7 @@ pub fn undefined_behaviour(comptime string: []const u8) noreturn { } /// Zig panic handler, forwards panics to `foundation_libc_panic_handler`. -pub fn panic(msg: []const u8, maybe_error_return_trace: ?*std.builtin.StackTrace, maybe_return_address: ?usize) noreturn { +pub fn panic(msg: []const u8, maybe_error_return_trace: ?*std.lang.StackTrace, maybe_return_address: ?usize) noreturn { _ = maybe_error_return_trace; _ = maybe_return_address; h.foundation_libc_panic_handler(msg.ptr, msg.len); @@ -68,7 +68,7 @@ fn fallback_panic_handler(msg_ptr: [*]const u8, msg_len: usize) callconv(.c) nor } comptime { const ptr = &fallback_panic_handler; - @export(ptr, std.builtin.ExportOptions{ + @export(ptr, .{ .name = "foundation_libc_panic_handler", .linkage = .weak, .visibility = .default, diff --git a/modules/foundation-libc/src/modules/assert.zig b/modules/foundation-libc/src/modules/assert.zig index 436760ae0..c6601c6c6 100644 --- a/modules/foundation-libc/src/modules/assert.zig +++ b/modules/foundation-libc/src/modules/assert.zig @@ -9,7 +9,7 @@ export fn foundation_libc_assert( switch (builtin.mode) { .Debug, .ReleaseSafe => { var buf: [256]u8 = undefined; - const str = std.fmt.bufPrint(&buf, "assertion failed: '{?s}' in file {?s} line {}", .{ assertion, file, line }) catch { + const str = std.mem.print(&buf, "assertion failed: '{?s}' in file {?s} line {}", .{ assertion, file, line }) catch { @panic("assertion failed"); }; @panic(str); diff --git a/modules/foundation-libc/src/modules/string.zig b/modules/foundation-libc/src/modules/string.zig index 7deed946f..04d3b2717 100644 --- a/modules/foundation-libc/src/modules/string.zig +++ b/modules/foundation-libc/src/modules/string.zig @@ -46,7 +46,7 @@ export fn strlen(str: ?[*:0]const c_char) usize { export fn strnlen(str: ?[*:0]const u8, n: usize) usize { const s = str orelse return 0; - return if (std.mem.indexOfScalar(u8, s[0..n], 0)) |index| index else n; + return if (std.mem.findScalar(u8, s[0..n], 0)) |index| index else n; } /// https://en.cppreference.com/w/c/string/byte/strncmp diff --git a/modules/foundation-libc/test/build.zig b/modules/foundation-libc/test/build.zig index 67636aecb..035480b05 100644 --- a/modules/foundation-libc/test/build.zig +++ b/modules/foundation-libc/test/build.zig @@ -10,7 +10,7 @@ pub fn build(b: *Build) void { // Compile for huge amount of targets to detect breakage early on: for ([_]bool{ false, true }) |validation_single_threaded| { - for (std.enums.values(std.builtin.OptimizeMode)) |validation_optimize| { + for (std.enums.values(std.lang.Optimize)) |validation_optimize| { for (validation_target_list) |validation_target_query| { const validation_target = b.resolveTargetQuery(validation_target_query); diff --git a/modules/network/build.zig b/modules/network/build.zig index 93d26f85f..0618bcc52 100644 --- a/modules/network/build.zig +++ b/modules/network/build.zig @@ -82,5 +82,5 @@ pub fn build(b: *std.Build) void { } fn to_s(buf: []u8, value: usize) []const u8 { - return std.fmt.bufPrint(buf, "{d}", .{value}) catch @panic("insufficient to_s buffer"); + return std.mem.print(buf, "{d}", .{value}) catch @panic("insufficient to_s buffer"); } diff --git a/modules/network/src/root.zig b/modules/network/src/root.zig index af3a46969..2a401aa35 100644 --- a/modules/network/src/root.zig +++ b/modules/network/src/root.zig @@ -509,7 +509,7 @@ pub const Endpoint = struct { const ip4_addr: *const lwip.ip4_addr_t = @ptrCast(&self.addr); try writer.writeAll(std.mem.sliceTo(lwip.ip4addr_ntoa(ip4_addr), 0)); var buf: [16]u8 = undefined; - try writer.writeAll(std.fmt.bufPrint(&buf, ":{}", .{self.port}) catch ""); + try writer.writeAll(std.mem.print(&buf, ":{}", .{self.port}) catch ""); } pub fn parse(ip: []const u8, port: u16) !Endpoint { diff --git a/modules/rtt/src/rtt.zig b/modules/rtt/src/rtt.zig index b9ce179ed..dcffb20fb 100644 --- a/modules/rtt/src/rtt.zig +++ b/modules/rtt/src/rtt.zig @@ -425,7 +425,7 @@ fn BuildBufferStorageType(comptime up_channels: []const channel.Config, comptime const count = up_channels.len + down_channels.len; var field_names: [count][]const u8 = undefined; var field_types: [count]type = undefined; - var field_attrs: [count]std.builtin.Type.Struct.FieldAttributes = undefined; + var field_attrs: [count]std.lang.Type.Struct.FieldAttributes = undefined; var i: usize = 0; for (up_channels, 0..) |up_cfg, idx| { diff --git a/modules/virtual-io/src/root.zig b/modules/virtual-io/src/root.zig index c161a9c78..4b6941ffe 100644 --- a/modules/virtual-io/src/root.zig +++ b/modules/virtual-io/src/root.zig @@ -144,7 +144,7 @@ pub const File = struct { pub const Node = union(enum) { pub const ID = u16; pub const Kind = std.meta.Tag(Node); - pub const Map = std.AutoArrayHashMapUnmanaged(ID, Node); + pub const Map = std.array_hash_map.Auto(ID, Node); file: File, dir: Dir, diff --git a/port/espressif/esp/src/cpus/esp_riscv.zig b/port/espressif/esp/src/cpus/esp_riscv.zig index 618d9ce8d..2cebf0e8b 100644 --- a/port/espressif/esp/src/cpus/esp_riscv.zig +++ b/port/espressif/esp/src/cpus/esp_riscv.zig @@ -409,7 +409,7 @@ fn _vector_table() align(256) linksection(".ram_vectors") callconv(.naked) void var interrupt_jump_asm: []const u8 = ""; var interrupt_c_stubs_asm: []const u8 = ""; - for (std.meta.fieldNames(InterruptOptions)) |field_name| { + for (@typeInfo(InterruptOptions).@"struct".field_names) |field_name| { const handler: InterruptHandler = @field(microzig.options.interrupts, field_name) orelse .{ .c = &unhandled }; switch (handler) { .naked => |naked_handler| { diff --git a/port/espressif/esp/src/hal/atomic.zig b/port/espressif/esp/src/hal/atomic.zig index 32c3426bb..d493a904d 100644 --- a/port/espressif/esp/src/hal/atomic.zig +++ b/port/espressif/esp/src/hal/atomic.zig @@ -21,7 +21,7 @@ inline fn atomic_load(comptime T: type, ptr: *volatile T, _: i32) T { return ptr.*; } -inline fn atomic_rmw(comptime T: type, ptr: *volatile T, val: T, _: i32, comptime op: std.builtin.AtomicRmwOp) T { +inline fn atomic_rmw(comptime T: type, ptr: *volatile T, val: T, _: i32, comptime op: std.lang.AtomicRmwOp) T { const cs = microzig.interrupt.enter_critical_section(); defer cs.leave(); diff --git a/port/espressif/esp/src/hal/radio/osi.zig b/port/espressif/esp/src/hal/radio/osi.zig index ccb76349f..7609a5e0b 100644 --- a/port/espressif/esp/src/hal/radio/osi.zig +++ b/port/espressif/esp/src/hal/radio/osi.zig @@ -28,9 +28,9 @@ pub var wifi_interrupt_handler: ?struct { arg: ?*anyopaque, } = undefined; -extern fn vsnprintf(buffer: [*c]u8, len: usize, fmt: [*c]const u8, va_list: std.builtin.VaList) callconv(.c) void; +extern fn vsnprintf(buffer: [*c]u8, len: usize, fmt: [*c]const u8, va_list: std.lang.VaList) callconv(.c) void; -fn syslog(fmt: ?[*:0]const u8, va_list: std.builtin.VaList) callconv(.c) void { +fn syslog(fmt: ?[*:0]const u8, va_list: std.lang.VaList) callconv(.c) void { var buf: [512:0]u8 = undefined; vsnprintf(&buf, 512, fmt, va_list); log.debug("{s}", .{std.mem.span((&buf).ptr)}); @@ -46,7 +46,7 @@ pub fn strlen(str: ?[*:0]const u8) callconv(.c) usize { pub fn strnlen(str: ?[*:0]const u8, n: usize) callconv(.c) usize { const s = str orelse return 0; - return if (std.mem.indexOfScalar(u8, s[0..n], 0)) |index| index else n; + return if (std.mem.findScalar(u8, s[0..n], 0)) |index| index else n; } test "strnlen" { @@ -60,7 +60,7 @@ pub fn strrchr(str: ?[*:0]const u8, chr: u32) callconv(.c) ?[*:0]const u8 { // Should return even the index of the zero byte if requested. This // implementation only works with single byte characters. - if (std.mem.lastIndexOfScalar(u8, s[0 .. std.mem.len(s) + 1], @intCast(chr))) |index| { + if (std.mem.findScalarLast(u8, s[0 .. std.mem.len(s) + 1], @intCast(chr))) |index| { return @ptrFromInt(@intFromPtr(s) + index); } else { return null; diff --git a/port/gigadevice/gd32/src/hals/GD32VF103/pins.zig b/port/gigadevice/gd32/src/hals/GD32VF103/pins.zig index eb1056109..1a9edda78 100644 --- a/port/gigadevice/gd32/src/hals/GD32VF103/pins.zig +++ b/port/gigadevice/gd32/src/hals/GD32VF103/pins.zig @@ -94,7 +94,7 @@ pub fn Pins(comptime config: GlobalConfiguration) type { var field_names: [count][]const u8 = undefined; var field_types: [count]type = undefined; - var field_attrs: [count]std.builtin.Type.Struct.FieldAttributes = undefined; + var field_attrs: [count]std.lang.Type.Struct.FieldAttributes = undefined; var i: usize = 0; for (@typeInfo(GlobalConfiguration).@"struct".field_names) |port_field_name| { diff --git a/port/microchip/atmega/src/chips.zig b/port/microchip/atmega/src/chips.zig index 5bca1eef8..68a54eeb7 100644 --- a/port/microchip/atmega/src/chips.zig +++ b/port/microchip/atmega/src/chips.zig @@ -1,5 +1,5 @@ const std = @import("std"); fn root_dir() []const u8 { - return std.fs.path.dirname(@src().file) orelse "."; + return std.Io.Dir.path.dirname(@src().file) orelse "."; } diff --git a/port/nxp/lpc/src/hals/LPC176x5x.zig b/port/nxp/lpc/src/hals/LPC176x5x.zig index e503f8737..084a0937d 100644 --- a/port/nxp/lpc/src/hals/LPC176x5x.zig +++ b/port/nxp/lpc/src/hals/LPC176x5x.zig @@ -31,7 +31,7 @@ pub fn parse_pin(comptime spec: []const u8) type { if (spec[0] != 'P') @compileError(invalid_format_msg); - const index = std.mem.indexOfScalar(u8, spec, '.') orelse @compileError(invalid_format_msg); + const index = std.mem.findScalar(u8, spec, '.') orelse @compileError(invalid_format_msg); const _port: comptime_int = std.fmt.parseInt(u3, spec[1..index], 10) catch @compileError(invalid_format_msg); const _pin: comptime_int = std.fmt.parseInt(u5, spec[index + 1 ..], 10) catch @compileError(invalid_format_msg); diff --git a/port/nxp/mcx/src/mcxn947/scripts/generate.zig b/port/nxp/mcx/src/mcxn947/scripts/generate.zig index 2c400983a..9da58ecd0 100644 --- a/port/nxp/mcx/src/mcxn947/scripts/generate.zig +++ b/port/nxp/mcx/src/mcxn947/scripts/generate.zig @@ -38,9 +38,9 @@ pub fn print_fields(comptime ty: []const u8, comptime suffix_: ?[]const u8) []Fi inline for (0..4) |i| { const num: []const u8 = &[_]u8{comptime std.fmt.digitToChar(i, .lower)}; const T = @FieldType(peripherals.SYSCON0, ty ++ num).underlying_type; - inline for (comptime std.meta.fieldNames(T)) |name| { - if (comptime std.mem.indexOf(u8, name, "reserved") != null or std.mem.indexOf(u8, name, "padding") != null) continue; - const suf_i: ?usize = if (suffix_) |suffix| comptime std.mem.indexOf(u8, name, suffix) else name.len; + inline for (@typeInfo(T).@"struct".field_names) |name| { + if (comptime std.mem.find(u8, name, "reserved") != null or std.mem.find(u8, name, "padding") != null) continue; + const suf_i: ?usize = if (suffix_) |suffix| comptime std.mem.find(u8, name, suffix) else name.len; if (suf_i == null) @compileError("field doesn't have suffix"); fields_[len] = .{ .name = name[0..suf_i.?], .i = i, .offset = get_field_offset(T, name) }; max_len = @max(max_len, fields_[len].name.len); diff --git a/port/raspberrypi/rp2xxx/src/cpus/hazard3.zig b/port/raspberrypi/rp2xxx/src/cpus/hazard3.zig index 549cfa100..d00658ad7 100644 --- a/port/raspberrypi/rp2xxx/src/cpus/hazard3.zig +++ b/port/raspberrypi/rp2xxx/src/cpus/hazard3.zig @@ -30,7 +30,7 @@ pub const CoreInterrupt = enum(u5) { pub const ExternalInterrupt = microzig.utilities.GenerateInterruptEnum(u7); // NOTE: there is no way to use a custom incoming_stack_alignment with this way of doing things -const riscv_calling_convention: std.builtin.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; +const riscv_calling_convention: std.lang.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; pub const InterruptHandler = extern union { naked: *const fn () callconv(.naked) noreturn, diff --git a/port/raspberrypi/rp2xxx/src/hal/atomic.zig b/port/raspberrypi/rp2xxx/src/hal/atomic.zig index 1a49d0107..bd4a1b7bd 100644 --- a/port/raspberrypi/rp2xxx/src/hal/atomic.zig +++ b/port/raspberrypi/rp2xxx/src/hal/atomic.zig @@ -34,7 +34,7 @@ fn atomic_load(comptime T: type, ptr: *volatile T, _: i32) T { return val; } -fn atomic_rmw(comptime T: type, ptr: *volatile T, val: T, _: i32, comptime op: std.builtin.AtomicRmwOp) T { +fn atomic_rmw(comptime T: type, ptr: *volatile T, val: T, _: i32, comptime op: std.lang.AtomicRmwOp) T { const save = atomic_lock(); defer atomic_unlock(save); const tmp = ptr.*; diff --git a/port/raspberrypi/rp2xxx/src/hal/pins.zig b/port/raspberrypi/rp2xxx/src/hal/pins.zig index 95a6d7b70..193dde538 100644 --- a/port/raspberrypi/rp2xxx/src/hal/pins.zig +++ b/port/raspberrypi/rp2xxx/src/hal/pins.zig @@ -764,7 +764,7 @@ pub const GlobalConfiguration = struct { } pub fn PinsType(self: GlobalConfiguration) type { - const Attributes = std.builtin.Type.Struct.FieldAttributes; + const Attributes = std.lang.Type.Struct.FieldAttributes; var field_names: []const []const u8 = &.{}; var field_types: []const type = &.{}; diff --git a/port/raspberrypi/rp2xxx/src/hal/pio/assembler/Expression.zig b/port/raspberrypi/rp2xxx/src/hal/pio/assembler/Expression.zig index 64a6dd7f6..9663540ee 100644 --- a/port/raspberrypi/rp2xxx/src/hal/pio/assembler/Expression.zig +++ b/port/raspberrypi/rp2xxx/src/hal/pio/assembler/Expression.zig @@ -231,7 +231,7 @@ fn recursive_tokenize( } else { // if we hit this path, then the full string has been scanned, and no operators const trimmed = std.mem.trim(u8, expr_str, " \t"); - const value_index = expr_index + @as(u32, @intCast(std.mem.indexOf(u8, expr_str, trimmed).?)); + const value_index = expr_index + @as(u32, @intCast(std.mem.find(u8, expr_str, trimmed).?)); try ops.append(.{ .op = .value, .index = value_index, diff --git a/port/raspberrypi/rp2xxx/src/hal/pio/assembler/tokenizer.zig b/port/raspberrypi/rp2xxx/src/hal/pio/assembler/tokenizer.zig index dae1f775a..44e2ace56 100644 --- a/port/raspberrypi/rp2xxx/src/hal/pio/assembler/tokenizer.zig +++ b/port/raspberrypi/rp2xxx/src/hal/pio/assembler/tokenizer.zig @@ -2272,7 +2272,7 @@ test "tokenize.instr.comment with no whitespace" { test "format tokenizer" { const test_tokenizer = Tokenizer(.RP2040).init("out 1"); - const string = try std.fmt.allocPrint(std.testing.allocator, "{f}", .{test_tokenizer}); + const string = try std.testing.allocator.print("{f}", .{test_tokenizer}); defer std.testing.allocator.free(string); try expectEqualStrings( \\parser: diff --git a/port/raspberrypi/rp2xxx/src/hal/uart.zig b/port/raspberrypi/rp2xxx/src/hal/uart.zig index e5bd5ca69..a64f7daf8 100644 --- a/port/raspberrypi/rp2xxx/src/hal/uart.zig +++ b/port/raspberrypi/rp2xxx/src/hal/uart.zig @@ -257,7 +257,7 @@ pub const UART = enum(u1) { fn apply_internal(uart: UART, config: Config) void { const uart_regs = uart.get_regs(); const peri_freq = config.clock_config.peri.?.frequency(); - uart.set_baudrate(config.baud_rate, peri_freq); + uart.set_baudrate(config.baud_rate, peri_freq); // zlinter-disable-current-line no_deprecated uart.set_format(config.word_bits, config.stop_bits, config.parity); uart.set_flow_control(config.flow_control); uart_regs.UARTLCR_H.modify(.{ .FEN = 1 }); diff --git a/port/raspberrypi/rp2xxx/tools/rp2040-flash.zig b/port/raspberrypi/rp2xxx/tools/rp2040-flash.zig index 7c0cba8db..3640113e4 100644 --- a/port/raspberrypi/rp2xxx/tools/rp2040-flash.zig +++ b/port/raspberrypi/rp2xxx/tools/rp2040-flash.zig @@ -230,8 +230,8 @@ fn auto_detect_pico(allocator: std.mem.Allocator) !?[]const u8 { path: []const u8, }; - var picos = std.array_list.Managed(Device).init(allocator); - defer picos.deinit(); + var picos: std.ArrayList(Device) = .empty; + defer picos.deinit(allocator); var base_dir = try std.fs.openIterableDirAbsolute("/sys/block/", .{}); defer base_dir.close(); @@ -264,7 +264,7 @@ fn auto_detect_pico(allocator: std.mem.Allocator) !?[]const u8 { const device_id = std.mem.trim(u8, try dir.readFile("dev", &buffer), "\r\n\t "); - return try std.fs.path.join(allo, &.{ + return try std.Io.Dir.path.join(allo, &.{ "/dev/block", device_id, }); } @@ -278,7 +278,7 @@ fn auto_detect_pico(allocator: std.mem.Allocator) !?[]const u8 { }; if (maybe_device) |device_path| { - try picos.append(Device{ + try picos.append(allocator, .{ .name = try allocator.dupe(u8, entry.name), .path = device_path, }); diff --git a/port/stmicro/stm32/build.zig b/port/stmicro/stm32/build.zig index 28230cdcf..cd21f6f4b 100644 --- a/port/stmicro/stm32/build.zig +++ b/port/stmicro/stm32/build.zig @@ -87,7 +87,7 @@ pub fn init(dep: *std.Build.Dependency) ?Self { pub fn build(b: *std.Build) !void { const generate = b.option(bool, "generate", "") orelse false; if (generate) { - const stm32_data_generated = b.lazyDependency("stm32-data-generated", .{}) orelse return; + const stm32_data_generated = try b.dependencyLazy("stm32-data-generated", .{}); const generate_optimize: std.lang.Optimize = .safe; const regz_dep = b.dependency("microzig/tools/regz", .{ diff --git a/port/stmicro/stm32/src/generate.zig b/port/stmicro/stm32/src/generate.zig index c2d40699f..add8df86e 100644 --- a/port/stmicro/stm32/src/generate.zig +++ b/port/stmicro/stm32/src/generate.zig @@ -23,11 +23,11 @@ pub fn main(init: std.process.Init) !void { var data_dir = try package_dir.openDir(io, "data", .{}); defer data_dir.close(io); - var chip_files = std.array_list.Managed(std.json.Parsed(ChipFile)).init(allocator); + var chip_files: std.ArrayList(std.json.Parsed(ChipFile)) = .empty; defer { for (chip_files.items) |chip_file| chip_file.deinit(); - chip_files.deinit(); + chip_files.deinit(allocator); } var chips_dir = try data_dir.openDir(io, "chips", .{ .iterate = true }); @@ -57,7 +57,7 @@ pub fn main(init: std.process.Init) !void { }); errdefer chips_file.deinit(); - try chip_files.append(chips_file); + try chip_files.append(allocator, chips_file); } // sort to try to keep things somewhat in order @@ -121,7 +121,7 @@ fn generate_chips_file( var with_fpu = false; for (core.interrupts) |item| { - if (std.mem.indexOf(u8, item.name, "FPU")) |_| { + if (std.mem.find(u8, item.name, "FPU")) |_| { with_fpu = true; break; } @@ -178,8 +178,8 @@ fn generate_chips_file( ); { - var chip_memory = try std.array_list.Managed(ChipFile.Memory).initCapacity(allocator, chip_file.memory.len); - defer chip_memory.deinit(); + var chip_memory: std.ArrayList(ChipFile.Memory) = try .initCapacity(allocator, chip_file.memory.len); + defer chip_memory.deinit(allocator); // Some flash bank regions are not merged so we better do that. // Flash memory names are formated as: BANK_{id}_REGION_{id}. diff --git a/port/stmicro/stm32/src/hals/STM32F103/pins.zig b/port/stmicro/stm32/src/hals/STM32F103/pins.zig index b6d05e6b4..0bc9cd072 100644 --- a/port/stmicro/stm32/src/hals/STM32F103/pins.zig +++ b/port/stmicro/stm32/src/hals/STM32F103/pins.zig @@ -80,10 +80,10 @@ pub fn GPIO(comptime port: u3, comptime num: u4, comptime mode: gpio.Mode) type } pub fn Pins(comptime config: GlobalConfiguration) type { - const Attributes = std.builtin.Type.Struct.FieldAttributes; + const Attributes = std.lang.Type.Struct.FieldAttributes; var field_names: []const []const u8 = &.{}; var field_types: []const type = &.{}; - var field_attrs: []const std.builtin.Type.Struct.FieldAttributes = &.{}; + var field_attrs: []const std.lang.Type.Struct.FieldAttributes = &.{}; for (@typeInfo(GlobalConfiguration).@"struct".field_names) |port_field_name| { if (@field(config, port_field_name)) |port_config| { for (@typeInfo(Port.Configuration).@"struct".field_names) |field_name| { diff --git a/port/stmicro/stm32/src/hals/STM32F103/util.zig b/port/stmicro/stm32/src/hals/STM32F103/util.zig index 6c138e2cb..539e081ec 100644 --- a/port/stmicro/stm32/src/hals/STM32F103/util.zig +++ b/port/stmicro/stm32/src/hals/STM32F103/util.zig @@ -5,7 +5,7 @@ pub fn find_clock_tree(comptime name: []const u8) type { //ALL F1 peri const F105_7 = @import("clocks/clock_stm32f105.zig"); - if (std.mem.indexOf(u8, name, "105")) |_| return F105_7; - if (std.mem.indexOf(u8, name, "107")) |_| return F105_7; + if (std.mem.find(u8, name, "105")) |_| return F105_7; + if (std.mem.find(u8, name, "107")) |_| return F105_7; return F103; } diff --git a/port/stmicro/stm32/src/hals/common/pins_v2.zig b/port/stmicro/stm32/src/hals/common/pins_v2.zig index 81b0d5f9a..1687353c8 100644 --- a/port/stmicro/stm32/src/hals/common/pins_v2.zig +++ b/port/stmicro/stm32/src/hals/common/pins_v2.zig @@ -315,7 +315,7 @@ pub fn Pins(comptime config: GlobalConfiguration) type { var field_names: [count][]const u8 = undefined; var field_types: [count]type = undefined; - var field_attrs: [count]std.builtin.Type.Struct.FieldAttributes = undefined; + var field_attrs: [count]std.lang.Type.Struct.FieldAttributes = undefined; var i: usize = 0; for (@typeInfo(GlobalConfiguration).@"struct".field_names, @typeInfo(GlobalConfiguration).@"struct".field_types) |port_field_name, port_field_type| { if (port_field_type != ?PortConfiguration) { diff --git a/port/stmicro/stm32/src/hals/common/util.zig b/port/stmicro/stm32/src/hals/common/util.zig index 8125cd2f9..26a8b09e3 100644 --- a/port/stmicro/stm32/src/hals/common/util.zig +++ b/port/stmicro/stm32/src/hals/common/util.zig @@ -8,7 +8,7 @@ pub fn has_port(comptime id: u8) bool { pub fn match_name(heystack: []const u8, needles: []const []const u8) bool { for (needles) |needle| { - if (std.mem.indexOf(u8, heystack, needle)) |_| { + if (std.mem.find(u8, heystack, needle)) |_| { return true; } } @@ -38,7 +38,7 @@ pub fn sub_peripheral_enum(comptime T: type, comptime keep_name: []const []const if (match_name(field_name, keep_name)) { if (match_type) |match| { const type_name = @typeName(@TypeOf(@field(peripherals, field_name))); - _ = std.mem.indexOf(u8, type_name, match) orelse continue; + _ = std.mem.find(u8, type_name, match) orelse continue; } field_names = field_names ++ .{field_name}; diff --git a/port/texasinstruments/msp430/build.zig b/port/texasinstruments/msp430/build.zig index a59f737a2..d01d01f3f 100644 --- a/port/texasinstruments/msp430/build.zig +++ b/port/texasinstruments/msp430/build.zig @@ -37,10 +37,10 @@ pub fn init(dep: *std.Build.Dependency) ?Self { }; } -pub fn build(b: *std.Build) void { +pub fn build(b: *std.Build) !void { const generate = b.option(bool, "generate", "") orelse false; if (generate) { - const ti_data = b.lazyDependency("ti_data", .{}) orelse return; + const ti_data = try b.dependencyLazy("ti_data", .{}); const targetdb = ti_data.path("targetdb"); const generate_optimize: std.lang.Optimize = .safe; diff --git a/port/texasinstruments/mspm0/src/hal/Uart.zig b/port/texasinstruments/mspm0/src/hal/Uart.zig index 733c2576f..2dbeb9bbb 100644 --- a/port/texasinstruments/mspm0/src/hal/Uart.zig +++ b/port/texasinstruments/mspm0/src/hal/Uart.zig @@ -176,9 +176,9 @@ pub fn log( fn RegFieldType(register_name: []const u8, field_name: []const u8) type { const reg_idx = std.meta.fieldIndex(peri_types.uart0, register_name) orelse @compileError("No register " ++ register_name ++ " in uart0."); - const Reg = std.meta.fieldTypes(peri_types.uart0)[reg_idx].underlying_type; + const Reg = @typeInfo(peri_types.uart0).@"struct".field_types[reg_idx].underlying_type; const fld_idx = std.meta.fieldIndex(Reg, field_name) orelse @compileError("No field " ++ field_name ++ " in uart0." ++ register_name ++ "."); - return std.meta.fieldTypes(Reg)[fld_idx]; + return @typeInfo(Reg).@"struct".field_types[fld_idx]; } diff --git a/port/texasinstruments/tm4c/build.zig b/port/texasinstruments/tm4c/build.zig index b4cee384b..e32996b45 100644 --- a/port/texasinstruments/tm4c/build.zig +++ b/port/texasinstruments/tm4c/build.zig @@ -29,10 +29,10 @@ pub fn init(dep: *std.Build.Dependency) ?Self { }; } -pub fn build(b: *std.Build) void { +pub fn build(b: *std.Build) !void { const generate = b.option(bool, "generate", "") orelse false; if (generate) { - const ti_data = b.lazyDependency("ti_data", .{}) orelse return; + const ti_data = try b.dependencyLazy("ti_data", .{}); const targetdb = ti_data.path("targetdb"); const generate_optimize: std.lang.Optimize = .safe; diff --git a/port/wch/ch32h/src/cpus/main.zig b/port/wch/ch32h/src/cpus/main.zig index da4cd241b..574c33bc8 100644 --- a/port/wch/ch32h/src/cpus/main.zig +++ b/port/wch/ch32h/src/cpus/main.zig @@ -20,7 +20,7 @@ pub const cpu_name: CpuName = std.meta.stringToEnum(CpuName, microzig.config.cpu // Interrupt pub const Interrupt = cpu_impl.Interrupt; -pub const riscv_calling_convention: std.builtin.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; +pub const riscv_calling_convention: std.lang.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; pub const Exception = enum(u32) { InstructionMisaligned = 0x0, InstructionFault = 0x1, diff --git a/port/wch/ch32v/src/cpus/main.zig b/port/wch/ch32v/src/cpus/main.zig index 0cee05c35..519726661 100644 --- a/port/wch/ch32v/src/cpus/main.zig +++ b/port/wch/ch32v/src/cpus/main.zig @@ -20,7 +20,7 @@ pub const cpu_name: CpuName = std.meta.stringToEnum(CpuName, microzig.config.cpu // Interrupt pub const Interrupt = cpu_impl.Interrupt; -pub const riscv_calling_convention: std.builtin.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; +pub const riscv_calling_convention: std.lang.CallingConvention = .{ .riscv32_interrupt = .{ .mode = .machine } }; pub const Exception = enum(u32) { InstructionMisaligned = 0x0, InstructionFault = 0x1, diff --git a/port/wch/ch32v/src/hals/ch32v003/pins.zig b/port/wch/ch32v/src/hals/ch32v003/pins.zig index 821636867..27b671798 100644 --- a/port/wch/ch32v/src/hals/ch32v003/pins.zig +++ b/port/wch/ch32v/src/hals/ch32v003/pins.zig @@ -83,7 +83,7 @@ fn get_tag_name_by_index(comptime T: type, comptime index: usize) []const u8 { } pub fn Pins(comptime config: GlobalConfiguration) type { - const Attributes = std.builtin.Type.Struct.FieldAttributes; + const Attributes = std.lang.Type.Struct.FieldAttributes; var field_names: []const []const u8 = &.{}; var field_types: []const type = &.{}; var field_attrs: []const Attributes = &.{}; diff --git a/port/wch/ch32v/src/hals/pins.zig b/port/wch/ch32v/src/hals/pins.zig index 1852f49e4..3b36b59e6 100644 --- a/port/wch/ch32v/src/hals/pins.zig +++ b/port/wch/ch32v/src/hals/pins.zig @@ -91,7 +91,7 @@ fn get_tag_name_by_index(comptime T: type, comptime index: usize) []const u8 { } pub fn Pins(comptime config: GlobalConfiguration) type { - const Attributes = std.builtin.Type.Struct.FieldAttributes; + const Attributes = std.lang.Type.Struct.FieldAttributes; var field_names: []const []const u8 = &.{}; var field_types: []const type = &.{}; diff --git a/sim/aviron/build.zig b/sim/aviron/build.zig index 7493d1211..719b15fbf 100644 --- a/sim/aviron/build.zig +++ b/sim/aviron/build.zig @@ -114,7 +114,7 @@ fn add_test_suite( debug_step: *Build.Step, host_target: ResolvedTarget, avr_target: ResolvedTarget, - optimize: std.builtin.OptimizeMode, + optimize: std.lang.Optimize, aviron_module: *Build.Module, flags_module: *Build.Module, ) !void { @@ -193,7 +193,7 @@ fn add_test_suite( .json = .ignore, }; - const ext = std.fs.path.extension(entry.basename); + const ext = std.Io.Dir.path.extension(entry.basename); const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".field_names) |field_name| { const action: FileAction = @field(extension_to_action, field_name); @@ -227,7 +227,7 @@ fn add_test_suite( else avr_target; - const file_ext = std.fs.path.extension(entry.path); + const file_ext = std.Io.Dir.path.extension(entry.path); const is_zig_test = std.mem.eql(u8, file_ext, ".zig"); const is_c_test = std.mem.eql(u8, file_ext, ".c"); const is_asm_test = std.mem.eql(u8, file_ext, ".S"); @@ -241,7 +241,7 @@ fn add_test_suite( b.path("testsuite/dummy.zig"); const test_payload = b.addExecutable(.{ - .name = std.fs.path.stem(entry.basename), + .name = std.Io.Dir.path.stem(entry.basename), .root_module = b.createModule(.{ .root_source_file = if (is_zig_test) root_file else null, .target = custom_target, @@ -279,8 +279,8 @@ fn add_test_suite( debug_step.dependOn(&b.addInstallFile( test_payload.getEmittedBin(), b.fmt("testsuite/{s}/{s}.elf", .{ - std.fs.path.dirname(entry.path).?, - std.fs.path.stem(entry.basename), + std.Io.Dir.path.dirname(entry.path).?, + std.Io.Dir.path.stem(entry.basename), }), ).step); @@ -308,14 +308,14 @@ fn add_test_suite( }; const write_file = b.addWriteFile( - b.fmt("test-config-{s}.json", .{std.fs.path.stem(entry.basename)}), + b.fmt("test-config-{s}.json", .{std.Io.Dir.path.stem(entry.basename)}), cae.config.to_string(b), ); const test_run = b.addRunArtifact(testrunner_exe); test_run.addPrefixedFileArg("--config=", write_file.getDirectory().path(b, b.fmt( "test-config-{s}.json", - .{std.fs.path.stem(entry.basename)}, + .{std.Io.Dir.path.stem(entry.basename)}, ))); test_run.addArg(b.fmt("--name={s}", .{entry.path})); @@ -363,7 +363,7 @@ fn add_test_suite_update( .md = .ignore, }; - const ext = std.fs.path.extension(entry.basename); + const ext = std.Io.Dir.path.extension(entry.basename); const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".field_names) |field_name| { const action: FileAction = @field(extension_to_action, field_name); if (std.mem.eql(u8, ext, "." ++ field_name)) @@ -403,7 +403,7 @@ fn add_test_suite_update( json_write.addFileArg(temp_json.getDirectory().path(b, "temp.json")); json_write.addArg(b.fmt( "testsuite/{s}/{s}{s}.elf.json", - .{ std.fs.path.dirname(entry.path).?, std.fs.path.stem(entry.basename), json_suffix }, + .{ std.Io.Dir.path.dirname(entry.path).?, std.Io.Dir.path.stem(entry.basename), json_suffix }, )); json_write.step.dependOn(&temp_json.step); @@ -411,7 +411,7 @@ fn add_test_suite_update( const gcc_invocation = Build.Step.Run.create(b, b.fmt("compile elf for {s}", .{cpu})); gcc_invocation.addFileArg(avr_gcc); gcc_invocation.addArg("-o"); - gcc_invocation.addArg(b.fmt("testsuite/{s}/{s}{s}.elf", .{ std.fs.path.dirname(entry.path).?, std.fs.path.stem(entry.basename), json_suffix })); + gcc_invocation.addArg(b.fmt("testsuite/{s}/{s}{s}.elf", .{ std.Io.Dir.path.dirname(entry.path).?, std.Io.Dir.path.stem(entry.basename), json_suffix })); gcc_invocation.addArg(b.fmt("-mmcu={s}", .{cpu})); for (config.gcc_flags) |opt| { gcc_invocation.addArg(opt); @@ -425,7 +425,7 @@ fn add_test_suite_update( const objcopy = Build.Step.Run.create(b, b.fmt("strip locals for {s}", .{cpu})); objcopy.addArg("avr-objcopy"); objcopy.addArg("--strip-unneeded"); - objcopy.addArg(b.fmt("testsuite/{s}/{s}{s}.elf", .{ std.fs.path.dirname(entry.path).?, std.fs.path.stem(entry.basename), json_suffix })); + objcopy.addArg(b.fmt("testsuite/{s}/{s}{s}.elf", .{ std.Io.Dir.path.dirname(entry.path).?, std.Io.Dir.path.stem(entry.basename), json_suffix })); objcopy.step.dependOn(&gcc_invocation.step); invoke_step.dependOn(&json_write.step); @@ -438,8 +438,8 @@ fn add_test_suite_update( fn parse_test_suite_config(b: *Build, file: std.Io.File) !TestSuiteConfig { const io = b.graph.io; - var code = std.array_list.Managed(u8).init(b.allocator); - defer code.deinit(); + var code: std.ArrayList(u8) = .empty; + defer code.deinit(b.allocator); var read_buf: [4096]u8 = undefined; var file_reader = file.reader(io, &read_buf); @@ -449,8 +449,8 @@ fn parse_test_suite_config(b: *Build, file: std.Io.File) !TestSuiteConfig { const comment_prefix = "//!"; const line = try reader.takeDelimiter('\n') orelse break; if (std.mem.startsWith(u8, line, comment_prefix)) { - try code.appendSlice(line[comment_prefix.len..]); - try code.appendSlice("\n"); + try code.appendSlice(b.allocator, line[comment_prefix.len..]); + try code.appendSlice(b.allocator, "\n"); } } diff --git a/sim/aviron/src/lib/decoder.zig b/sim/aviron/src/lib/decoder.zig index 1d83d212f..7c82e3eb2 100644 --- a/sim/aviron/src/lib/decoder.zig +++ b/sim/aviron/src/lib/decoder.zig @@ -28,7 +28,7 @@ pub fn decode(inst_val: u16) !Instruction { const Bitsets = @Tuple(types: { var bs_types: [positionals.len]type = undefined; for (positionals, 0..) |pos, i| { - bs_types[i] = std.bit_set.IntegerBitSet(pos[1].len); + bs_types[i] = std.bit_set.Integer(pos[1].len); } break :types &bs_types; }); @@ -38,7 +38,7 @@ pub fn decode(inst_val: u16) !Instruction { bs.* = .empty; } - var bitset: std.bit_set.IntegerBitSet(16) = .empty; + var bitset: std.bit_set.Integer(16) = .empty; bitset.mask = @bitReverse(inst_val); var result: Result = undefined; diff --git a/sim/aviron/src/testconfig.zig b/sim/aviron/src/testconfig.zig index f710fd3ba..b30dbe870 100644 --- a/sim/aviron/src/testconfig.zig +++ b/sim/aviron/src/testconfig.zig @@ -70,7 +70,7 @@ pub const TestSuiteConfig = struct { cpu: ?[]const u8 = null, cpus: ?[][]const u8 = null, // Alternative to cpu: run test against multiple MCUs - optimize: std.builtin.OptimizeMode = .small, + optimize: std.lang.Optimize = .small, gcc_flags: []const []const u8 = &.{ "-g", diff --git a/sim/aviron/src/testrunner.zig b/sim/aviron/src/testrunner.zig index ad85b0270..abc16988f 100644 --- a/sim/aviron/src/testrunner.zig +++ b/sim/aviron/src/testrunner.zig @@ -67,10 +67,10 @@ fn run_test( var flash_storage = aviron.Flash.Static(mcu_config.flash_size){}; var sram = aviron.FixedSizeMemory(mcu_config.sram_size, .{ .address_type = u24 }){}; - var stdout = std.array_list.Managed(u8).init(gpa); + var stdout = std.array_list.Managed(u8).init(gpa); // zlinter-disable-current-line no_deprecated defer stdout.deinit(); - var stderr = std.array_list.Managed(u8).init(gpa); + var stderr = std.array_list.Managed(u8).init(gpa); // zlinter-disable-current-line no_deprecated defer stderr.deinit(); var io = IO{ @@ -325,8 +325,8 @@ const IO = struct { ramp_d: u8 = 0, e_ind: u8 = 0, - stdout: *std.array_list.Managed(u8), - stderr: *std.array_list.Managed(u8), + stdout: *std.array_list.Managed(u8), // zlinter-disable-current-line no_deprecated + stderr: *std.array_list.Managed(u8), // zlinter-disable-current-line no_deprecated stdin: []const u8, diff --git a/sim/aviron/tools/generate_tables.zig b/sim/aviron/tools/generate_tables.zig index a118a1d33..2a8c69ef3 100644 --- a/sim/aviron/tools/generate_tables.zig +++ b/sim/aviron/tools/generate_tables.zig @@ -28,12 +28,12 @@ pub fn main(init: std.process.Init) !void { var lut: [std.math.maxInt(u16) + 1]isa.Opcode = @splat(.unknown); - var base_number_bit_set: std.bit_set.IntegerBitSet(16) = .empty; + var base_number_bit_set: std.bit_set.Integer(16) = .empty; var unknown_indices = try BoundedArray(u8, 16).init(0); - var unknown_indices_bit_set: std.bit_set.IntegerBitSet(16) = .empty; - var result_bit_set: std.bit_set.IntegerBitSet(16) = .empty; + var unknown_indices_bit_set: std.bit_set.Integer(16) = .empty; + var result_bit_set: std.bit_set.Integer(16) = .empty; - var positionals = std.enums.EnumArray(isa.Opcode, std.AutoArrayHashMapUnmanaged(u8, BoundedArray(u8, 16))).initFill(.{}); + var positionals = std.enums.EnumArray(isa.Opcode, std.array_hash_map.Auto(u8, BoundedArray(u8, 16))).initFill(.{}); defer for (&positionals.values) |*map| { map.deinit(gpa); }; @@ -113,12 +113,12 @@ pub fn main(init: std.process.Init) !void { } }; - var items = std.array_list.Managed(BitSet).init(gpa); - defer items.deinit(); + var items: std.ArrayList(BitSet) = .empty; + defer items.deinit(gpa); var it = map.iterator(); while (it.next()) |entry| { - try items.append(.{ + try items.append(gpa, .{ .name = entry.key_ptr.*, .count = entry.value_ptr.*.slice().len, }); diff --git a/tools/esp-image/src/elf2image.zig b/tools/esp-image/src/elf2image.zig index 7c0e5fe58..ea16d55b3 100644 --- a/tools/esp-image/src/elf2image.zig +++ b/tools/esp-image/src/elf2image.zig @@ -75,7 +75,7 @@ pub fn main(init: std.process.Init) !void { var flash_mmu_page_size: Flash_MMU_PageSize = esp_image.DEFAULT_FLASH_MMU_PAGE_SIZE; if (cli_args.flash_mmu_page_size) |page_size_override| { if (chip.supported_flash_mmu_page_sizes) |supported_flash_mmu_page_sizes| { - if (std.mem.indexOfScalar(Flash_MMU_PageSize, supported_flash_mmu_page_sizes, page_size_override) != null) { + if (std.mem.findScalar(Flash_MMU_PageSize, supported_flash_mmu_page_sizes, page_size_override) != null) { flash_mmu_page_size = page_size_override; } else { std.log.err("flash mmu page size `{t}` is not supported by chip `{t}`... using default `{t}`", .{ @@ -133,7 +133,7 @@ pub fn main(init: std.process.Init) !void { } else { var it = elf_header.iterateSectionHeaders(&elf_file_reader); while (try it.next()) |hdr| { - if (hdr.sh_type == std.elf.SHT_PROGBITS and hdr.sh_flags & std.elf.SHF_ALLOC != 0 and hdr.sh_size > 0) { + if (hdr.sh_type == @backingInt(std.elf.SHT.PROGBITS) and hdr.sh_flags & std.elf.SHF_ALLOC != 0 and hdr.sh_size > 0) { try info_list.append(gpa, .{ .addr = @as(u32, @intCast(hdr.sh_addr)), .file_offset = @as(u32, @intCast(hdr.sh_offset)), diff --git a/tools/generate_linker_script.zig b/tools/generate_linker_script.zig index 5cc7cfe17..f7851c8e9 100644 --- a/tools/generate_linker_script.zig +++ b/tools/generate_linker_script.zig @@ -57,7 +57,7 @@ pub fn main(init: std.process.Init) !void { if (region.name) |name| { region_name.* = try allocator.dupe(u8, name); } else { - region_name.* = try std.fmt.allocPrint(allocator, "{s}{}", .{ + region_name.* = try allocator.print("{s}{}", .{ @tagName(region.tag), counters[@backingInt(region.tag)], }); @@ -248,7 +248,7 @@ pub fn main(init: std.process.Init) !void { \\ , .{ if (!parsed_args.ram_image) - try std.fmt.allocPrint(allocator, "{s} AT> {s}", .{ ram_region_name, flash_region_name }) + try allocator.print("{s} AT> {s}", .{ ram_region_name, flash_region_name }) else ram_region_name, ram_region_name, diff --git a/tools/linter/src/main.zig b/tools/linter/src/main.zig index a810571d6..051cf8286 100644 --- a/tools/linter/src/main.zig +++ b/tools/linter/src/main.zig @@ -34,7 +34,7 @@ pub fn main(init: std.process.Init) !void { if (is_camel_case(identifier_str) and !is_snake_case(identifier_str)) { const snake_case = try camel_to_snake(allocator, identifier_str); const location = ast.tokenLocation(0, identifier_tok); - const message = try std.fmt.allocPrint(allocator, "Please change to `{s}`, in MicroZig we use snake case for function names.", .{ + const message = try allocator.print("Please change to `{s}`, in MicroZig we use snake case for function names.", .{ snake_case, }); @@ -57,7 +57,7 @@ pub fn main(init: std.process.Init) !void { if (try should_transform_typename(allocator, identifier_str)) |typename| { try issues.append(allocator, .{ .line = @intCast(location.line + 1), - .message = try std.fmt.allocPrint(allocator, "Suggestion: Rename `{s}` to `{s}`, " ++ + .message = try allocator.print("Suggestion: Rename `{s}` to `{s}`, " ++ "it _should_ be more in line with our [style guidelines](https://microzig.tech/docs/contributing/). " ++ "This automation is not perfect so take it with a grain of salt.", .{ identifier_str, typename }), .file = path, @@ -575,12 +575,12 @@ pub fn check_todos( allocator: Allocator, path: []const u8, source: []const u8, - issues: *std.ArrayListUnmanaged(Issue), + issues: *std.ArrayListUnmanaged(Issue), // zlinter-disable-current-line no_deprecated ) !void { var line_num: u32 = 1; var it = std.mem.splitScalar(u8, source, '\n'); while (it.next()) |line| : (line_num += 1) { - const comment_start = std.mem.indexOf(u8, line, "//") orelse continue; + const comment_start = std.mem.find(u8, line, "//") orelse continue; const comment = line[comment_start..]; if (contains_todo_keyword(comment) and !contains_link(comment)) { try issues.append(allocator, .{ @@ -594,12 +594,12 @@ pub fn check_todos( /// Checks if a string contains a link (URL). fn contains_link(text: []const u8) bool { - return std.mem.indexOf(u8, text, "https://github.com/ZigEmbeddedGroup/microzig/issues") != null; + return std.mem.find(u8, text, "https://github.com/ZigEmbeddedGroup/microzig/issues") != null; } fn contains_todo_keyword(text: []const u8) bool { return for (uppercase_todo_keywords) |keyword| { - if (std.mem.indexOf(u8, text, keyword) != null) + if (std.mem.find(u8, text, keyword) != null) break true; } else false; } diff --git a/tools/parts_db.zig b/tools/parts_db.zig index aad821c34..5422b0474 100644 --- a/tools/parts_db.zig +++ b/tools/parts_db.zig @@ -19,8 +19,8 @@ pub fn main() !void { const output_path = args[1]; - var chips = std.array_list.Managed(MicroZig.Chip).init(allocator); - var boards = std.array_list.Managed(MicroZig.Board).init(allocator); + var chips: std.ArrayList(MicroZig.Chip) = .empty; + var boards: std.ArrayList(MicroZig.Board) = .empty; inline for (port) |port| {} const json_str = std.json.stringifyAlloc(b.allocator, parts_db, .{}) catch @panic("OOM"); diff --git a/tools/printer/src/DebugInfo.zig b/tools/printer/src/DebugInfo.zig index e78e063cb..0c2cbfc42 100644 --- a/tools/printer/src/DebugInfo.zig +++ b/tools/printer/src/DebugInfo.zig @@ -780,7 +780,7 @@ const Parser = struct { } }; - fn read_address(reader: *std.Io.Reader, dwarf_format: dwarf.Format, endian: std.builtin.Endian) !u64 { + fn read_address(reader: *std.Io.Reader, dwarf_format: dwarf.Format, endian: std.lang.Endian) !u64 { return switch (dwarf_format) { .@"32" => try reader.takeInt(u32, endian), .@"64" => try reader.takeInt(u64, endian), diff --git a/tools/printer/src/Elf.zig b/tools/printer/src/Elf.zig index 86f9f789b..a14def553 100644 --- a/tools/printer/src/Elf.zig +++ b/tools/printer/src/Elf.zig @@ -2,7 +2,7 @@ const std = @import("std"); const Elf = @This(); -endian: std.builtin.Endian, +endian: std.lang.Endian, format: Format, sections: Sections, loaded_regions: []const Region, @@ -41,33 +41,33 @@ pub fn init(allocator: std.mem.Allocator, file_reader: *std.Io.File.Reader) !Elf const format: Format = if (elf_header.is_64) .@"64" else .@"32"; const string_table_data = blk: { - var shdr: std.elf.Elf64_Shdr = undefined; + var shdr: std.elf.Elf64.Shdr = undefined; if (format == .@"32") { - // var shdr32: std.elf.Elf32_Shdr = undefined; - const offset = elf_header.shoff + @sizeOf(std.elf.Elf32_Shdr) * elf_header.shstrndx; + // var shdr32: std.elf.Elf32.Shdr = undefined; + const offset = elf_header.shoff + @sizeOf(std.elf.Elf32.Shdr) * elf_header.shstrndx; try file_reader.seekTo(offset); - const shdr32 = try file_reader.interface.takeStruct(std.elf.Elf32_Shdr, elf_header.endian); + const shdr32 = try file_reader.interface.takeStruct(std.elf.Elf32.Shdr, elf_header.endian); shdr = .{ - .sh_name = shdr32.sh_name, - .sh_type = shdr32.sh_type, - .sh_flags = shdr32.sh_flags, - .sh_addr = shdr32.sh_addr, - .sh_offset = shdr32.sh_offset, - .sh_size = shdr32.sh_size, - .sh_link = shdr32.sh_link, - .sh_info = shdr32.sh_info, - .sh_addralign = shdr32.sh_addralign, - .sh_entsize = shdr32.sh_entsize, + .name = shdr32.name, + .type = shdr32.type, + .flags = .{ .shf = shdr32.flags.shf }, + .addr = shdr32.addr, + .offset = shdr32.offset, + .size = shdr32.size, + .link = shdr32.link, + .info = shdr32.info, + .addralign = shdr32.addralign, + .entsize = shdr32.entsize, }; } else { - const offset = elf_header.shoff + @sizeOf(std.elf.Elf64_Shdr) * elf_header.shstrndx; + const offset = elf_header.shoff + @sizeOf(std.elf.Elf64.Shdr) * elf_header.shstrndx; try file_reader.seekTo(offset); - shdr = try file_reader.interface.takeStruct(std.elf.Elf64_Shdr, elf_header.endian); + shdr = try file_reader.interface.takeStruct(std.elf.Elf64.Shdr, elf_header.endian); } - try file_reader.seekTo(shdr.sh_offset); - break :blk try file_reader.interface.readAlloc(allocator, shdr.sh_size); + try file_reader.seekTo(shdr.offset); + break :blk try file_reader.interface.readAllocAll(allocator, shdr.size); }; defer allocator.free(string_table_data); @@ -87,7 +87,7 @@ pub fn init(allocator: std.mem.Allocator, file_reader: *std.Io.File.Reader) !Elf if (std.mem.eql(u8, name, section_field_name)) { try file_reader.seekTo(shdr.sh_offset); - const section_data = try file_reader.interface.readAlloc(allocator, shdr.sh_size); + const section_data = try file_reader.interface.readAllocAll(allocator, shdr.sh_size); errdefer allocator.free(section_data); sections.put(@fromBackingInt(section_field_value), section_data); diff --git a/tools/printer/src/root.zig b/tools/printer/src/root.zig index 553206451..2461164f6 100644 --- a/tools/printer/src/root.zig +++ b/tools/printer/src/root.zig @@ -38,7 +38,7 @@ fn output_line( ) !void { try terminal.writer.writeAll(line); - const prefix_index = std.mem.indexOf(u8, line, "0x") orelse return; + const prefix_index = std.mem.find(u8, line, "0x") orelse return; var after_prefix = line[prefix_index + 2 ..]; var hex_digit_count: u32 = 0; @@ -71,7 +71,7 @@ fn output_location_info( if (query_result.source_location) |src_loc| { try terminal.writer.print("{f}:{}:{}", .{ - std.fs.path.fmtJoin(&.{ src_loc.dir_path, src_loc.file_path }), + std.Io.Dir.path.fmtJoin(&.{ src_loc.dir_path, src_loc.file_path }), src_loc.line, src_loc.column, }); diff --git a/tools/printer/tests/test.zig b/tools/printer/tests/test.zig index e671cd039..1d76aee81 100644 --- a/tools/printer/tests/test.zig +++ b/tools/printer/tests/test.zig @@ -17,7 +17,7 @@ pub fn main(init: std.process.Init) !void { const elf_path = args[1]; const test_data_path = args[2]; - const test_name = std.fs.path.stem(test_data_path); + const test_name = std.Io.Dir.path.stem(test_data_path); const elf_file = try std.Io.Dir.cwd().openFile(io, elf_path, .{}); defer elf_file.close(io); diff --git a/tools/regz/src/Database.zig b/tools/regz/src/Database.zig index 5168ee82d..dc7e661a0 100644 --- a/tools/regz/src/Database.zig +++ b/tools/regz/src/Database.zig @@ -958,7 +958,7 @@ fn get_nested_struct_fields( fn recursively_calculate_struct_size( db: *Database, depth: *u8, - cache: *std.AutoArrayHashMapUnmanaged(StructID, u64), + cache: *std.array_hash_map.Auto(StructID, u64), gpa: Allocator, struct_id: StructID, ) !u64 { @@ -1013,7 +1013,7 @@ pub fn get_nested_struct_fields_with_calculated_size( log.debug("nested_struct_fields.len={} struct_id={f}", .{ nested_struct_fields.len, struct_id }); - var size_cache: std.AutoArrayHashMapUnmanaged(StructID, u64) = .empty; + var size_cache: std.array_hash_map.Auto(StructID, u64) = .empty; defer size_cache.deinit(gpa); for (nested_struct_fields) |*nsf| { diff --git a/tools/regz/src/analysis.zig b/tools/regz/src/analysis.zig index 9a2011ced..99c42e0f8 100644 --- a/tools/regz/src/analysis.zig +++ b/tools/regz/src/analysis.zig @@ -247,7 +247,7 @@ pub fn find_equivalent_enums( } }; - var groups: std.ArrayHashMapUnmanaged(SignatureKey, std.ArrayList(AnonymousEnumInfo), HashMapContext, false) = .{}; + var groups: std.array_hash_map.Custom(SignatureKey, std.ArrayList(AnonymousEnumInfo), HashMapContext, false) = .{}; for (anonymous_enums) |enum_info| { const signature = try self.compute_enum_signature(arena, enum_info.enum_id); diff --git a/tools/regz/src/atdf.zig b/tools/regz/src/atdf.zig index f8aa65e6d..caf0a335e 100644 --- a/tools/regz/src/atdf.zig +++ b/tools/regz/src/atdf.zig @@ -24,7 +24,7 @@ const Context = struct { db: *Database, arena: std.heap.ArenaAllocator, interrupt_groups: std.StringHashMapUnmanaged(std.ArrayList(InterruptGroupEntry)) = .empty, - inferred_register_group_offsets: std.AutoArrayHashMapUnmanaged(StructID, u64) = .{}, + inferred_register_group_offsets: std.array_hash_map.Auto(StructID, u64) = .{}, fn init(db: *Database) Context { return Context{ @@ -629,7 +629,7 @@ fn load_field(ctx: *Context, node: xml.Node, peripheral_struct_id: StructID, par var i = offset; while (i < 32) : (i += 1) { if (0 != (@as(u64, 1) << @as(u5, @intCast(i))) & mask) { - const field_name = try std.fmt.allocPrint(db.gpa, "{s}_bit{}", .{ + const field_name = try db.gpa.print("{s}_bit{}", .{ name, bit_count, }); diff --git a/tools/regz/src/embassy.zig b/tools/regz/src/embassy.zig index 8efd2b6af..46737cd4a 100644 --- a/tools/regz/src/embassy.zig +++ b/tools/regz/src/embassy.zig @@ -159,7 +159,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons chip_files.deinit(allocator); } - var register_files: std.StringArrayHashMapUnmanaged(std.json.Parsed(std.json.Value)) = .empty; + var register_files: std.array_hash_map.String(std.json.Parsed(std.json.Value)) = .empty; defer { for (register_files.values()) |*value| value.deinit(); @@ -239,7 +239,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons try handle_extends(allocator, ®ister_file.value); - const register_name = try allocator.dupe(u8, entry.name[0 .. entry.name.len - std.fs.path.extension(entry.name).len]); + const register_name = try allocator.dupe(u8, entry.name[0 .. entry.name.len - std.Io.Dir.path.extension(entry.name).len]); try register_files.put(allocator, register_name, register_file); } @@ -251,7 +251,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons .name = name, }); - var enums: std.StringArrayHashMapUnmanaged(Database.EnumID) = .empty; + var enums: std.array_hash_map.String(Database.EnumID) = .empty; defer enums.deinit(allocator); for (register_file.value.object.keys(), register_file.value.object.values()) |key, obj| { @@ -322,7 +322,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons // of cluster. if (item.object.get("block")) |block| { const ref_type = block.string; - const block_key = try std.fmt.allocPrint(allocator, "block/{s}", .{ref_type}); + const block_key = try allocator.print("block/{s}", .{ref_type}); const block_value = (register_file.value.object.get(block_key) orelse continue).object; var max_bytes: u64 = 0; for (block_value.get("items").?.array.items) |nested_item| { @@ -353,7 +353,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons } else if (maybe_stride) |stride| { // We have spread cluster for (0..maybe_count.?) |id| { - const register_part_name = try std.fmt.allocPrint(allocator, "{s}[{d}]", .{ + const register_part_name = try allocator.print("{s}[{d}]", .{ register_name, id, }); @@ -389,7 +389,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons if (maybe_count) |count| { // We spread the register as it jumps over other registers for (0..count) |id| { - const register_part_name = try std.fmt.allocPrint(allocator, "{s}[{d}]", .{ + const register_part_name = try allocator.print("{s}[{d}]", .{ register_name, id, }); @@ -415,7 +415,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons } if (item.object.get("fieldset")) |fieldset| blk: { - const fieldset_key = try std.fmt.allocPrint(allocator, "fieldset/{s}", .{fieldset.string}); + const fieldset_key = try allocator.print("fieldset/{s}", .{fieldset.string}); const fieldset_value = (register_file.value.object.get(fieldset_key) orelse break :blk).object; next_field: for (fieldset_value.get("fields").?.array.items) |field| { const field_name = field.object.get("name").?.string; @@ -445,7 +445,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons if (object_map.get("offsets")) |positions| { for (positions.array.items, 0..) |position, idx| { - const field_name_irregular_stride = try std.fmt.allocPrint(allocator, "{s}[{}]", .{ field_name, idx }); + const field_name_irregular_stride = try allocator.print("{s}[{}]", .{ field_name, idx }); for (register_ids.items) |register_id| { try db.add_register_field(register_id, .{ .name = field_name_irregular_stride, @@ -481,7 +481,7 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons std.log.warn("skipping {s}, it's an non-consecutive field with more than two parts", .{field_name}); continue; } - const cont_field = try std.fmt.allocPrint(allocator, "{s}_CONT", .{field_name}); + const cont_field = try allocator.print("{s}_CONT", .{field_name}); const field_names = [2][]const u8{ field_name, cont_field }; for (arr.items, field_names) |non_contiguous_offset, non_contiguous_field_name| { @@ -544,11 +544,11 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons .idx = interrupt.number, }); - if (std.mem.indexOf(u8, interrupt.name, "FPU")) |_| { + if (std.mem.find(u8, interrupt.name, "FPU")) |_| { has_fpu = true; } - if (std.mem.indexOf(u8, interrupt.name, "DMA")) |_| { + if (std.mem.find(u8, interrupt.name, "DMA")) |_| { dma_channel_count += 1; } } @@ -560,14 +560,14 @@ pub fn load_into_db(db: *Database, io: std.Io, path: []const u8, device: ?[]cons try db.add_device_property(device_id, .{ .key = "cpu.dmaChannelCount", - .value = try std.fmt.allocPrint(allocator, "{d}", .{dma_channel_count}), + .value = try allocator.print("{d}", .{dma_channel_count}), }); for (core.peripherals) |peripheral| { // Don't know what to do if registers is null, so skipping const registers = peripheral.registers orelse continue; - const periph_name = try std.fmt.allocPrint(allocator, "{s}_{s}", .{ registers.kind, registers.version }); + const periph_name = try allocator.print("{s}_{s}", .{ registers.kind, registers.version }); // get the register group representing the peripheral instance const periph_id = try db.get_peripheral_by_name(periph_name) orelse return error.MissingPeripheral; const struct_id = try db.get_peripheral_struct(periph_id); @@ -651,7 +651,7 @@ fn get_parent(gpa: std.mem.Allocator, json_data: *std.json.Value, child_full_nam const family_name = name_iterator.first(); //Get qualified parent name - const parent_full_name = try std.fmt.allocPrint(gpa, "{s}/{s}", .{ family_name, parent_name }); + const parent_full_name = try gpa.print("{s}/{s}", .{ family_name, parent_name }); defer gpa.free(parent_full_name); return json_data.object.getEntry(parent_full_name).?; diff --git a/tools/regz/src/gen.zig b/tools/regz/src/gen.zig index cafb0187c..322f8d110 100644 --- a/tools/regz/src/gen.zig +++ b/tools/regz/src/gen.zig @@ -149,7 +149,7 @@ fn write_device_file( try ast.render(arena, &rendered_buffer.writer, fixups); - const filename = try std.fmt.allocPrint(arena, "{s}.zig", .{device.name}); + const filename = try arena.print("{s}.zig", .{device.name}); try dir.writeFile(io, .{ .sub_path = filename, .data = rendered_buffer.written(), @@ -193,7 +193,7 @@ fn write_peripherals_files(io: std.Io, db: *Database, arena: Allocator, dir: std continue; }; - const path = try std.fmt.allocPrint(arena, "{s}.zig", .{ + const path = try arena.print("{s}.zig", .{ peripheral.name, }); @@ -546,7 +546,7 @@ fn write_device_peripheral( var array_prefix_buf: [80]u8 = undefined; const array_prefix = if (instance.count) |count| - try std.fmt.bufPrint(&array_prefix_buf, "[{}]", .{count}) + try std.mem.print(&array_prefix_buf, "[{}]", .{count}) else ""; @@ -1066,13 +1066,13 @@ fn write_nested_struct_field(db: *Database, arena: Allocator, nsf: *const Nested var offset_buf: [80]u8 = undefined; const offset_str: []const u8 = - try std.fmt.bufPrint(&offset_buf, "offset: 0x{x:0>2}", .{nsf.offset_bytes}); + try std.mem.print(&offset_buf, "offset: 0x{x:0>2}", .{nsf.offset_bytes}); try write_doc_comment(arena, offset_str, writer); try writer.print("{f}: ", .{std.zig.fmtId(nsf.name)}); var array_prefix_buf: [80]u8 = undefined; const array_prefix: []const u8 = if (nsf.count) |count| - try std.fmt.bufPrint(&array_prefix_buf, "[{}]", .{count}) + try std.mem.print(&array_prefix_buf, "[{}]", .{count}) else ""; try writer.print("{s}", .{array_prefix}); @@ -1144,12 +1144,12 @@ fn write_register( // Add offset comment var offset_buf: [80]u8 = undefined; const offset_str: []const u8 = - try std.fmt.bufPrint(&offset_buf, "offset: 0x{x:0>2}", .{register.offset_bytes}); + try std.mem.print(&offset_buf, "offset: 0x{x:0>2}", .{register.offset_bytes}); try write_doc_comment(arena, offset_str, writer); var array_prefix_buf: [80]u8 = undefined; const array_prefix: []const u8 = if (register.count) |count| - try std.fmt.bufPrint(&array_prefix_buf, "[{}]", .{count}) + try std.mem.print(&array_prefix_buf, "[{}]", .{count}) else ""; @@ -1241,8 +1241,8 @@ fn write_fields( subfield.count = undefined; subfield.stride = undefined; subfield.offset_bits = field.offset_bits + @as(u8, @intCast(stride * i)); - subfield.name = try std.fmt.allocPrint(arena, "{s}[{d}]", .{ field.name, i }); - subfield.description = try std.fmt.allocPrint(arena, "({d}/{d} of {s}) {s}", .{ i + 1, count, field.name, field.description orelse "" }); + subfield.name = try arena.print("{s}[{d}]", .{ field.name, i }); + subfield.description = try arena.print("({d}/{d} of {s}) {s}", .{ i + 1, count, field.name, field.description orelse "" }); try expanded_fields.append(arena, subfield); } } else try expanded_fields.append(arena, field); @@ -1271,13 +1271,13 @@ fn write_fields( // If the offset of this field is the exact same as for another shorter field, // then (because of the `field_comes_before()` sort order) we will already have seen the shorter field, // and here we are skipping the longer field. - const message = try std.fmt.allocPrint(arena, "skipped overlapping field {s} at offset {d} bits", .{ field.name, field.offset_bits }); + const message = try arena.print("skipped overlapping field {s} at offset {d} bits", .{ field.name, field.offset_bits }); log.debug("{s}", .{message}); try write_regular_comment(arena, message, writer); continue; } if (offset + field.size_bits > register_size_bits) { - const message = try std.fmt.allocPrint(arena, "skipped too long field {s} at offset {d} bits, length {d} bits", .{ field.name, field.offset_bits, field.size_bits }); + const message = try arena.print("skipped too long field {s} at offset {d} bits, length {d} bits", .{ field.name, field.offset_bits, field.size_bits }); log.warn("{s}", .{message}); try write_regular_comment(arena, message, writer); continue; diff --git a/tools/regz/src/patch.zig b/tools/regz/src/patch.zig index 5c94b0bc5..10f405a65 100644 --- a/tools/regz/src/patch.zig +++ b/tools/regz/src/patch.zig @@ -60,7 +60,7 @@ pub const Patch = union(enum) { /// List for assembling patches in build scripts pub const PatchList = struct { - entries: std.array_list.Managed(Patch), + entries: std.array_list.Managed(Patch), // zlinter-disable-current-line no_deprecated pub fn append(list: *PatchList, patch: Patch) void { list.append(patch) catch @panic("OOM"); diff --git a/tools/regz/src/svd.zig b/tools/regz/src/svd.zig index cf1a7cc70..1917a9175 100644 --- a/tools/regz/src/svd.zig +++ b/tools/regz/src/svd.zig @@ -19,8 +19,8 @@ const log = std.log.scoped(.svd); const Context = struct { db: *Database, arena: ArenaAllocator, - register_props: std.AutoArrayHashMapUnmanaged(RegisterPropertiesParent, RegisterProperties) = .{}, - derived_peripherals: std.AutoArrayHashMapUnmanaged(xml.Node, []const u8) = .{}, + register_props: std.array_hash_map.Auto(RegisterPropertiesParent, RegisterProperties) = .{}, + derived_peripherals: std.array_hash_map.Auto(xml.Node, []const u8) = .{}, fn deinit(ctx: *Context) void { ctx.register_props.deinit(ctx.db.gpa); @@ -406,7 +406,7 @@ fn load_register_with_dim_element_group(ctx: *Context, node: xml.Node, parent: S .list => blk: { const replacement = try dim_elements.dim_index_value(ctx, i); const new_name = try std.mem.replaceOwned(u8, ctx.arena.allocator(), name, "%s", replacement); - break :blk try std.fmt.allocPrintSentinel(ctx.arena.allocator(), "{s}", .{new_name}, 0); + break :blk try ctx.arena.allocator().printSentinel("{s}", .{new_name}, 0); }, }, .description = node.get_value("description"), @@ -501,7 +501,7 @@ fn load_field(ctx: *Context, node: xml.Node, register_id: RegisterID, props: *co .list => listblk: { const replacement = try elements.dim_index_value(ctx, i); const new_name = try std.mem.replaceOwned(u8, ctx.arena.allocator(), node.get_value("name").?, "%s", replacement); - break :listblk try std.fmt.allocPrintSentinel(ctx.arena.allocator(), "{s}", .{new_name}, 0); + break :listblk try ctx.arena.allocator().printSentinel("{s}", .{new_name}, 0); }, }; } else try get_name_without_suffix(node, "%s"), @@ -569,7 +569,7 @@ pub const Revision = struct { if (!std.mem.startsWith(u8, str, "r")) return error.Malformed; - const p_index = std.mem.indexOf(u8, str, "p") orelse return error.Malformed; + const p_index = std.mem.find(u8, str, "p") orelse return error.Malformed; return Revision{ .release = try std.fmt.parseInt(u64, str[1..p_index], 10), .part = try std.fmt.parseInt(u64, str[p_index + 1 ..], 10), @@ -679,7 +679,7 @@ const DimElements = struct { var ret: std.ArrayList([]const u8) = .empty; defer ret.deinit(gpa); - if (std.mem.indexOf(u8, list.pattern, "-")) |dash_idx| { + if (std.mem.find(u8, list.pattern, "-")) |dash_idx| { const begin_str = list.pattern[0..dash_idx]; const end_str = list.pattern[dash_idx + 1 ..]; @@ -693,7 +693,7 @@ const DimElements = struct { return error.InvalidRange; for (begin..end + 1) |c| { - const identifier = try std.fmt.allocPrint(gpa, "{c}", .{@as(u8, @intCast(c))}); + const identifier = try gpa.print("{c}", .{@as(u8, @intCast(c))}); try ret.append(gpa, identifier); } } else { @@ -703,7 +703,7 @@ const DimElements = struct { return error.InvalidRange; for (begin..end + 1) |n| { - const identifier = try std.fmt.allocPrint(gpa, "{}", .{n}); + const identifier = try gpa.print("{}", .{n}); try ret.append(gpa, identifier); } } @@ -766,7 +766,7 @@ const DimElements = struct { const buf = try ctx.arena.allocator().allocSentinel(u8, 16, 0); @memset(buf, 0); // dim index range is with - dim_index = try std.fmt.bufPrintSentinel(buf, "0-{d}", .{dim.? - 1}, 0); + dim_index = try std.mem.printSentinel(buf, "0-{d}", .{dim.? - 1}, 0); } if (node.get_value("dimArrayIndex") != null) { @@ -794,10 +794,10 @@ const DimElements = struct { const start_index = iter.next().?; const parse_start = std.fmt.parseInt(usize, start_index, 0); if (parse_start) |start| { - return try std.fmt.allocPrintSentinel(ctx.arena.allocator(), "{d}", .{start + index}, 0); + return try ctx.arena.allocator().printSentinel("{d}", .{start + index}, 0); } else |_| { if (start_index.len == 1 and std.ascii.isAlphabetic(start_index[0])) { - return std.fmt.allocPrintSentinel(ctx.arena.allocator(), "{c}", .{start_index[0] + @as(u8, @truncate(index))}, 0); + return ctx.arena.allocator().printSentinel("{c}", .{start_index[0] + @as(u8, @truncate(index))}, 0); } return error.DimIndexInvalid; } @@ -814,7 +814,7 @@ const DimElements = struct { const start_index = iter_value.?; const parse_start = std.fmt.parseInt(usize, start_index, 0); if (parse_start) |start| { - return try std.fmt.allocPrintSentinel(ctx.arena.allocator(), "{d}", .{start}, 0); + return try ctx.arena.allocator().printSentinel("{d}", .{start}, 0); } else |_| { if (start_index.len == 1 and std.ascii.isAlphabetic(start_index[0])) { return start_index; diff --git a/tools/release/src/Archive.zig b/tools/release/src/Archive.zig index 100767739..a9a3a03a4 100644 --- a/tools/release/src/Archive.zig +++ b/tools/release/src/Archive.zig @@ -46,7 +46,7 @@ fn strip_components(path: []const u8, count: u32) ![]const u8 { var i: usize = 0; var c = count; while (c > 0) : (c -= 1) { - if (std.mem.indexOfScalarPos(u8, path, i, '/')) |pos| { + if (std.mem.findScalarPos(u8, path, i, '/')) |pos| { i = pos + 1; } else { return error.TarComponentsOutsideStrippedPrefix; @@ -84,8 +84,8 @@ pub fn read_from_fs( const components = try path_to_components(allocator, path); defer allocator.free(components); - const basename = std.fs.path.basename(path); - const dir = if (std.fs.path.dirname(path)) |dirname| + const basename = std.Io.Dir.path.basename(path); + const dir = if (std.Io.Dir.path.dirname(path)) |dirname| try root_dir.openDir(io, dirname, .{}) else root_dir; @@ -119,7 +119,7 @@ pub fn read_from_fs( try path_components.appendSlice(allocator, components); try path_components.append(allocator, entry.path); - const path_copy = try std.fs.path.join(allocator, path_components.items); + const path_copy = try std.Io.Dir.path.join(allocator, path_components.items); defer allocator.free(path_copy); const normalized = try normalize_path_alloc(allocator, path_copy); @@ -147,14 +147,14 @@ pub fn read_from_fs( try path_components.appendSlice(allocator, components); try path_components.append(allocator, entry.path); - const path_copy = try std.fs.path.join(allocator, path_components.items); + const path_copy = try std.Io.Dir.path.join(allocator, path_components.items); defer allocator.free(path_copy); var buf: [8000]u8 = undefined; const link_len = try entry.dir.readLink(io, entry.basename, &buf); const link_copy = try allocator.dupe(u8, buf[0..link_len]); - if (std.fs.path.sep != canonical_sep) { + if (std.Io.Dir.path.sep != canonical_sep) { normalize_path(link_copy); } @@ -187,7 +187,7 @@ pub fn read_from_fs( const text = try file_reader.interface.allocRemaining(allocator, .limited(std.math.maxInt(usize))); errdefer allocator.free(text); - const path_copy = try std.fs.path.join(allocator, components); + const path_copy = try std.Io.Dir.path.join(allocator, components); defer allocator.free(path_copy); const file_stat = try file.stat(io); @@ -205,7 +205,7 @@ pub fn read_from_fs( const components = try path_to_components(allocator, path); defer allocator.free(components); - const path_copy = try std.fs.path.join(allocator, components); + const path_copy = try std.Io.Dir.path.join(allocator, components); defer allocator.free(path_copy); const normalized = try normalize_path_alloc(allocator, path_copy); @@ -335,7 +335,7 @@ pub fn hash( return error.NameTooLong; var ver_buf: [32]u8 = undefined; - const ver = try std.fmt.bufPrint(&ver_buf, "{f}", .{semver}); + const ver = try std.mem.print(&ver_buf, "{f}", .{semver}); const archive_hash = try archive.hash_files(gpa); @@ -347,7 +347,7 @@ pub fn hash( var buf: [80]u8 = undefined; const hashplus_str = std.base64.url_safe_no_pad.Encoder.encode(&buf, &hashplus); - return try std.fmt.allocPrint(gpa, "{s}-{s}-{s}", .{ name, ver, hashplus_str }); + return try gpa.print("{s}-{s}-{s}", .{ name, ver, hashplus_str }); } const ArchiveHash = struct { @@ -404,18 +404,18 @@ fn hash_files( }; } -const canonical_sep = std.fs.path.sep_posix; +const canonical_sep = std.Io.Dir.path.sep_posix; fn normalize_path_alloc(arena: Allocator, pkg_path: []const u8) ![]const u8 { const normalized = try arena.dupe(u8, pkg_path); - if (std.fs.path.sep == canonical_sep) return normalized; + if (std.Io.Dir.path.sep == canonical_sep) return normalized; normalize_path(normalized); return normalized; } fn normalize_path(bytes: []u8) void { - assert(std.fs.path.sep != canonical_sep); - std.mem.replaceScalar(u8, bytes, std.fs.path.sep, canonical_sep); + assert(std.Io.Dir.path.sep != canonical_sep); + std.mem.replaceScalar(u8, bytes, std.Io.Dir.path.sep, canonical_sep); } const testing = std.testing; @@ -426,7 +426,7 @@ test "normalize_path_alloc" { const allocator = arena.allocator(); - try testing.expectEqualStrings("./file", try normalize_path_alloc(allocator, "." ++ std.fs.path.sep_str ++ "file")); + try testing.expectEqualStrings("./file", try normalize_path_alloc(allocator, "." ++ std.Io.Dir.path.sep_str ++ "file")); try testing.expectEqualStrings("src/file", try normalize_path_alloc(allocator, "src/file")); try testing.expectEqualStrings("./src/file", try normalize_path_alloc(allocator, "./src/file")); } diff --git a/tools/release/src/Manifest.zig b/tools/release/src/Manifest.zig index acf63640a..145500634 100644 --- a/tools/release/src/Manifest.zig +++ b/tools/release/src/Manifest.zig @@ -325,10 +325,10 @@ pub fn serialize(manifest: *Manifest, allocator: Allocator, opts: SerializeOptio // Add or replace minimum_zig_version. if (opts.minimum_zig_version != null) { if (manifest.nodes.minimum_zig_version.unwrap()) |mzv_node| { - const mzv_text = try std.fmt.allocPrint(a, "\"{s}\"", .{opts.minimum_zig_version.?}); + const mzv_text = try a.print("\"{s}\"", .{opts.minimum_zig_version.?}); try fixups.replace_nodes_with_string.put(allocator, mzv_node, mzv_text); } else if (manifest.nodes.version.unwrap()) |version_node| { - const mzv_field = try std.fmt.allocPrint(a, "\n .minimum_zig_version = \"{s}\",", .{opts.minimum_zig_version.?}); + const mzv_field = try a.print("\n .minimum_zig_version = \"{s}\",", .{opts.minimum_zig_version.?}); try fixups.append_string_after_node.put(allocator, version_node, mzv_field); } } diff --git a/tools/release/src/hash_test.zig b/tools/release/src/hash_test.zig index 538955c7a..7ef0cb8c4 100644 --- a/tools/release/src/hash_test.zig +++ b/tools/release/src/hash_test.zig @@ -33,7 +33,7 @@ fn createTempPackage( test_dir_name: []const u8, files: []const TestFile, ) ![]const u8 { - const tmp_path = try std.fmt.allocPrint(allocator, "/tmp/release-test-{s}", .{test_dir_name}); + const tmp_path = try allocator.print("/tmp/release-test-{s}", .{test_dir_name}); // Clean up any leftover std.Io.Dir.cwd().deleteTree(io, tmp_path) catch {}; _ = try std.Io.Dir.cwd().createDirPathOpen(io, tmp_path, .{}); @@ -43,7 +43,7 @@ fn createTempPackage( for (files) |f| { // Create parent directories if needed - if (std.fs.path.dirname(f.path)) |dirname| { + if (std.Io.Dir.path.dirname(f.path)) |dirname| { pkg_dir.createDirPath(io, dirname) catch |err| switch (err) { error.PathAlreadyExists => {}, else => return err, @@ -105,7 +105,7 @@ fn verifyHashMatches( defer allocator.free(tar_gz); // Write tar.gz to a temp file - const tar_gz_path = try std.fmt.allocPrint(allocator, "/tmp/release-test-{s}.tar.gz", .{pkg.name}); + const tar_gz_path = try allocator.print("/tmp/release-test-{s}.tar.gz", .{pkg.name}); defer { std.Io.Dir.cwd().deleteFile(io, tar_gz_path) catch {}; allocator.free(tar_gz_path); @@ -132,7 +132,7 @@ fn verifyHashMatches( var i: usize = 0; while (env_ptr[i]) |entry| : (i += 1) { const entry_str = std.mem.span(entry); - const eq_pos = std.mem.indexOfScalar(u8, entry_str, '=') orelse continue; + const eq_pos = std.mem.findScalar(u8, entry_str, '=') orelse continue; try m.put(entry_str[0..eq_pos], entry_str[eq_pos + 1 ..]); } break :blk m; diff --git a/tools/release/src/main.zig b/tools/release/src/main.zig index 5e342f44e..2cb73c183 100644 --- a/tools/release/src/main.zig +++ b/tools/release/src/main.zig @@ -49,7 +49,7 @@ pub fn main(init: std.process.Init) !void { .file => if (std.mem.eql(u8, entry.basename, "build.zig.zon")) { const path = try entry.dir.realPathFileAlloc(io, "build.zig.zon", allocator); std.log.info("found build.zig.zon: {s}", .{path}); - try todo.put(allocator, std.fs.path.dirname(path).?, {}); + try todo.put(allocator, std.Io.Dir.path.dirname(path).?, {}); }, else => {}, }; @@ -135,7 +135,7 @@ pub fn main(init: std.process.Init) !void { const root_manifest = manifests.get(root_path).?; // calculate urls for (manifests.keys(), manifests.values()) |path, manifest| { - try urls.put(allocator, path, try std.fmt.allocPrint(allocator, "{s}/{f}/{s}.tar.gz", .{ + try urls.put(allocator, path, try allocator.print("{s}/{f}/{s}.tar.gz", .{ base_url, root_manifest.version, manifest.name, @@ -161,7 +161,7 @@ pub fn main(init: std.process.Init) !void { try manifest.dependencies.put(allocator, dep_name, .{ .remote = .{ .url = urls.get(dep_path).?, - .hash = try std.fmt.allocPrint(allocator, "{s}", .{hashes.get(dep_path).?}), + .hash = try allocator.print("{s}", .{hashes.get(dep_path).?}), .lazy = old.local.lazy, }, }); @@ -197,15 +197,15 @@ pub fn main(init: std.process.Init) !void { continue; } - const out_path = try std.fmt.allocPrint(allocator, "{f}/{s}.tar.gz", .{ + const out_path = try allocator.print("{f}/{s}.tar.gz", .{ root_manifest.version, manifest.name, }); - var dir = try out_dir.createDirPathOpen(io, std.fs.path.dirname(out_path).?, .{}); + var dir = try out_dir.createDirPathOpen(io, std.Io.Dir.path.dirname(out_path).?, .{}); defer dir.close(io); - const file = try dir.createFile(io, std.fs.path.basename(out_path), .{}); + const file = try dir.createFile(io, std.Io.Dir.path.basename(out_path), .{}); defer file.close(io); const tar_gz = try archives.get(path).?.to_tar_gz(allocator); @@ -235,7 +235,7 @@ pub fn main(init: std.process.Init) !void { var package: json.ObjectMap = .empty; try package.put(allocator, "dependencies", .{ .object = deps }); - try package.put(allocator, "version", .{ .string = try std.fmt.allocPrint(allocator, "{f}", .{manifest.version}) }); + try package.put(allocator, "version", .{ .string = try allocator.print("{f}", .{manifest.version}) }); try package.put(allocator, "url", .{ .string = urls.get(path).? }); try package.put(allocator, "hash", .{ .string = hashes.get(path).? }); @@ -254,11 +254,11 @@ pub fn main(init: std.process.Init) !void { if (manifests.get(root_path)) |manifest| { var metadata: json.ObjectMap = .empty; - try metadata.put(allocator, "version", .{ .string = try std.fmt.allocPrint(allocator, "{f}", .{manifest.version}) }); + try metadata.put(allocator, "version", .{ .string = try allocator.print("{f}", .{manifest.version}) }); try metadata.put(allocator, "minimum_zig_version", .{ .string = minimum_zig_version }); try metadata.put(allocator, "packages", .{ .object = packages }); - const version_path = try std.fmt.allocPrint(allocator, "{f}", .{manifest.version}); + const version_path = try allocator.print("{f}", .{manifest.version}); var dir = try out_dir.openDir(io, version_path, .{}); defer dir.close(io); diff --git a/tools/release/src/tar.zig b/tools/release/src/tar.zig index 67cf0a884..455b7a031 100644 --- a/tools/release/src/tar.zig +++ b/tools/release/src/tar.zig @@ -87,10 +87,10 @@ pub const Header = extern struct { break; } - _ = try std.fmt.bufPrint(&self.prefix, "{s}", .{path[0..i]}); - _ = try std.fmt.bufPrint(&self.name, "{s}", .{path[i + 1 ..]}); + _ = try std.mem.print(&self.prefix, "{s}", .{path[0..i]}); + _ = try std.mem.print(&self.name, "{s}", .{path[i + 1 ..]}); } else { - _ = try std.fmt.bufPrint(&self.name, "{s}", .{path}); + _ = try std.mem.print(&self.name, "{s}", .{path}); } } @@ -98,11 +98,11 @@ pub const Header = extern struct { if (linkname.len > self.linkname.len) return error.TooBig; - _ = try std.fmt.bufPrint(&self.linkname, "{s}", .{linkname}); + _ = try std.mem.print(&self.linkname, "{s}", .{linkname}); } pub fn setSize(self: *Self, size: u64) !void { - _ = try std.fmt.bufPrint(&self.size, "{o:0>11}", .{size}); + _ = try std.mem.print(&self.size, "{o:0>11}", .{size}); } pub fn get_size(header: Header) !u64 { @@ -110,14 +110,14 @@ pub const Header = extern struct { } pub fn setMtime(self: *Self, mtime: u32) !void { - _ = try std.fmt.bufPrint(&self.mtime, "{o:0>11}", .{mtime}); + _ = try std.mem.print(&self.mtime, "{o:0>11}", .{mtime}); } pub fn setMode(self: *Self, filetype: FileType, perm: u32) !void { switch (filetype) { - .regular => _ = try std.fmt.bufPrint(&self.mode, "0{o:0>6}", .{perm}), - .directory => _ = try std.fmt.bufPrint(&self.mode, "0{o:0>6}", .{perm}), - .symbolic_link => _ = try std.fmt.bufPrint(&self.mode, "0{o:0>6}", .{perm}), + .regular => _ = try std.mem.print(&self.mode, "0{o:0>6}", .{perm}), + .directory => _ = try std.mem.print(&self.mode, "0{o:0>6}", .{perm}), + .symbolic_link => _ = try std.mem.print(&self.mode, "0{o:0>6}", .{perm}), else => return error.Unsupported, } } @@ -127,11 +127,11 @@ pub const Header = extern struct { } fn setUid(self: *Self, uid: u32) !void { - _ = try std.fmt.bufPrint(&self.uid, "{o:0>7}", .{uid}); + _ = try std.mem.print(&self.uid, "{o:0>7}", .{uid}); } fn setGid(self: *Self, gid: u32) !void { - _ = try std.fmt.bufPrint(&self.gid, "{o:0>7}", .{gid}); + _ = try std.mem.print(&self.gid, "{o:0>7}", .{gid}); } pub fn updateChecksum(self: *Self) !void { @@ -144,12 +144,12 @@ pub const Header = extern struct { val; } - _ = try std.fmt.bufPrint(&self.checksum, "{o:0>7}", .{checksum}); + _ = try std.mem.print(&self.checksum, "{o:0>7}", .{checksum}); } pub fn fromStat(stat: std.Io.File.Stat, path: []const u8) !Header { - if (std.mem.indexOf(u8, path, "\\") != null) return error.NeedPosixPath; - if (std.fs.path.isAbsolute(path)) return error.NeedRelPath; + if (std.mem.find(u8, path, "\\") != null) return error.NeedPosixPath; + if (std.Io.Dir.path.isAbsolute(path)) return error.NeedRelPath; var ret = Self.init(); ret.typeflag = switch (stat.kind) { @@ -224,7 +224,7 @@ pub fn instantiate( try components.append(component); } - const tmp_path = try std.fs.path.join(allocator, components.items); + const tmp_path = try std.Io.Dir.path.join(allocator, components.items); defer allocator.free(tmp_path); if (skip_depth >= components.items.len) { @@ -237,7 +237,7 @@ pub fn instantiate( _ = components.orderedRemove(0); } - const file_path = try std.fs.path.join(allocator, components.items); + const file_path = try std.Io.Dir.path.join(allocator, components.items); defer allocator.free(file_path); switch (header.typeflag) { @@ -315,7 +315,7 @@ pub fn Builder(comptime Writer: type) type { .ctime = undefined, }; const allocator = self.arena.child_allocator; - const posix_dirpath = try std.mem.replaceOwned(u8, allocator, dirpath, std.fs.path.sep_str_windows, std.fs.path.sep_str_posix); + const posix_dirpath = try std.mem.replaceOwned(u8, allocator, dirpath, std.Io.Dir.path.sep_str_windows, std.Io.Dir.path.sep_str_posix); defer allocator.free(posix_dirpath); const header = try Header.fromStat(stat, posix_dirpath); @@ -332,15 +332,15 @@ pub fn Builder(comptime Writer: type) type { ) !void { const allocator = self.arena.child_allocator; const path = if (prefix) |prefix_path| - try std.fs.path.join(allocator, &[_][]const u8{ prefix_path, subpath }) + try std.Io.Dir.path.join(allocator, &[_][]const u8{ prefix_path, subpath }) else subpath; defer if (prefix != null) allocator.free(path); - const posix_path = try std.mem.replaceOwned(u8, allocator, path, std.fs.path.sep_str_windows, std.fs.path.sep_str_posix); + const posix_path = try std.mem.replaceOwned(u8, allocator, path, std.Io.Dir.path.sep_str_windows, std.Io.Dir.path.sep_str_posix); defer allocator.free(posix_path); - if (std.fs.path.dirname(posix_path)) |dirname| + if (std.Io.Dir.path.dirname(posix_path)) |dirname| try self.maybeAddDirectories(posix_path[0 .. dirname.len + 1]); const subfile = try root.openFile(subpath, .{ .mode = .read_write }); defer subfile.close(); @@ -369,7 +369,7 @@ pub fn Builder(comptime Writer: type) type { /// add slice of bytes as file `path` pub fn addSlice(self: *Self, slice: []const u8, path: []const u8) !void { const allocator = self.arena.child_allocator; - const posix_path = try std.mem.replaceOwned(u8, allocator, path, std.fs.path.sep_str_windows, std.fs.path.sep_str_posix); + const posix_path = try std.mem.replaceOwned(u8, allocator, path, std.Io.Dir.path.sep_str_windows, std.Io.Dir.path.sep_str_posix); defer allocator.free(posix_path); const stat = std.fs.File.Stat{ @@ -420,8 +420,8 @@ pub const PaxHeaderMap = struct { var it = std.mem.tokenize(u8, text, "\n"); while (it.next()) |line| { - const begin = (std.mem.indexOf(u8, line, " ") orelse return error.BadMapEntry) + 1; - const eql = std.mem.indexOf(u8, line[begin..], "=") orelse return error.BadMapEntry; + const begin = (std.mem.find(u8, line, " ") orelse return error.BadMapEntry) + 1; + const eql = std.mem.find(u8, line[begin..], "=") orelse return error.BadMapEntry; try map.put(line[begin .. begin + eql], line[begin + eql + 1 ..]); } @@ -472,7 +472,7 @@ pub fn FileExtractor(comptime ReaderType: type) type { if (c != 0) break; } else return error.FileNotFound; const size = try std.fmt.parseInt(usize, &header.size, 8); - const name = header.name[0 .. std.mem.indexOf(u8, &header.name, "\x00") orelse header.name.len]; + const name = header.name[0 .. std.mem.find(u8, &header.name, "\x00") orelse header.name.len]; if (std.mem.eql(u8, name, self.path)) { self.len = size; break; diff --git a/tools/uf2/build.zig b/tools/uf2/build.zig index 01ba89641..354397e87 100644 --- a/tools/uf2/build.zig +++ b/tools/uf2/build.zig @@ -26,25 +26,24 @@ pub fn from_elf(dep: *Dependency, elf_file: std.Build.LazyPath, opts: Options) s return run.addOutputFileArg("output.uf2"); } -pub fn build(b: *std.Build) void { +pub fn build(b: *std.Build) !void { const optimize = b.standardOptimizeOption(.{}); const target = b.standardTargetOptions(.{}); const should_update_family_id = b.option(bool, "update_family_id", "Should update the FamilyId enum") orelse false; if (should_update_family_id) { - if (b.lazyDependency("microsoft_uf2", .{})) |microsoft_uf2_dep| { - const update_family_id_exe = b.addExecutable(.{ - .name = "update_family_id", - .root_module = b.createModule(.{ - .root_source_file = b.path("src/update_family_id.zig"), - .target = b.graph.host, - }), - }); - const update_family_id_run = b.addRunArtifact(update_family_id_exe); - update_family_id_run.addFileArg(microsoft_uf2_dep.path("utils/uf2families.json")); - update_family_id_run.addFileArg(b.path("src/family_id.zig")); - b.default_step.dependOn(&update_family_id_run.step); - } + const microsoft_uf2_dep = try b.dependencyLazy("microsoft_uf2", .{}); + const update_family_id_exe = b.addExecutable(.{ + .name = "update_family_id", + .root_module = b.createModule(.{ + .root_source_file = b.path("src/update_family_id.zig"), + .target = b.graph.host, + }), + }); + const update_family_id_run = b.addRunArtifact(update_family_id_exe); + update_family_id_run.addFileArg(microsoft_uf2_dep.path("utils/uf2families.json")); + update_family_id_run.addFileArg(b.path("src/family_id.zig")); + b.default_step.dependOn(&update_family_id_run.step); } const uf2_mod = b.addModule("uf2", .{ diff --git a/tools/uf2/src/uf2.zig b/tools/uf2/src/uf2.zig index 2c8fe54fd..dfade6324 100644 --- a/tools/uf2/src/uf2.zig +++ b/tools/uf2/src/uf2.zig @@ -17,7 +17,7 @@ pub const Archive = struct { allocator: Allocator, io: std.Io, blocks: std.ArrayList(Block), - families: std.AutoArrayHashMapUnmanaged(FamilyId, void), + families: std.array_hash_map.Auto(FamilyId, void), files: std.ArrayList(FileEntry), pub fn init(allocator: std.mem.Allocator, io: std.Io) Archive { @@ -51,7 +51,7 @@ pub const Archive = struct { /// Reads UF2 blocks from a reader. Reader buffer size must be at least 512 /// bytes. pub fn read_from(self: *Archive, reader: *std.Io.Reader, options: ReadFromOptions) !void { - var new_family_ids: std.AutoArrayHashMapUnmanaged(FamilyId, void) = .empty; + var new_family_ids: std.array_hash_map.Auto(FamilyId, void) = .empty; defer new_family_ids.deinit(self.allocator); while (reader.takeStruct(Block, .little)) |block| { @@ -165,7 +165,7 @@ pub const Archive = struct { pub fn add_file(self: *Archive, path: []const u8) !void { if (self.has_file(path)) return error.FileAlreadyAdded; - const file = if (std.fs.path.isAbsolute(path)) + const file = if (std.Io.Dir.path.isAbsolute(path)) try std.Io.Dir.openFileAbsolute(self.io, path, .{}) else try std.Io.Dir.cwd().openFile(self.io, path, .{}); From 8414fcdf114052b9e3a09fbd28a656e8d760e960 Mon Sep 17 00:00:00 2001 From: Vesim Date: Thu, 5 Nov 2026 05:13:09 +0100 Subject: [PATCH 2/2] feat(zlinter): enable no_literal_only_bool_expression --- build.zig | 1 + port/espressif/esp/src/hal/radio/wifi.zig | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/build.zig b/build.zig index 7f39f7207..29b3d1357 100644 --- a/build.zig +++ b/build.zig @@ -68,6 +68,7 @@ pub fn build(b: *Build) void { }); builder.addRule(.{ .builtin = .no_hidden_allocations }, .{}); builder.addRule(.{ .builtin = .no_deprecated }, .{}); + builder.addRule(.{ .builtin = .no_literal_only_bool_expression }, .{}); builder.addRule(.{ .builtin = .require_fmt }, .{}); break :step builder.build(); }); diff --git a/port/espressif/esp/src/hal/radio/wifi.zig b/port/espressif/esp/src/hal/radio/wifi.zig index e2b1ccbd4..4db55b982 100644 --- a/port/espressif/esp/src/hal/radio/wifi.zig +++ b/port/espressif/esp/src/hal/radio/wifi.zig @@ -163,7 +163,7 @@ pub fn init(gpa: std.mem.Allocator, config: InitConfig) InitError!void { } // TODO: if coex enabled - if (false) try c_err(c.coex_init()); + // if (false) try c_err(c.coex_init()); try c_err(c.esp_wifi_init_internal(&init_config));