mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 05:44:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Update all std.mem.split calls to their appropriate function

Browse source 
Everywhere that can now use `splitScalar` should get a nice little performance boost.
This commit is contained in:
Ryan Liptak 2023-05-04 18:15:50 -07:00
parent 815e53b147
commit 2129f28953
27 changed files with 58 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
build.zig
View file

@ -239,7 +239,7 @@ pub fn build(b: *std.Build) !void {
},
2 => {
// Untagged development build (e.g. 0.10.0-dev.2025+ecf0050a9).
var it = mem.split(u8, git_describe, "-");
var it = mem.splitScalar(u8, git_describe, '-');
const tagged_ancestor = it.first();
const commit_height = it.next().?;
const commit_id = it.next().?;
@ -859,14 +859,14 @@ fn parseConfigH(b: *std.Build, config_h_text: []const u8) ?CMakeConfig {
while (lines_it.next()) |line| {
inline for (mappings) |mapping| {
if (mem.startsWith(u8, line, mapping.prefix)) {
var it = mem.split(u8, line, "\"");
var it = mem.splitScalar(u8, line, '"');
_ = it.first(); // skip the stuff before the quote
const quoted = it.next().?; // the stuff inside the quote
@field(ctx, mapping.field) = toNativePathSep(b, quoted);
}
}
if (mem.startsWith(u8, line, "#define ZIG_LLVM_LINK_MODE ")) {
var it = mem.split(u8, line, "\"");
var it = mem.splitScalar(u8, line, '"');
_ = it.next().?; // skip the stuff before the quote
const quoted = it.next().?; // the stuff inside the quote
ctx.llvm_linkage = if (mem.eql(u8, quoted, "shared")) .dynamic else .static;

2
doc/docgen.zig
View file

@ -1223,7 +1223,7 @@ fn printShell(out: anytype, shell_content: []const u8, escape: bool) !void {
const trimmed_shell_content = mem.trim(u8, shell_content, " \n");
try out.writeAll("<figure><figcaption class=\"shell-cap\">Shell</figcaption><pre><samp>");
var cmd_cont: bool = false;
var iter = std.mem.split(u8, trimmed_shell_content, "\n");
var iter = std.mem.splitScalar(u8, trimmed_shell_content, '\n');
while (iter.next()) |orig_line| {
const line = mem.trimRight(u8, orig_line, " ");
if (!cmd_cont and line.len > 1 and mem.eql(u8, line[0..2], "$ ") and line[line.len - 1] != '\\') {

2
lib/std/Build/Step/Compile.zig
View file

@ -2140,7 +2140,7 @@ fn checkCompileErrors(self: *Compile) !void {
// Render the expected lines into a string that we can compare verbatim.
var expected_generated = std.ArrayList(u8).init(arena);
var actual_line_it = mem.split(u8, actual_stderr, "\n");
var actual_line_it = mem.splitScalar(u8, actual_stderr, '\n');
for (self.expect_errors) |expect_line| {
const actual_line = actual_line_it.next() orelse {
try expected_generated.appendSlice(expect_line);

4
lib/std/Build/Step/ConfigHeader.zig
View file

@ -250,7 +250,7 @@ fn render_autoconf(
var any_errors = false;
var line_index: u32 = 0;
var line_it = std.mem.split(u8, contents, "\n");
var line_it = std.mem.splitScalar(u8, contents, '\n');
while (line_it.next()) |line| : (line_index += 1) {
if (!std.mem.startsWith(u8, line, "#")) {
try output.appendSlice(line);
@ -297,7 +297,7 @@ fn render_cmake(
var any_errors = false;
var line_index: u32 = 0;
var line_it = std.mem.split(u8, contents, "\n");
var line_it = std.mem.splitScalar(u8, contents, '\n');
while (line_it.next()) |line| : (line_index += 1) {
if (!std.mem.startsWith(u8, line, "#")) {
try output.appendSlice(line);

10
lib/std/SemanticVersion.zig
View file

@ -42,8 +42,8 @@ pub fn order(lhs: Version, rhs: Version) std.math.Order {
if (lhs.pre == null and rhs.pre != null) return .gt;
// Iterate over pre-release identifiers until a difference is found.
var lhs_pre_it = std.mem.split(u8, lhs.pre.?, ".");
var rhs_pre_it = std.mem.split(u8, rhs.pre.?, ".");
var lhs_pre_it = std.mem.splitScalar(u8, lhs.pre.?, '.');
var rhs_pre_it = std.mem.splitScalar(u8, rhs.pre.?, '.');
while (true) {
const next_lid = lhs_pre_it.next();
const next_rid = rhs_pre_it.next();
@ -86,7 +86,7 @@ pub fn parse(text: []const u8) !Version {
// Parse the required major, minor, and patch numbers.
const extra_index = std.mem.indexOfAny(u8, text, "-+");
const required = text[0..(extra_index orelse text.len)];
var it = std.mem.split(u8, required, ".");
var it = std.mem.splitScalar(u8, required, '.');
var ver = Version{
.major = try parseNum(it.first()),
.minor = try parseNum(it.next() orelse return error.InvalidVersion),
@ -108,7 +108,7 @@ pub fn parse(text: []const u8) !Version {
// Check validity of optional pre-release identifiers.
// See: https://semver.org/#spec-item-9
if (ver.pre) |pre| {
it = std.mem.split(u8, pre, ".");
it = std.mem.splitScalar(u8, pre, '.');
while (it.next()) |id| {
// Identifiers MUST NOT be empty.
if (id.len == 0) return error.InvalidVersion;
@ -127,7 +127,7 @@ pub fn parse(text: []const u8) !Version {
// Check validity of optional build metadata identifiers.
// See: https://semver.org/#spec-item-10
if (ver.build) |build| {
it = std.mem.split(u8, build, ".");
it = std.mem.splitScalar(u8, build, '.');
while (it.next()) |id| {
// Identifiers MUST NOT be empty.
if (id.len == 0) return error.InvalidVersion;

2
lib/std/builtin.zig
View file

@ -531,7 +531,7 @@ pub const Version = struct {
// found no digits or '.' before unexpected character
if (end == 0) return error.InvalidVersion;
var it = std.mem.split(u8, text[0..end], ".");
var it = std.mem.splitScalar(u8, text[0..end], '.');
// substring is not empty, first call will succeed
const major = it.first();
if (major.len == 0) return error.InvalidVersion;

4
lib/std/crypto/Certificate.zig
View file

@ -337,8 +337,8 @@ pub const Parsed = struct {
return true; // exact match
}
var it_host = std.mem.split(u8, host_name, ".");
var it_dns = std.mem.split(u8, dns_name, ".");
var it_host = std.mem.splitScalar(u8, host_name, '.');
var it_dns = std.mem.splitScalar(u8, dns_name, '.');
const len_match = while (true) {
const host = it_host.next();

9
lib/std/crypto/phc_encoding.zig
View file

@ -7,9 +7,12 @@ const mem = std.mem;
const meta = std.meta;
const fields_delimiter = "$";
const fields_delimiter_scalar = '$';
const version_param_name = "v";
const params_delimiter = ",";
const params_delimiter_scalar = ',';
const kv_delimiter = "=";
const kv_delimiter_scalar = '=';
pub const Error = std.crypto.errors.EncodingError || error{NoSpaceLeft};
@ -73,7 +76,7 @@ pub fn BinValue(comptime max_len: usize) type {
/// Other fields will also be deserialized from the function parameters section.
pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult {
var out = mem.zeroes(HashResult);
var it = mem.split(u8, str, fields_delimiter);
var it = mem.splitScalar(u8, str, fields_delimiter_scalar);
var set_fields: usize = 0;
while (true) {
@ -104,7 +107,7 @@ pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult
// Read optional parameters
var has_params = false;
var it_params = mem.split(u8, field, params_delimiter);
var it_params = mem.splitScalar(u8, field, params_delimiter_scalar);
while (it_params.next()) |params| {
const param = kvSplit(params) catch break;
var found = false;
@ -252,7 +255,7 @@ fn serializeTo(params: anytype, out: anytype) !void {
// Split a `key=value` string into `key` and `value`
fn kvSplit(str: []const u8) !struct { key: []const u8, value: []const u8 } {
var it = mem.split(u8, str, kv_delimiter);
var it = mem.splitScalar(u8, str, kv_delimiter_scalar);
const key = it.first();
const value = it.next() orelse return Error.InvalidEncoding;
const ret = .{ .key = key, .value = value };

2
lib/std/crypto/scrypt.zig
View file

@ -287,7 +287,7 @@ const crypt_format = struct {
out.r = try Codec.intDecode(u30, str[4..9]);
out.p = try Codec.intDecode(u30, str[9..14]);
var it = mem.split(u8, str[14..], "$");
var it = mem.splitScalar(u8, str[14..], '$');
const salt = it.first();
if (@hasField(T, "salt")) out.salt = salt;

2
lib/std/http/Client.zig
View file

@ -426,7 +426,7 @@ pub const Response = struct {
} else if (std.ascii.eqlIgnoreCase(header_name, "transfer-encoding")) {
// Transfer-Encoding: second, first
// Transfer-Encoding: deflate, chunked
var iter = mem.splitBackwards(u8, header_value, ",");
var iter = mem.splitBackwardsScalar(u8, header_value, ',');
if (iter.next()) |first| {
const trimmed = mem.trim(u8, first, " ");

2
lib/std/http/Server.zig
View file

@ -277,7 +277,7 @@ pub const Request = struct {
} else if (std.ascii.eqlIgnoreCase(header_name, "transfer-encoding")) {
// Transfer-Encoding: second, first
// Transfer-Encoding: deflate, chunked
var iter = mem.splitBackwards(u8, header_value, ",");
var iter = mem.splitBackwardsScalar(u8, header_value, ',');
if (iter.next()) |first| {
const trimmed = mem.trim(u8, first, " ");

6
lib/std/net.zig
View file

@ -1263,7 +1263,7 @@ fn linuxLookupNameFromHosts(
},
else => |e| return e,
}) |line| {
var split_it = mem.split(u8, line, "#");
var split_it = mem.splitScalar(u8, line, '#');
const no_comment_line = split_it.first();
var line_it = mem.tokenizeAny(u8, no_comment_line, " \t");
@ -1465,7 +1465,7 @@ fn getResolvConf(allocator: mem.Allocator, rc: *ResolvConf) !void {
else => |e| return e,
}) |line| {
const no_comment_line = no_comment_line: {
var split = mem.split(u8, line, "#");
var split = mem.splitScalar(u8, line, '#');
break :no_comment_line split.first();
};
var line_it = mem.tokenizeAny(u8, no_comment_line, " \t");
@ -1473,7 +1473,7 @@ fn getResolvConf(allocator: mem.Allocator, rc: *ResolvConf) !void {
const token = line_it.next() orelse continue;
if (mem.eql(u8, token, "options")) {
while (line_it.next()) |sub_tok| {
var colon_it = mem.split(u8, sub_tok, ":");
var colon_it = mem.splitScalar(u8, sub_tok, ':');
const name = colon_it.first();
const value_txt = colon_it.next() orelse continue;
const value = std.fmt.parseInt(u8, value_txt, 10) catch |err| switch (err) {

2
lib/std/process.zig
View file

@ -310,7 +310,7 @@ pub fn getEnvMap(allocator: Allocator) !EnvMap {
for (environ) |env| {
const pair = mem.sliceTo(env, 0);
var parts = mem.split(u8, pair, "=");
var parts = mem.splitScalar(u8, pair, '=');
const key = parts.first();
const value = parts.rest();
try result.put(key, value);

12
lib/std/zig/CrossTarget.zig
View file

@ -239,7 +239,7 @@ pub fn parse(args: ParseOptions) !CrossTarget {
.dynamic_linker = DynamicLinker.init(args.dynamic_linker),
};
var it = mem.split(u8, args.arch_os_abi, "-");
var it = mem.splitScalar(u8, args.arch_os_abi, '-');
const arch_name = it.first();
const arch_is_native = mem.eql(u8, arch_name, "native");
if (!arch_is_native) {
@ -257,7 +257,7 @@ pub fn parse(args: ParseOptions) !CrossTarget {
const opt_abi_text = it.next();
if (opt_abi_text) |abi_text| {
var abi_it = mem.split(u8, abi_text, ".");
var abi_it = mem.splitScalar(u8, abi_text, '.');
const abi = std.meta.stringToEnum(Target.Abi, abi_it.first()) orelse
return error.UnknownApplicationBinaryInterface;
result.abi = abi;
@ -343,7 +343,7 @@ pub fn parse(args: ParseOptions) !CrossTarget {
/// This is intended to be used if the API user of CrossTarget needs to learn the
/// target CPU architecture in order to fully populate `ParseOptions`.
pub fn parseCpuArch(args: ParseOptions) ?Target.Cpu.Arch {
var it = mem.split(u8, args.arch_os_abi, "-");
var it = mem.splitScalar(u8, args.arch_os_abi, '-');
const arch_name = it.first();
const arch_is_native = mem.eql(u8, arch_name, "native");
if (arch_is_native) {
@ -645,7 +645,7 @@ pub fn updateCpuFeatures(self: CrossTarget, set: *Target.Cpu.Feature.Set) void {
}
fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const u8) !void {
var it = mem.split(u8, text, ".");
var it = mem.splitScalar(u8, text, '.');
const os_name = it.first();
diags.os_name = os_name;
const os_is_native = mem.eql(u8, os_name, "native");
@ -706,7 +706,7 @@ fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const
.linux,
.dragonfly,
=> {
var range_it = mem.split(u8, version_text, "...");
var range_it = mem.splitFull(u8, version_text, "...");
const min_text = range_it.next().?;
const min_ver = SemVer.parse(min_text) catch |err| switch (err) {
@ -726,7 +726,7 @@ fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const
},
.windows => {
var range_it = mem.split(u8, version_text, "...");
var range_it = mem.splitFull(u8, version_text, "...");
const min_text = range_it.first();
const min_ver = std.meta.stringToEnum(Target.Os.WindowsVersion, min_text) orelse

2
lib/std/zig/ErrorBundle.zig
View file

@ -294,7 +294,7 @@ fn renderErrorMessageToWriter(
///
/// This is used to split the message in `@compileError("hello\nworld")` for example.
fn writeMsg(eb: ErrorBundle, err_msg: ErrorMessage, stderr: anytype, indent: usize) !void {
var lines = std.mem.split(u8, eb.nullTerminatedString(err_msg.msg), "\n");
var lines = std.mem.splitScalar(u8, eb.nullTerminatedString(err_msg.msg), '\n');
while (lines.next()) |line| {
try stderr.writeAll(line);
if (lines.index == null) break;

2
lib/std/zig/render.zig
View file

@ -1995,7 +1995,7 @@ fn renderArrayInit(
if (!expr_newlines[i]) {
try ais.writer().writeAll(expr_text);
} else {
var by_line = std.mem.split(u8, expr_text, "\n");
var by_line = std.mem.splitScalar(u8, expr_text, '\n');
var last_line_was_empty = false;
try ais.writer().writeAll(by_line.first());
while (by_line.next()) |line| {

2
lib/std/zig/system/NativeTargetInfo.zig
View file

@ -556,7 +556,7 @@ fn glibcVerFromSoFile(file: fs.File) !std.builtin.Version {
const dynstr_size = @intCast(usize, dynstr.size);
const dynstr_bytes = buf[0..dynstr_size];
_ = try preadMin(file, dynstr_bytes, dynstr.offset, dynstr_bytes.len);
var it = mem.split(u8, dynstr_bytes, &.{0});
var it = mem.splitScalar(u8, dynstr_bytes, 0);
var max_ver: std.builtin.Version = .{ .major = 2, .minor = 2, .patch = 5 };
while (it.next()) |s| {
if (mem.startsWith(u8, s, "GLIBC_2.")) {

2
src/Autodoc.zig
View file

@ -4951,7 +4951,7 @@ fn findGuidePaths(self: *Autodoc, file: *File, str: []const u8) ![]const u8 {
// TODO: this algo is kinda inefficient
var it = std.mem.split(u8, str, "\n");
var it = std.mem.splitScalar(u8, str, '\n');
while (it.next()) |line| {
const trimmed_line = std.mem.trim(u8, line, " ");
if (std.mem.startsWith(u8, trimmed_line, guide_prefix)) {

6
src/Compilation.zig
View file

@ -4636,7 +4636,7 @@ pub fn hasSharedLibraryExt(filename: []const u8) bool {
return true;
}
// Look for .so.X, .so.X.Y, .so.X.Y.Z
var it = mem.split(u8, filename, ".");
var it = mem.splitScalar(u8, filename, '.');
_ = it.first();
var so_txt = it.next() orelse return false;
while (!mem.eql(u8, so_txt, "so")) {
@ -5016,14 +5016,14 @@ fn parseLldStderr(comp: *Compilation, comptime prefix: []const u8, stderr: []con
defer context_lines.deinit();
var current_err: ?*LldError = null;
var lines = mem.split(u8, stderr, std.cstr.line_sep);
var lines = mem.splitFull(u8, stderr, std.cstr.line_sep);
while (lines.next()) |line| {
if (mem.startsWith(u8, line, prefix ++ ":")) {
if (current_err) |err| {
err.context_lines = try context_lines.toOwnedSlice();
}
var split = std.mem.split(u8, line, "error: ");
var split = std.mem.splitFull(u8, line, "error: ");
_ = split.first();
const duped_msg = try std.fmt.allocPrint(comp.gpa, "{s}: {s}", .{ prefix, split.rest() });

2
src/libc_installation.zig
View file

@ -63,7 +63,7 @@ pub const LibCInstallation = struct {
var it = std.mem.tokenizeScalar(u8, contents, '\n');
while (it.next()) |line| {
if (line.len == 0 or line[0] == '#') continue;
var line_it = std.mem.split(u8, line, "=");
var line_it = std.mem.splitScalar(u8, line, '=');
const name = line_it.first();
const value = line_it.rest();
inline for (fields, 0..) |field, i| {

2
src/link/MachO/Dylib.zig
View file

@ -91,7 +91,7 @@ pub const Id = struct {
var out: u32 = 0;
var values: [3][]const u8 = undefined;
var split = mem.split(u8, string, ".");
var split = mem.splitScalar(u8, string, '.');
var count: u4 = 0;
while (split.next()) |value| {
if (count > 2) {

16
src/main.zig
View file

@ -976,7 +976,7 @@ fn buildOutputType(
}
} else if (mem.eql(u8, arg, "--mod")) {
const info = args_iter.nextOrFatal();
var info_it = mem.split(u8, info, ":");
var info_it = mem.splitScalar(u8, info, ':');
const mod_name = info_it.next() orelse fatal("expected non-empty argument after {s}", .{arg});
const deps_str = info_it.next() orelse fatal("expected 'name:deps:path' after {s}", .{arg});
const root_src_orig = info_it.rest();
@ -1176,7 +1176,7 @@ fn buildOutputType(
} else {
if (build_options.omit_pkg_fetching_code) unreachable;
// example: --listen 127.0.0.1:9000
var it = std.mem.split(u8, next_arg, ":");
var it = std.mem.splitScalar(u8, next_arg, ':');
const host = it.next().?;
const port_text = it.next() orelse "14735";
const port = std.fmt.parseInt(u16, port_text, 10) catch |err|
@ -1673,7 +1673,7 @@ fn buildOutputType(
},
.rdynamic => rdynamic = true,
.wl => {
var split_it = mem.split(u8, it.only_arg, ",");
var split_it = mem.splitScalar(u8, it.only_arg, ',');
while (split_it.next()) |linker_arg| {
// Handle nested-joined args like `-Wl,-rpath=foo`.
// Must be prefixed with 1 or 2 dashes.
@ -2183,17 +2183,17 @@ fn buildOutputType(
const next_arg = linker_args_it.nextOrFatal();
try symbol_wrap_set.put(arena, next_arg, {});
} else if (mem.startsWith(u8, arg, "/subsystem:")) {
var split_it = mem.splitBackwards(u8, arg, ":");
var split_it = mem.splitBackwardsScalar(u8, arg, ':');
subsystem = try parseSubSystem(split_it.first());
} else if (mem.startsWith(u8, arg, "/implib:")) {
var split_it = mem.splitBackwards(u8, arg, ":");
var split_it = mem.splitBackwardsScalar(u8, arg, ':');
emit_implib = .{ .yes = split_it.first() };
emit_implib_arg_provided = true;
} else if (mem.startsWith(u8, arg, "/pdb:")) {
var split_it = mem.splitBackwards(u8, arg, ":");
var split_it = mem.splitBackwardsScalar(u8, arg, ':');
pdb_out_path = split_it.first();
} else if (mem.startsWith(u8, arg, "/version:")) {
var split_it = mem.splitBackwards(u8, arg, ":");
var split_it = mem.splitBackwardsScalar(u8, arg, ':');
const version_arg = split_it.first();
version = std.builtin.Version.parse(version_arg) catch |err| {
fatal("unable to parse /version '{s}': {s}", .{ arg, @errorName(err) });
@ -3534,7 +3534,7 @@ const ModuleDepIterator = struct {
split: mem.SplitIterator(u8, .scalar),
fn init(deps_str: []const u8) ModuleDepIterator {
return .{ .split = mem.split(u8, deps_str, ",") };
return .{ .split = mem.splitScalar(u8, deps_str, ',') };
}
const Dependency = struct {

6
test/src/Cases.zig
View file

@ -877,7 +877,7 @@ const TestManifest = struct {
if (trimmed.len == 0) break;
// Parse key=value(s)
var kv_it = std.mem.split(u8, trimmed, "=");
var kv_it = std.mem.splitScalar(u8, trimmed, '=');
const key = kv_it.first();
try manifest.config_map.putNoClobber(key, kv_it.next() orelse return error.MissingValuesForConfig);
}
@ -895,7 +895,7 @@ const TestManifest = struct {
) ConfigValueIterator(T) {
const bytes = self.config_map.get(key) orelse TestManifestConfigDefaults.get(self.type, key);
return ConfigValueIterator(T){
.inner = std.mem.split(u8, bytes, ","),
.inner = std.mem.splitScalar(u8, bytes, ','),
};
}
@ -1399,7 +1399,7 @@ fn runOneCase(
// Render the expected lines into a string that we can compare verbatim.
var expected_generated = std.ArrayList(u8).init(arena);
var actual_line_it = std.mem.split(u8, actual_stderr.items, "\n");
var actual_line_it = std.mem.splitScalar(u8, actual_stderr.items, '\n');
for (expected_errors) |expect_line| {
const actual_line = actual_line_it.next() orelse {
try expected_generated.appendSlice(expect_line);

2
test/src/check-stack-trace.zig
View file

@ -27,7 +27,7 @@ pub fn main() !void {
var buf = std.ArrayList(u8).init(arena);
defer buf.deinit();
if (stderr.len != 0 and stderr[stderr.len - 1] == '\n') stderr = stderr[0 .. stderr.len - 1];
var it = mem.split(u8, stderr, "\n");
var it = mem.splitScalar(u8, stderr, '\n');
process_lines: while (it.next()) |line| {
if (line.len == 0) continue;

2
tools/gen_outline_atomics.zig
View file

@ -88,7 +88,7 @@ fn writeFunction(
\\ asm volatile (
\\
);
var iter = std.mem.split(u8, body, "\n");
var iter = std.mem.splitScalar(u8, body, '\n');
while (iter.next()) |line| {
try w.writeAll(" \\\\");
try w.writeAll(line);

2
tools/update_crc_catalog.zig
View file

@ -78,7 +78,7 @@ pub fn main() anyerror!void {
var residue: []const u8 = undefined;
var name: []const u8 = undefined;
var it = mem.split(u8, line, " ");
var it = mem.splitFull(u8, line, " ");
while (it.next()) |property| {
const i = mem.indexOf(u8, property, "=").?;
const key = property[0..i];

2
tools/update_spirv_features.zig
View file

@ -19,7 +19,7 @@ const Version = struct {
minor: u32,
fn parse(str: []const u8) !Version {
var it = std.mem.split(u8, str, ".");
var it = std.mem.splitScalar(u8, str, '.');
const major = it.first();
const minor = it.next() orelse return error.InvalidVersion;