Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

run zig fmt on some of the codebase

Browse Source 
See #1003
This commit is contained in:
Andrew Kelley 2018-05-26 18:16:39 -04:00
parent 118d41ef83
commit b184ae5ca5
28 changed files with 920 additions and 852 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
doc/docgen.zig
View File

@ -95,7 +95,7 @@ const Tokenizer = struct {
}; };
fn init(source_file_name: []const u8, buffer: []const u8) Tokenizer { fn init(source_file_name: []const u8, buffer: []const u8) Tokenizer {
return Tokenizer { return Tokenizer{
.buffer = buffer, .buffer = buffer,
.index = 0, .index = 0,
.state = State.Start, .state = State.Start,
@ -105,7 +105,7 @@ const Tokenizer = struct {
} }
fn next(self: &Tokenizer) Token { fn next(self: &Tokenizer) Token {
var result = Token { var result = Token{
.id = Token.Id.Eof, .id = Token.Id.Eof,
.start = self.index, .start = self.index,
.end = undefined, .end = undefined,
@ -197,7 +197,7 @@ const Tokenizer = struct {
}; };
fn getTokenLocation(self: &Tokenizer, token: &const Token) Location { fn getTokenLocation(self: &Tokenizer, token: &const Token) Location {
var loc = Location { var loc = Location{
.line = 0, .line = 0,
.column = 0, .column = 0,
.line_start = 0, .line_start = 0,
@ -346,7 +346,7 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
break; break;
}, },
Token.Id.Content => { Token.Id.Content => {
try nodes.append(Node {.Content = tokenizer.buffer[token.start..token.end] }); try nodes.append(Node{ .Content = tokenizer.buffer[token.start..token.end] });
}, },
Token.Id.BracketOpen => { Token.Id.BracketOpen => {
const tag_token = try eatToken(tokenizer, Token.Id.TagContent); const tag_token = try eatToken(tokenizer, Token.Id.TagContent);
@ -365,11 +365,13 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
header_stack_size += 1; header_stack_size += 1;
const urlized = try urlize(allocator, content); const urlized = try urlize(allocator, content);
try nodes.append(Node{.HeaderOpen = HeaderOpen { try nodes.append(Node{
.name = content, .HeaderOpen = HeaderOpen{
.url = urlized, .name = content,
.n = header_stack_size, .url = urlized,
}}); .n = header_stack_size,
},
});
if (try urls.put(urlized, tag_token)) |other_tag_token| { if (try urls.put(urlized, tag_token)) |other_tag_token| {
parseError(tokenizer, tag_token, "duplicate header url: #{}", urlized) catch {}; parseError(tokenizer, tag_token, "duplicate header url: #{}", urlized) catch {};
parseError(tokenizer, other_tag_token, "other tag here") catch {}; parseError(tokenizer, other_tag_token, "other tag here") catch {};
@ -407,14 +409,14 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
switch (see_also_tok.id) { switch (see_also_tok.id) {
Token.Id.TagContent => { Token.Id.TagContent => {
const content = tokenizer.buffer[see_also_tok.start..see_also_tok.end]; const content = tokenizer.buffer[see_also_tok.start..see_also_tok.end];
try list.append(SeeAlsoItem { try list.append(SeeAlsoItem{
.name = content, .name = content,
.token = see_also_tok, .token = see_also_tok,
}); });
}, },
Token.Id.Separator => {}, Token.Id.Separator => {},
Token.Id.BracketClose => { Token.Id.BracketClose => {
try nodes.append(Node {.SeeAlso = list.toOwnedSlice() } ); try nodes.append(Node{ .SeeAlso = list.toOwnedSlice() });
break; break;
}, },
else => return parseError(tokenizer, see_also_tok, "invalid see_also token"), else => return parseError(tokenizer, see_also_tok, "invalid see_also token"),
@ -438,8 +440,8 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
} }
}; };
try nodes.append(Node { try nodes.append(Node{
.Link = Link { .Link = Link{
.url = try urlize(allocator, url_name), .url = try urlize(allocator, url_name),
.name = name, .name = name,
.token = name_tok, .token = name_tok,
@ -463,24 +465,24 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
var code_kind_id: Code.Id = undefined; var code_kind_id: Code.Id = undefined;
var is_inline = false; var is_inline = false;
if (mem.eql(u8, code_kind_str, "exe")) { if (mem.eql(u8, code_kind_str, "exe")) {
code_kind_id = Code.Id { .Exe = ExpectedOutcome.Succeed }; code_kind_id = Code.Id{ .Exe = ExpectedOutcome.Succeed };
} else if (mem.eql(u8, code_kind_str, "exe_err")) { } else if (mem.eql(u8, code_kind_str, "exe_err")) {
code_kind_id = Code.Id { .Exe = ExpectedOutcome.Fail }; code_kind_id = Code.Id{ .Exe = ExpectedOutcome.Fail };
} else if (mem.eql(u8, code_kind_str, "test")) { } else if (mem.eql(u8, code_kind_str, "test")) {
code_kind_id = Code.Id.Test; code_kind_id = Code.Id.Test;
} else if (mem.eql(u8, code_kind_str, "test_err")) { } else if (mem.eql(u8, code_kind_str, "test_err")) {
code_kind_id = Code.Id { .TestError = name}; code_kind_id = Code.Id{ .TestError = name };
name = "test"; name = "test";
} else if (mem.eql(u8, code_kind_str, "test_safety")) { } else if (mem.eql(u8, code_kind_str, "test_safety")) {
code_kind_id = Code.Id { .TestSafety = name}; code_kind_id = Code.Id{ .TestSafety = name };
name = "test"; name = "test";
} else if (mem.eql(u8, code_kind_str, "obj")) { } else if (mem.eql(u8, code_kind_str, "obj")) {
code_kind_id = Code.Id { .Obj = null }; code_kind_id = Code.Id{ .Obj = null };
} else if (mem.eql(u8, code_kind_str, "obj_err")) { } else if (mem.eql(u8, code_kind_str, "obj_err")) {
code_kind_id = Code.Id { .Obj = name }; code_kind_id = Code.Id{ .Obj = name };
name = "test"; name = "test";
} else if (mem.eql(u8, code_kind_str, "syntax")) { } else if (mem.eql(u8, code_kind_str, "syntax")) {
code_kind_id = Code.Id { .Obj = null }; code_kind_id = Code.Id{ .Obj = null };
is_inline = true; is_inline = true;
} else { } else {
return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", code_kind_str); return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", code_kind_str);
@ -514,17 +516,20 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
return parseError(tokenizer, end_code_tag, "invalid token inside code_begin: {}", end_tag_name); return parseError(tokenizer, end_code_tag, "invalid token inside code_begin: {}", end_tag_name);
} }
_ = try eatToken(tokenizer, Token.Id.BracketClose); _ = try eatToken(tokenizer, Token.Id.BracketClose);
} else unreachable; // TODO issue #707 } else
try nodes.append(Node {.Code = Code { unreachable; // TODO issue #707
.id = code_kind_id, try nodes.append(Node{
.name = name, .Code = Code{
.source_token = source_token, .id = code_kind_id,
.is_inline = is_inline, .name = name,
.mode = mode, .source_token = source_token,
.link_objects = link_objects.toOwnedSlice(), .is_inline = is_inline,
.target_windows = target_windows, .mode = mode,
.link_libc = link_libc, .link_objects = link_objects.toOwnedSlice(),
}}); .target_windows = target_windows,
.link_libc = link_libc,
},
});
tokenizer.code_node_count += 1; tokenizer.code_node_count += 1;
} else { } else {
return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name); return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name);
@ -534,7 +539,7 @@ fn genToc(allocator: &mem.Allocator, tokenizer: &Tokenizer) !Toc {
} }
} }
return Toc { return Toc{
.nodes = nodes.toOwnedSlice(), .nodes = nodes.toOwnedSlice(),
.toc = toc_buf.toOwnedSlice(), .toc = toc_buf.toOwnedSlice(),
.urls = urls, .urls = urls,
@ -727,16 +732,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name); const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext); const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext);
try io.writeFile(allocator, tmp_source_file_name, trimmed_raw_source); try io.writeFile(allocator, tmp_source_file_name, trimmed_raw_source);
switch (code.id) { switch (code.id) {
Code.Id.Exe => |expected_outcome| { Code.Id.Exe => |expected_outcome| {
const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext); const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext);
const tmp_bin_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_bin_ext); const tmp_bin_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_bin_ext);
var build_args = std.ArrayList([]const u8).init(allocator); var build_args = std.ArrayList([]const u8).init(allocator);
defer build_args.deinit(); defer build_args.deinit();
try build_args.appendSlice([][]const u8 {zig_exe, try build_args.appendSlice([][]const u8{
"build-exe", tmp_source_file_name, zig_exe,
"--output", tmp_bin_file_name, "build-exe",
tmp_source_file_name,
"--output",
tmp_bin_file_name,
}); });
try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", code.name); try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", code.name);
switch (code.mode) { switch (code.mode) {
@ -766,10 +774,9 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
try build_args.append("c"); try build_args.append("c");
try out.print(" --library c"); try out.print(" --library c");
} }
_ = exec(allocator, build_args.toSliceConst()) catch return parseError( _ = exec(allocator, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
tokenizer, code.source_token, "example failed to compile");
const run_args = [][]const u8 {tmp_bin_file_name}; const run_args = [][]const u8{tmp_bin_file_name};
const result = if (expected_outcome == ExpectedOutcome.Fail) blk: { const result = if (expected_outcome == ExpectedOutcome.Fail) blk: {
const result = try os.ChildProcess.exec(allocator, run_args, null, null, max_doc_file_size); const result = try os.ChildProcess.exec(allocator, run_args, null, null, max_doc_file_size);
@ -777,7 +784,10 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
os.ChildProcess.Term.Exited => |exit_code| { os.ChildProcess.Term.Exited => |exit_code| {
if (exit_code == 0) { if (exit_code == 0) {
warn("{}\nThe following command incorrectly succeeded:\n", result.stderr); warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
for (run_args) |arg| warn("{} ", arg) else warn("\n"); for (run_args) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example incorrectly compiled"); return parseError(tokenizer, code.source_token, "example incorrectly compiled");
} }
}, },
@ -785,11 +795,9 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
} }
break :blk result; break :blk result;
} else blk: { } else blk: {
break :blk exec(allocator, run_args) catch return parseError( break :blk exec(allocator, run_args) catch return parseError(tokenizer, code.source_token, "example crashed");
tokenizer, code.source_token, "example crashed");
}; };
const escaped_stderr = try escapeHtml(allocator, result.stderr); const escaped_stderr = try escapeHtml(allocator, result.stderr);
const escaped_stdout = try escapeHtml(allocator, result.stdout); const escaped_stdout = try escapeHtml(allocator, result.stdout);
@ -802,7 +810,11 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
var test_args = std.ArrayList([]const u8).init(allocator); var test_args = std.ArrayList([]const u8).init(allocator);
defer test_args.deinit(); defer test_args.deinit();
try test_args.appendSlice([][]const u8 {zig_exe, "test", tmp_source_file_name}); try test_args.appendSlice([][]const u8{
zig_exe,
"test",
tmp_source_file_name,
});
try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name); try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
switch (code.mode) { switch (code.mode) {
builtin.Mode.Debug => {}, builtin.Mode.Debug => {},
@ -821,13 +833,15 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
} }
if (code.target_windows) { if (code.target_windows) {
try test_args.appendSlice([][]const u8{ try test_args.appendSlice([][]const u8{
"--target-os", "windows", "--target-os",
"--target-arch", "x86_64", "windows",
"--target-environ", "msvc", "--target-arch",
"x86_64",
"--target-environ",
"msvc",
}); });
} }
const result = exec(allocator, test_args.toSliceConst()) catch return parseError( const result = exec(allocator, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
tokenizer, code.source_token, "test failed");
const escaped_stderr = try escapeHtml(allocator, result.stderr); const escaped_stderr = try escapeHtml(allocator, result.stderr);
const escaped_stdout = try escapeHtml(allocator, result.stdout); const escaped_stdout = try escapeHtml(allocator, result.stdout);
try out.print("\n{}{}</code></pre>\n", escaped_stderr, escaped_stdout); try out.print("\n{}{}</code></pre>\n", escaped_stderr, escaped_stdout);
@ -836,7 +850,13 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
var test_args = std.ArrayList([]const u8).init(allocator); var test_args = std.ArrayList([]const u8).init(allocator);
defer test_args.deinit(); defer test_args.deinit();
try test_args.appendSlice([][]const u8 {zig_exe, "test", "--color", "on", tmp_source_file_name}); try test_args.appendSlice([][]const u8{
zig_exe,
"test",
"--color",
"on",
tmp_source_file_name,
});
try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name); try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
switch (code.mode) { switch (code.mode) {
builtin.Mode.Debug => {}, builtin.Mode.Debug => {},
@ -858,13 +878,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
os.ChildProcess.Term.Exited => |exit_code| { os.ChildProcess.Term.Exited => |exit_code| {
if (exit_code == 0) { if (exit_code == 0) {
warn("{}\nThe following command incorrectly succeeded:\n", result.stderr); warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (test_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example incorrectly compiled"); return parseError(tokenizer, code.source_token, "example incorrectly compiled");
} }
}, },
else => { else => {
warn("{}\nThe following command crashed:\n", result.stderr); warn("{}\nThe following command crashed:\n", result.stderr);
for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (test_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example compile crashed"); return parseError(tokenizer, code.source_token, "example compile crashed");
}, },
} }
@ -881,7 +907,11 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
var test_args = std.ArrayList([]const u8).init(allocator); var test_args = std.ArrayList([]const u8).init(allocator);
defer test_args.deinit(); defer test_args.deinit();
try test_args.appendSlice([][]const u8 {zig_exe, "test", tmp_source_file_name}); try test_args.appendSlice([][]const u8{
zig_exe,
"test",
tmp_source_file_name,
});
switch (code.mode) { switch (code.mode) {
builtin.Mode.Debug => {}, builtin.Mode.Debug => {},
builtin.Mode.ReleaseSafe => try test_args.append("--release-safe"), builtin.Mode.ReleaseSafe => try test_args.append("--release-safe"),
@ -894,13 +924,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
os.ChildProcess.Term.Exited => |exit_code| { os.ChildProcess.Term.Exited => |exit_code| {
if (exit_code == 0) { if (exit_code == 0) {
warn("{}\nThe following command incorrectly succeeded:\n", result.stderr); warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (test_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example test incorrectly succeeded"); return parseError(tokenizer, code.source_token, "example test incorrectly succeeded");
} }
}, },
else => { else => {
warn("{}\nThe following command crashed:\n", result.stderr); warn("{}\nThe following command crashed:\n", result.stderr);
for (test_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (test_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example compile crashed"); return parseError(tokenizer, code.source_token, "example compile crashed");
}, },
} }
@ -918,9 +954,15 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
var build_args = std.ArrayList([]const u8).init(allocator); var build_args = std.ArrayList([]const u8).init(allocator);
defer build_args.deinit(); defer build_args.deinit();
try build_args.appendSlice([][]const u8 {zig_exe, "build-obj", tmp_source_file_name, try build_args.appendSlice([][]const u8{
"--color", "on", zig_exe,
"--output", tmp_obj_file_name}); "build-obj",
tmp_source_file_name,
"--color",
"on",
"--output",
tmp_obj_file_name,
});
if (!code.is_inline) { if (!code.is_inline) {
try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", code.name); try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", code.name);
@ -954,13 +996,19 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
os.ChildProcess.Term.Exited => |exit_code| { os.ChildProcess.Term.Exited => |exit_code| {
if (exit_code == 0) { if (exit_code == 0) {
warn("{}\nThe following command incorrectly succeeded:\n", result.stderr); warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
for (build_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (build_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example build incorrectly succeeded"); return parseError(tokenizer, code.source_token, "example build incorrectly succeeded");
} }
}, },
else => { else => {
warn("{}\nThe following command crashed:\n", result.stderr); warn("{}\nThe following command crashed:\n", result.stderr);
for (build_args.toSliceConst()) |arg| warn("{} ", arg) else warn("\n"); for (build_args.toSliceConst()) |arg|
warn("{} ", arg)
else
warn("\n");
return parseError(tokenizer, code.source_token, "example compile crashed"); return parseError(tokenizer, code.source_token, "example compile crashed");
}, },
} }
@ -975,8 +1023,7 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
try out.print("</code></pre>\n"); try out.print("</code></pre>\n");
} }
} else { } else {
_ = exec(allocator, build_args.toSliceConst()) catch return parseError( _ = exec(allocator, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
tokenizer, code.source_token, "example failed to compile");
} }
if (!code.is_inline) { if (!code.is_inline) {
try out.print("</code></pre>\n"); try out.print("</code></pre>\n");
@ -987,7 +1034,6 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
}, },
} }
} }
} }
fn exec(allocator: &mem.Allocator, args: []const []const u8) !os.ChildProcess.ExecResult { fn exec(allocator: &mem.Allocator, args: []const []const u8) !os.ChildProcess.ExecResult {
@ -996,13 +1042,19 @@ fn exec(allocator: &mem.Allocator, args: []const []const u8) !os.ChildProcess.Ex
os.ChildProcess.Term.Exited => |exit_code| { os.ChildProcess.Term.Exited => |exit_code| {
if (exit_code != 0) { if (exit_code != 0) {
warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code); warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);
for (args) |arg| warn("{} ", arg) else warn("\n"); for (args) |arg|
warn("{} ", arg)
else
warn("\n");
return error.ChildExitError; return error.ChildExitError;
} }
}, },
else => { else => {
warn("{}\nThe following command crashed:\n", result.stderr); warn("{}\nThe following command crashed:\n", result.stderr);
for (args) |arg| warn("{} ", arg) else warn("\n"); for (args) |arg|
warn("{} ", arg)
else
warn("\n");
return error.ChildCrashed; return error.ChildCrashed;
}, },
} }

2
example/guess_number/main.zig
View File

@ -23,7 +23,7 @@ pub fn main() !void {
while (true) { while (true) {
try stdout.print("\nGuess a number between 1 and 100: "); try stdout.print("\nGuess a number between 1 and 100: ");
var line_buf : [20]u8 = undefined; var line_buf: [20]u8 = undefined;
const line_len = io.readLine(line_buf[0..]) catch |err| switch (err) { const line_len = io.readLine(line_buf[0..]) catch |err| switch (err) {
error.InputTooLong => { error.InputTooLong => {

3
example/hello_world/hello_libc.zig
View File

@ -8,8 +8,7 @@ const c = @cImport({
const msg = c"Hello, world!\n"; const msg = c"Hello, world!\n";
export fn main(argc: c_int, argv: &&u8) c_int { export fn main(argc: c_int, argv: &&u8) c_int {
if (c.printf(msg) != c_int(c.strlen(msg))) if (c.printf(msg) != c_int(c.strlen(msg))) return -1;
return -1;
return 0; return 0;
} }

4
example/mix_o_files/build.zig
View File

@ -4,9 +4,7 @@ pub fn build(b: &Builder) void {
const obj = b.addObject("base64", "base64.zig"); const obj = b.addObject("base64", "base64.zig");
const exe = b.addCExecutable("test"); const exe = b.addCExecutable("test");
exe.addCompileFlags([][]const u8 { exe.addCompileFlags([][]const u8{"-std=c99"});
"-std=c99",
});
exe.addSourceFile("test.c"); exe.addSourceFile("test.c");
exe.addObject(obj); exe.addObject(obj);

4
example/shared_library/build.zig
View File

@ -4,9 +4,7 @@ pub fn build(b: &Builder) void {
const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0)); const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));
const exe = b.addCExecutable("test"); const exe = b.addCExecutable("test");
exe.addCompileFlags([][]const u8 { exe.addCompileFlags([][]const u8{"-std=c99"});
"-std=c99",
});
exe.addSourceFile("test.c"); exe.addSourceFile("test.c");
exe.linkLibrary(lib); exe.linkLibrary(lib);

4
src-self-hosted/introspect.zig
View File

@ -48,9 +48,7 @@ pub fn resolveZigLibDir(allocator: &mem.Allocator) ![]u8 {
\\Unable to find zig lib directory: {}. \\Unable to find zig lib directory: {}.
\\Reinstall Zig or use --zig-install-prefix. \\Reinstall Zig or use --zig-install-prefix.
\\ \\
, , @errorName(err));
@errorName(err)
);
return error.ZigLibDirNotFound; return error.ZigLibDirNotFound;
}; };

1
src-self-hosted/ir.zig
View File

@ -108,5 +108,4 @@ pub const Instruction = struct {
ArgType, ArgType,
Export, Export,
}; };
}; };

169
src-self-hosted/main.zig
View File

@ -37,7 +37,7 @@ const usage =
\\ zen Print zen of zig and exit \\ zen Print zen of zig and exit
\\ \\
\\ \\
; ;
const Command = struct { const Command = struct {
name: []const u8, name: []const u8,
@ -63,22 +63,61 @@ pub fn main() !void {
os.exit(1); os.exit(1);
} }
const commands = []Command { const commands = []Command{
Command { .name = "build", .exec = cmdBuild }, Command{
Command { .name = "build-exe", .exec = cmdBuildExe }, .name = "build",
Command { .name = "build-lib", .exec = cmdBuildLib }, .exec = cmdBuild,
Command { .name = "build-obj", .exec = cmdBuildObj }, },
Command { .name = "fmt", .exec = cmdFmt }, Command{
Command { .name = "run", .exec = cmdRun }, .name = "build-exe",
Command { .name = "targets", .exec = cmdTargets }, .exec = cmdBuildExe,
Command { .name = "test", .exec = cmdTest }, },
Command { .name = "translate-c", .exec = cmdTranslateC }, Command{
Command { .name = "version", .exec = cmdVersion }, .name = "build-lib",
Command { .name = "zen", .exec = cmdZen }, .exec = cmdBuildLib,
},
Command{
.name = "build-obj",
.exec = cmdBuildObj,
},
Command{
.name = "fmt",
.exec = cmdFmt,
},
Command{
.name = "run",
.exec = cmdRun,
},
Command{
.name = "targets",
.exec = cmdTargets,
},
Command{
.name = "test",
.exec = cmdTest,
},
Command{
.name = "translate-c",
.exec = cmdTranslateC,
},
Command{
.name = "version",
.exec = cmdVersion,
},
Command{
.name = "zen",
.exec = cmdZen,
},
// undocumented commands // undocumented commands
Command { .name = "help", .exec = cmdHelp }, Command{
Command { .name = "internal", .exec = cmdInternal }, .name = "help",
.exec = cmdHelp,
},
Command{
.name = "internal",
.exec = cmdInternal,
},
}; };
for (commands) |command| { for (commands) |command| {
@ -120,9 +159,9 @@ const usage_build =
\\ --verbose-cimport Enable compiler debug output for C imports \\ --verbose-cimport Enable compiler debug output for C imports
\\ \\
\\ \\
; ;
const args_build_spec = []Flag { const args_build_spec = []Flag{
Flag.Bool("--help"), Flag.Bool("--help"),
Flag.Bool("--init"), Flag.Bool("--init"),
Flag.Arg1("--build-file"), Flag.Arg1("--build-file"),
@ -148,7 +187,7 @@ const missing_build_file =
\\ \\
\\See: `zig build --help` or `zig help` for more options. \\See: `zig build --help` or `zig help` for more options.
\\ \\
; ;
fn cmdBuild(allocator: &Allocator, args: []const []const u8) !void { fn cmdBuild(allocator: &Allocator, args: []const []const u8) !void {
var flags = try Args.parse(allocator, args_build_spec, args); var flags = try Args.parse(allocator, args_build_spec, args);
@ -317,15 +356,23 @@ const usage_build_generic =
\\ --ver-patch [ver] Dynamic library semver patch version \\ --ver-patch [ver] Dynamic library semver patch version
\\ \\
\\ \\
; ;
const args_build_generic = []Flag { const args_build_generic = []Flag{
Flag.Bool("--help"), Flag.Bool("--help"),
Flag.Option("--color", []const []const u8 { "auto", "off", "on" }), Flag.Option("--color", []const []const u8{
"auto",
"off",
"on",
}),
Flag.ArgMergeN("--assembly", 1), Flag.ArgMergeN("--assembly", 1),
Flag.Arg1("--cache-dir"), Flag.Arg1("--cache-dir"),
Flag.Option("--emit", []const []const u8 { "asm", "bin", "llvm-ir" }), Flag.Option("--emit", []const []const u8{
"asm",
"bin",
"llvm-ir",
}),
Flag.Bool("--enable-timing-info"), Flag.Bool("--enable-timing-info"),
Flag.Arg1("--libc-include-dir"), Flag.Arg1("--libc-include-dir"),
Flag.Arg1("--name"), Flag.Arg1("--name"),
@ -471,7 +518,7 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
os.exit(1); os.exit(1);
}; };
const asm_a= flags.many("assembly"); const asm_a = flags.many("assembly");
const obj_a = flags.many("object"); const obj_a = flags.many("object");
if (in_file == null and (obj_a == null or (??obj_a).len == 0) and (asm_a == null or (??asm_a).len == 0)) { if (in_file == null and (obj_a == null or (??obj_a).len == 0) and (asm_a == null or (??asm_a).len == 0)) {
try stderr.write("Expected source file argument or at least one --object or --assembly argument\n"); try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");
@ -493,17 +540,16 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch os.exit(1); const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch os.exit(1);
defer allocator.free(zig_lib_dir); defer allocator.free(zig_lib_dir);
var module = var module = try Module.create(
try Module.create( allocator,
allocator, root_name,
root_name, zig_root_source_file,
zig_root_source_file, Target.Native,
Target.Native, out_type,
out_type, build_mode,
build_mode, zig_lib_dir,
zig_lib_dir, full_cache_dir,
full_cache_dir );
);
defer module.destroy(); defer module.destroy();
module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") ?? "0", 10); module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") ?? "0", 10);
@ -588,10 +634,10 @@ fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Mo
} }
if (flags.single("mmacosx-version-min")) |ver| { if (flags.single("mmacosx-version-min")) |ver| {
module.darwin_version_min = Module.DarwinVersionMin { .MacOS = ver }; module.darwin_version_min = Module.DarwinVersionMin{ .MacOS = ver };
} }
if (flags.single("mios-version-min")) |ver| { if (flags.single("mios-version-min")) |ver| {
module.darwin_version_min = Module.DarwinVersionMin { .Ios = ver }; module.darwin_version_min = Module.DarwinVersionMin{ .Ios = ver };
} }
module.emit_file_type = emit_type; module.emit_file_type = emit_type;
@ -639,11 +685,9 @@ const usage_fmt =
\\ --help Print this help and exit \\ --help Print this help and exit
\\ \\
\\ \\
; ;
const args_fmt_spec = []Flag { const args_fmt_spec = []Flag{Flag.Bool("--help")};
Flag.Bool("--help"),
};
fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void { fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void {
var flags = try Args.parse(allocator, args_fmt_spec, args); var flags = try Args.parse(allocator, args_fmt_spec, args);
@ -675,7 +719,6 @@ fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void {
}; };
defer tree.deinit(); defer tree.deinit();
var error_it = tree.errors.iterator(0); var error_it = tree.errors.iterator(0);
while (error_it.next()) |parse_error| { while (error_it.next()) |parse_error| {
const token = tree.tokens.at(parse_error.loc()); const token = tree.tokens.at(parse_error.loc());
@ -721,8 +764,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
inline while (i < @memberCount(builtin.Arch)) : (i += 1) { inline while (i < @memberCount(builtin.Arch)) : (i += 1) {
comptime const arch_tag = @memberName(builtin.Arch, i); comptime const arch_tag = @memberName(builtin.Arch, i);
// NOTE: Cannot use empty string, see #918. // NOTE: Cannot use empty string, see #918.
comptime const native_str = comptime const native_str = if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
try stdout.print(" {}{}", arch_tag, native_str); try stdout.print(" {}{}", arch_tag, native_str);
} }
@ -735,8 +777,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
inline while (i < @memberCount(builtin.Os)) : (i += 1) { inline while (i < @memberCount(builtin.Os)) : (i += 1) {
comptime const os_tag = @memberName(builtin.Os, i); comptime const os_tag = @memberName(builtin.Os, i);
// NOTE: Cannot use empty string, see #918. // NOTE: Cannot use empty string, see #918.
comptime const native_str = comptime const native_str = if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
try stdout.print(" {}{}", os_tag, native_str); try stdout.print(" {}{}", os_tag, native_str);
} }
@ -749,8 +790,7 @@ fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
inline while (i < @memberCount(builtin.Environ)) : (i += 1) { inline while (i < @memberCount(builtin.Environ)) : (i += 1) {
comptime const environ_tag = @memberName(builtin.Environ, i); comptime const environ_tag = @memberName(builtin.Environ, i);
// NOTE: Cannot use empty string, see #918. // NOTE: Cannot use empty string, see #918.
comptime const native_str = comptime const native_str = if (comptime mem.eql(u8, environ_tag, @tagName(builtin.environ))) " (native)\n" else "\n";
if (comptime mem.eql(u8, environ_tag, @tagName(builtin.environ))) " (native)\n" else "\n";
try stdout.print(" {}{}", environ_tag, native_str); try stdout.print(" {}{}", environ_tag, native_str);
} }
@ -772,12 +812,9 @@ const usage_test =
\\ --help Print this help and exit \\ --help Print this help and exit
\\ \\
\\ \\
; ;
const args_test_spec = []Flag {
Flag.Bool("--help"),
};
const args_test_spec = []Flag{Flag.Bool("--help")};
fn cmdTest(allocator: &Allocator, args: []const []const u8) !void { fn cmdTest(allocator: &Allocator, args: []const []const u8) !void {
var flags = try Args.parse(allocator, args_build_spec, args); var flags = try Args.parse(allocator, args_build_spec, args);
@ -810,21 +847,18 @@ const usage_run =
\\ --help Print this help and exit \\ --help Print this help and exit
\\ \\
\\ \\
; ;
const args_run_spec = []Flag {
Flag.Bool("--help"),
};
const args_run_spec = []Flag{Flag.Bool("--help")};
fn cmdRun(allocator: &Allocator, args: []const []const u8) !void { fn cmdRun(allocator: &Allocator, args: []const []const u8) !void {
var compile_args = args; var compile_args = args;
var runtime_args: []const []const u8 = []const []const u8 {}; var runtime_args: []const []const u8 = []const []const u8{};
for (args) |argv, i| { for (args) |argv, i| {
if (mem.eql(u8, argv, "--")) { if (mem.eql(u8, argv, "--")) {
compile_args = args[0..i]; compile_args = args[0..i];
runtime_args = args[i+1..]; runtime_args = args[i + 1..];
break; break;
} }
} }
@ -858,9 +892,9 @@ const usage_translate_c =
\\ --output [path] Output file to write generated zig file (default: stdout) \\ --output [path] Output file to write generated zig file (default: stdout)
\\ \\
\\ \\
; ;
const args_translate_c_spec = []Flag { const args_translate_c_spec = []Flag{
Flag.Bool("--help"), Flag.Bool("--help"),
Flag.Bool("--enable-timing-info"), Flag.Bool("--enable-timing-info"),
Flag.Arg1("--libc-include-dir"), Flag.Arg1("--libc-include-dir"),
@ -934,7 +968,7 @@ const info_zen =
\\ * Together we serve end users. \\ * Together we serve end users.
\\ \\
\\ \\
; ;
fn cmdZen(allocator: &Allocator, args: []const []const u8) !void { fn cmdZen(allocator: &Allocator, args: []const []const u8) !void {
try stdout.write(info_zen); try stdout.write(info_zen);
@ -949,7 +983,7 @@ const usage_internal =
\\ build-info Print static compiler build-info \\ build-info Print static compiler build-info
\\ \\
\\ \\
; ;
fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void { fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void {
if (args.len == 0) { if (args.len == 0) {
@ -957,9 +991,10 @@ fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void {
os.exit(1); os.exit(1);
} }
const sub_commands = []Command { const sub_commands = []Command{Command{
Command { .name = "build-info", .exec = cmdInternalBuildInfo }, .name = "build-info",
}; .exec = cmdInternalBuildInfo,
}};
for (sub_commands) |sub_command| { for (sub_commands) |sub_command| {
if (mem.eql(u8, sub_command.name, args[0])) { if (mem.eql(u8, sub_command.name, args[0])) {
@ -983,7 +1018,7 @@ fn cmdInternalBuildInfo(allocator: &Allocator, args: []const []const u8) !void {
\\ZIG_C_HEADER_FILES {} \\ZIG_C_HEADER_FILES {}
\\ZIG_DIA_GUIDS_LIB {} \\ZIG_DIA_GUIDS_LIB {}
\\ \\
, ,
std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR), std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
std.cstr.toSliceConst(c.ZIG_CXX_COMPILER), std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
std.cstr.toSliceConst(c.ZIG_LLVM_CONFIG_EXE), std.cstr.toSliceConst(c.ZIG_LLVM_CONFIG_EXE),

3
src-self-hosted/target.zig
View File

@ -38,8 +38,7 @@ pub const Target = union(enum) {
pub fn isDarwin(self: &const Target) bool { pub fn isDarwin(self: &const Target) bool {
return switch (self.getOs()) { return switch (self.getOs()) {
builtin.Os.ios, builtin.Os.ios, builtin.Os.macosx => true,
builtin.Os.macosx => true,
else => false, else => false,
}; };
} }

9
std/array_list.zig
View File

@ -150,7 +150,10 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
}; };
pub fn iterator(self: &const Self) Iterator { pub fn iterator(self: &const Self) Iterator {
return Iterator { .list = self, .count = 0 }; return Iterator{
.list = self,
.count = 0,
};
} }
}; };
} }
@ -207,7 +210,7 @@ test "iterator ArrayList test" {
try list.append(2); try list.append(2);
try list.append(3); try list.append(3);
var count : i32 = 0; var count: i32 = 0;
var it = list.iterator(); var it = list.iterator();
while (it.next()) |next| { while (it.next()) |next| {
assert(next == count + 1); assert(next == count + 1);
@ -225,7 +228,7 @@ test "iterator ArrayList test" {
} }
it.reset(); it.reset();
assert(?? it.next() == 1); assert(??it.next() == 1);
} }
test "insert ArrayList test" { test "insert ArrayList test" {

117
std/base64.zig
View File

@ -41,12 +41,10 @@ pub const Base64Encoder = struct {
dest[out_index] = encoder.alphabet_chars[(source[i] >> 2) & 0x3f]; dest[out_index] = encoder.alphabet_chars[(source[i] >> 2) & 0x3f];
out_index += 1; out_index += 1;
dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
((source[i + 1] & 0xf0) >> 4)];
out_index += 1; out_index += 1;
dest[out_index] = encoder.alphabet_chars[((source[i + 1] & 0xf) << 2) | dest[out_index] = encoder.alphabet_chars[((source[i + 1] & 0xf) << 2) | ((source[i + 2] & 0xc0) >> 6)];
((source[i + 2] & 0xc0) >> 6)];
out_index += 1; out_index += 1;
dest[out_index] = encoder.alphabet_chars[source[i + 2] & 0x3f]; dest[out_index] = encoder.alphabet_chars[source[i + 2] & 0x3f];
@ -64,8 +62,7 @@ pub const Base64Encoder = struct {
dest[out_index] = encoder.pad_char; dest[out_index] = encoder.pad_char;
out_index += 1; out_index += 1;
} else { } else {
dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | dest[out_index] = encoder.alphabet_chars[((source[i] & 0x3) << 4) | ((source[i + 1] & 0xf0) >> 4)];
((source[i + 1] & 0xf0) >> 4)];
out_index += 1; out_index += 1;
dest[out_index] = encoder.alphabet_chars[(source[i + 1] & 0xf) << 2]; dest[out_index] = encoder.alphabet_chars[(source[i + 1] & 0xf) << 2];
@ -131,26 +128,20 @@ pub const Base64Decoder = struct {
// common case // common case
if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter; if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
if (!decoder.char_in_alphabet[source[src_cursor + 3]]) return error.InvalidCharacter; if (!decoder.char_in_alphabet[source[src_cursor + 3]]) return error.InvalidCharacter;
dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
decoder.char_to_index[source[src_cursor + 1]] >> 4; dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | dest[dest_cursor + 2] = decoder.char_to_index[source[src_cursor + 2]] << 6 | decoder.char_to_index[source[src_cursor + 3]];
decoder.char_to_index[source[src_cursor + 2]] >> 2;
dest[dest_cursor + 2] = decoder.char_to_index[source[src_cursor + 2]] << 6 |
decoder.char_to_index[source[src_cursor + 3]];
dest_cursor += 3; dest_cursor += 3;
} else if (source[src_cursor + 2] != decoder.pad_char) { } else if (source[src_cursor + 2] != decoder.pad_char) {
// one pad char // one pad char
if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter; if (!decoder.char_in_alphabet[source[src_cursor + 2]]) return error.InvalidCharacter;
dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
decoder.char_to_index[source[src_cursor + 1]] >> 4; dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 | decoder.char_to_index[source[src_cursor + 2]] >> 2;
dest[dest_cursor + 1] = decoder.char_to_index[source[src_cursor + 1]] << 4 |
decoder.char_to_index[source[src_cursor + 2]] >> 2;
if (decoder.char_to_index[source[src_cursor + 2]] << 6 != 0) return error.InvalidPadding; if (decoder.char_to_index[source[src_cursor + 2]] << 6 != 0) return error.InvalidPadding;
dest_cursor += 2; dest_cursor += 2;
} else { } else {
// two pad chars // two pad chars
dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[source[src_cursor + 0]] << 2 | decoder.char_to_index[source[src_cursor + 1]] >> 4;
decoder.char_to_index[source[src_cursor + 1]] >> 4;
if (decoder.char_to_index[source[src_cursor + 1]] << 4 != 0) return error.InvalidPadding; if (decoder.char_to_index[source[src_cursor + 1]] << 4 != 0) return error.InvalidPadding;
dest_cursor += 1; dest_cursor += 1;
} }
@ -165,7 +156,7 @@ pub const Base64DecoderWithIgnore = struct {
decoder: Base64Decoder, decoder: Base64Decoder,
char_is_ignored: [256]bool, char_is_ignored: [256]bool,
pub fn init(alphabet_chars: []const u8, pad_char: u8, ignore_chars: []const u8) Base64DecoderWithIgnore { pub fn init(alphabet_chars: []const u8, pad_char: u8, ignore_chars: []const u8) Base64DecoderWithIgnore {
var result = Base64DecoderWithIgnore { var result = Base64DecoderWithIgnore{
.decoder = Base64Decoder.init(alphabet_chars, pad_char), .decoder = Base64Decoder.init(alphabet_chars, pad_char),
.char_is_ignored = []bool{false} ** 256, .char_is_ignored = []bool{false} ** 256,
}; };
@ -223,10 +214,12 @@ pub const Base64DecoderWithIgnore = struct {
} else if (decoder_with_ignore.char_is_ignored[c]) { } else if (decoder_with_ignore.char_is_ignored[c]) {
// we can even ignore chars during the padding // we can even ignore chars during the padding
continue; continue;
} else return error.InvalidCharacter; } else
return error.InvalidCharacter;
} }
break; break;
} else return error.InvalidCharacter; } else
return error.InvalidCharacter;
} }
switch (available_chars) { switch (available_chars) {
@ -234,22 +227,17 @@ pub const Base64DecoderWithIgnore = struct {
// common case // common case
if (dest_cursor + 3 > dest.len) return error.OutputTooSmall; if (dest_cursor + 3 > dest.len) return error.OutputTooSmall;
assert(pad_char_count == 0); assert(pad_char_count == 0);
dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
decoder.char_to_index[next_4_chars[1]] >> 4; dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | dest[dest_cursor + 2] = decoder.char_to_index[next_4_chars[2]] << 6 | decoder.char_to_index[next_4_chars[3]];
decoder.char_to_index[next_4_chars[2]] >> 2;
dest[dest_cursor + 2] = decoder.char_to_index[next_4_chars[2]] << 6 |
decoder.char_to_index[next_4_chars[3]];
dest_cursor += 3; dest_cursor += 3;
continue; continue;
}, },
3 => { 3 => {
if (dest_cursor + 2 > dest.len) return error.OutputTooSmall; if (dest_cursor + 2 > dest.len) return error.OutputTooSmall;
if (pad_char_count != 1) return error.InvalidPadding; if (pad_char_count != 1) return error.InvalidPadding;
dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
decoder.char_to_index[next_4_chars[1]] >> 4; dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 | decoder.char_to_index[next_4_chars[2]] >> 2;
dest[dest_cursor + 1] = decoder.char_to_index[next_4_chars[1]] << 4 |
decoder.char_to_index[next_4_chars[2]] >> 2;
if (decoder.char_to_index[next_4_chars[2]] << 6 != 0) return error.InvalidPadding; if (decoder.char_to_index[next_4_chars[2]] << 6 != 0) return error.InvalidPadding;
dest_cursor += 2; dest_cursor += 2;
break; break;
@ -257,8 +245,7 @@ pub const Base64DecoderWithIgnore = struct {
2 => { 2 => {
if (dest_cursor + 1 > dest.len) return error.OutputTooSmall; if (dest_cursor + 1 > dest.len) return error.OutputTooSmall;
if (pad_char_count != 2) return error.InvalidPadding; if (pad_char_count != 2) return error.InvalidPadding;
dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | dest[dest_cursor + 0] = decoder.char_to_index[next_4_chars[0]] << 2 | decoder.char_to_index[next_4_chars[1]] >> 4;
decoder.char_to_index[next_4_chars[1]] >> 4;
if (decoder.char_to_index[next_4_chars[1]] << 4 != 0) return error.InvalidPadding; if (decoder.char_to_index[next_4_chars[1]] << 4 != 0) return error.InvalidPadding;
dest_cursor += 1; dest_cursor += 1;
break; break;
@ -280,7 +267,6 @@ pub const Base64DecoderWithIgnore = struct {
} }
}; };
pub const standard_decoder_unsafe = Base64DecoderUnsafe.init(standard_alphabet_chars, standard_pad_char); pub const standard_decoder_unsafe = Base64DecoderUnsafe.init(standard_alphabet_chars, standard_pad_char);
pub const Base64DecoderUnsafe = struct { pub const Base64DecoderUnsafe = struct {
@ -291,7 +277,7 @@ pub const Base64DecoderUnsafe = struct {
pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64DecoderUnsafe { pub fn init(alphabet_chars: []const u8, pad_char: u8) Base64DecoderUnsafe {
assert(alphabet_chars.len == 64); assert(alphabet_chars.len == 64);
var result = Base64DecoderUnsafe { var result = Base64DecoderUnsafe{
.char_to_index = undefined, .char_to_index = undefined,
.pad_char = pad_char, .pad_char = pad_char,
}; };
@ -321,16 +307,13 @@ pub const Base64DecoderUnsafe = struct {
} }
while (in_buf_len > 4) { while (in_buf_len > 4) {
dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
decoder.char_to_index[source[src_index + 1]] >> 4;
dest_index += 1; dest_index += 1;
dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
decoder.char_to_index[source[src_index + 2]] >> 2;
dest_index += 1; dest_index += 1;
dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
decoder.char_to_index[source[src_index + 3]];
dest_index += 1; dest_index += 1;
src_index += 4; src_index += 4;
@ -338,18 +321,15 @@ pub const Base64DecoderUnsafe = struct {
} }
if (in_buf_len > 1) { if (in_buf_len > 1) {
dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | dest[dest_index] = decoder.char_to_index[source[src_index + 0]] << 2 | decoder.char_to_index[source[src_index + 1]] >> 4;
decoder.char_to_index[source[src_index + 1]] >> 4;
dest_index += 1; dest_index += 1;
} }
if (in_buf_len > 2) { if (in_buf_len > 2) {
dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | dest[dest_index] = decoder.char_to_index[source[src_index + 1]] << 4 | decoder.char_to_index[source[src_index + 2]] >> 2;
decoder.char_to_index[source[src_index + 2]] >> 2;
dest_index += 1; dest_index += 1;
} }
if (in_buf_len > 3) { if (in_buf_len > 3) {
dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | dest[dest_index] = decoder.char_to_index[source[src_index + 2]] << 6 | decoder.char_to_index[source[src_index + 3]];
decoder.char_to_index[source[src_index + 3]];
dest_index += 1; dest_index += 1;
} }
} }
@ -367,7 +347,6 @@ fn calcDecodedSizeExactUnsafe(source: []const u8, pad_char: u8) usize {
return result; return result;
} }
test "base64" { test "base64" {
@setEvalBranchQuota(8000); @setEvalBranchQuota(8000);
testBase64() catch unreachable; testBase64() catch unreachable;
@ -375,26 +354,26 @@ test "base64" {
} }
fn testBase64() !void { fn testBase64() !void {
try testAllApis("", ""); try testAllApis("", "");
try testAllApis("f", "Zg=="); try testAllApis("f", "Zg==");
try testAllApis("fo", "Zm8="); try testAllApis("fo", "Zm8=");
try testAllApis("foo", "Zm9v"); try testAllApis("foo", "Zm9v");
try testAllApis("foob", "Zm9vYg=="); try testAllApis("foob", "Zm9vYg==");
try testAllApis("fooba", "Zm9vYmE="); try testAllApis("fooba", "Zm9vYmE=");
try testAllApis("foobar", "Zm9vYmFy"); try testAllApis("foobar", "Zm9vYmFy");
try testDecodeIgnoreSpace("", " "); try testDecodeIgnoreSpace("", " ");
try testDecodeIgnoreSpace("f", "Z g= ="); try testDecodeIgnoreSpace("f", "Z g= =");
try testDecodeIgnoreSpace("fo", " Zm8="); try testDecodeIgnoreSpace("fo", " Zm8=");
try testDecodeIgnoreSpace("foo", "Zm9v "); try testDecodeIgnoreSpace("foo", "Zm9v ");
try testDecodeIgnoreSpace("foob", "Zm9vYg = = "); try testDecodeIgnoreSpace("foob", "Zm9vYg = = ");
try testDecodeIgnoreSpace("fooba", "Zm9v YmE="); try testDecodeIgnoreSpace("fooba", "Zm9v YmE=");
try testDecodeIgnoreSpace("foobar", " Z m 9 v Y m F y "); try testDecodeIgnoreSpace("foobar", " Z m 9 v Y m F y ");
// test getting some api errors // test getting some api errors
try testError("A", error.InvalidPadding); try testError("A", error.InvalidPadding);
try testError("AA", error.InvalidPadding); try testError("AA", error.InvalidPadding);
try testError("AAA", error.InvalidPadding); try testError("AAA", error.InvalidPadding);
try testError("A..A", error.InvalidCharacter); try testError("A..A", error.InvalidCharacter);
try testError("AA=A", error.InvalidCharacter); try testError("AA=A", error.InvalidCharacter);
try testError("AA/=", error.InvalidPadding); try testError("AA/=", error.InvalidPadding);
@ -427,8 +406,7 @@ fn testAllApis(expected_decoded: []const u8, expected_encoded: []const u8) !void
// Base64DecoderWithIgnore // Base64DecoderWithIgnore
{ {
const standard_decoder_ignore_nothing = Base64DecoderWithIgnore.init( const standard_decoder_ignore_nothing = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, "");
standard_alphabet_chars, standard_pad_char, "");
var buffer: [0x100]u8 = undefined; var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(expected_encoded.len)]; var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(expected_encoded.len)];
var written = try standard_decoder_ignore_nothing.decode(decoded, expected_encoded); var written = try standard_decoder_ignore_nothing.decode(decoded, expected_encoded);
@ -446,8 +424,7 @@ fn testAllApis(expected_decoded: []const u8, expected_encoded: []const u8) !void
} }
fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !void { fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !void {
const standard_decoder_ignore_space = Base64DecoderWithIgnore.init( const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
standard_alphabet_chars, standard_pad_char, " ");
var buffer: [0x100]u8 = undefined; var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(encoded.len)]; var decoded = buffer[0..Base64DecoderWithIgnore.calcSizeUpperBound(encoded.len)];
var written = try standard_decoder_ignore_space.decode(decoded, encoded); var written = try standard_decoder_ignore_space.decode(decoded, encoded);
@ -455,8 +432,7 @@ fn testDecodeIgnoreSpace(expected_decoded: []const u8, encoded: []const u8) !voi
} }
fn testError(encoded: []const u8, expected_err: error) !void { fn testError(encoded: []const u8, expected_err: error) !void {
const standard_decoder_ignore_space = Base64DecoderWithIgnore.init( const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
standard_alphabet_chars, standard_pad_char, " ");
var buffer: [0x100]u8 = undefined; var buffer: [0x100]u8 = undefined;
if (standard_decoder.calcSize(encoded)) |decoded_size| { if (standard_decoder.calcSize(encoded)) |decoded_size| {
var decoded = buffer[0..decoded_size]; var decoded = buffer[0..decoded_size];
@ -471,8 +447,7 @@ fn testError(encoded: []const u8, expected_err: error) !void {
} }
fn testOutputTooSmallError(encoded: []const u8) !void { fn testOutputTooSmallError(encoded: []const u8) !void {
const standard_decoder_ignore_space = Base64DecoderWithIgnore.init( const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
standard_alphabet_chars, standard_pad_char, " ");
var buffer: [0x100]u8 = undefined; var buffer: [0x100]u8 = undefined;
var decoded = buffer[0..calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1]; var decoded = buffer[0..calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1];
if (standard_decoder_ignore_space.decode(decoded, encoded)) |_| { if (standard_decoder_ignore_space.decode(decoded, encoded)) |_| {

4
std/buf_map.zig
View File

@ -12,9 +12,7 @@ pub const BufMap = struct {
const BufMapHashMap = HashMap([]const u8, []const u8, mem.hash_slice_u8, mem.eql_slice_u8); const BufMapHashMap = HashMap([]const u8, []const u8, mem.hash_slice_u8, mem.eql_slice_u8);
pub fn init(allocator: &Allocator) BufMap { pub fn init(allocator: &Allocator) BufMap {
var self = BufMap { var self = BufMap{ .hash_map = BufMapHashMap.init(allocator) };
.hash_map = BufMapHashMap.init(allocator),
};
return self; return self;
} }

4
std/buf_set.zig
View File

@ -10,9 +10,7 @@ pub const BufSet = struct {
const BufSetHashMap = HashMap([]const u8, void, mem.hash_slice_u8, mem.eql_slice_u8); const BufSetHashMap = HashMap([]const u8, void, mem.hash_slice_u8, mem.eql_slice_u8);
pub fn init(a: &Allocator) BufSet { pub fn init(a: &Allocator) BufSet {
var self = BufSet { var self = BufSet{ .hash_map = BufSetHashMap.init(a) };
.hash_map = BufSetHashMap.init(a),
};
return self; return self;
} }

59
std/build.zig
View File

@ -420,15 +420,7 @@ pub const Builder = struct {
const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") ?? false; const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") ?? false;
const release_small = self.option(bool, "release-small", "size optimizations on and safety off") ?? false; const release_small = self.option(bool, "release-small", "size optimizations on and safety off") ?? false;
const mode = if (release_safe and !release_fast and !release_small) const mode = if (release_safe and !release_fast and !release_small) builtin.Mode.ReleaseSafe else if (release_fast and !release_safe and !release_small) builtin.Mode.ReleaseFast else if (release_small and !release_fast and !release_safe) builtin.Mode.ReleaseSmall else if (!release_fast and !release_safe and !release_small) builtin.Mode.Debug else x: {
builtin.Mode.ReleaseSafe
else if (release_fast and !release_safe and !release_small)
builtin.Mode.ReleaseFast
else if (release_small and !release_fast and !release_safe)
builtin.Mode.ReleaseSmall
else if (!release_fast and !release_safe and !release_small)
builtin.Mode.Debug
else x: {
warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)"); warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)");
self.markInvalidUserInput(); self.markInvalidUserInput();
break :x builtin.Mode.Debug; break :x builtin.Mode.Debug;
@ -649,11 +641,7 @@ pub const Builder = struct {
if (builtin.environ == builtin.Environ.msvc) { if (builtin.environ == builtin.Environ.msvc) {
return "cl.exe"; return "cl.exe";
} else { } else {
return os.getEnvVarOwned(self.allocator, "CC") catch |err| return os.getEnvVarOwned(self.allocator, "CC") catch |err| if (err == error.EnvironmentVariableNotFound) ([]const u8)("cc") else debug.panic("Unable to get environment variable: {}", err);
if (err == error.EnvironmentVariableNotFound)
([]const u8)("cc")
else
debug.panic("Unable to get environment variable: {}", err);
} }
} }
@ -782,8 +770,7 @@ pub const Target = union(enum) {
pub fn isDarwin(self: &const Target) bool { pub fn isDarwin(self: &const Target) bool {
return switch (self.getOs()) { return switch (self.getOs()) {
builtin.Os.ios, builtin.Os.ios, builtin.Os.macosx => true,
builtin.Os.macosx => true,
else => false, else => false,
}; };
} }
@ -990,8 +977,7 @@ pub const LibExeObjStep = struct {
self.out_filename = self.builder.fmt("lib{}.a", self.name); self.out_filename = self.builder.fmt("lib{}.a", self.name);
} else { } else {
switch (self.target.getOs()) { switch (self.target.getOs()) {
builtin.Os.ios, builtin.Os.ios, builtin.Os.macosx => {
builtin.Os.macosx => {
self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", self.name, self.version.major, self.version.minor, self.version.patch); self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", self.name, self.version.major, self.version.minor, self.version.patch);
self.major_only_filename = self.builder.fmt("lib{}.{d}.dylib", self.name, self.version.major); self.major_only_filename = self.builder.fmt("lib{}.{d}.dylib", self.name, self.version.major);
self.name_only_filename = self.builder.fmt("lib{}.dylib", self.name); self.name_only_filename = self.builder.fmt("lib{}.dylib", self.name);
@ -1011,11 +997,13 @@ pub const LibExeObjStep = struct {
} }
pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void { pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
self.target = Target{ .Cross = CrossTarget{ self.target = Target{
.arch = target_arch, .Cross = CrossTarget{
.os = target_os, .arch = target_arch,
.environ = target_environ, .os = target_os,
} }; .environ = target_environ,
},
};
self.computeOutFileNames(); self.computeOutFileNames();
} }
@ -1079,10 +1067,7 @@ pub const LibExeObjStep = struct {
} }
pub fn getOutputPath(self: &LibExeObjStep) []const u8 { pub fn getOutputPath(self: &LibExeObjStep) []const u8 {
return if (self.output_path) |output_path| return if (self.output_path) |output_path| output_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
output_path
else
os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
} }
pub fn setOutputHPath(self: &LibExeObjStep, file_path: []const u8) void { pub fn setOutputHPath(self: &LibExeObjStep, file_path: []const u8) void {
@ -1095,10 +1080,7 @@ pub const LibExeObjStep = struct {
} }
pub fn getOutputHPath(self: &LibExeObjStep) []const u8 { pub fn getOutputHPath(self: &LibExeObjStep) []const u8 {
return if (self.output_h_path) |output_h_path| return if (self.output_h_path) |output_h_path| output_h_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
output_h_path
else
os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
} }
pub fn addAssemblyFile(self: &LibExeObjStep, path: []const u8) void { pub fn addAssemblyFile(self: &LibExeObjStep, path: []const u8) void {
@ -1352,8 +1334,7 @@ pub const LibExeObjStep = struct {
args.append("ssp-buffer-size=4") catch unreachable; args.append("ssp-buffer-size=4") catch unreachable;
} }
}, },
builtin.Mode.ReleaseFast, builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {
builtin.Mode.ReleaseSmall => {
args.append("-O2") catch unreachable; args.append("-O2") catch unreachable;
args.append("-fno-stack-protector") catch unreachable; args.append("-fno-stack-protector") catch unreachable;
}, },
@ -1652,11 +1633,13 @@ pub const TestStep = struct {
} }
pub fn setTarget(self: &TestStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void { pub fn setTarget(self: &TestStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
self.target = Target{ .Cross = CrossTarget{ self.target = Target{
.arch = target_arch, .Cross = CrossTarget{
.os = target_os, .arch = target_arch,
.environ = target_environ, .os = target_os,
} }; .environ = target_environ,
},
};
} }
pub fn setExecCmd(self: &TestStep, args: []const ?[]const u8) void { pub fn setExecCmd(self: &TestStep, args: []const ?[]const u8) void {

2
std/c/darwin.zig
View File

@ -60,7 +60,7 @@ pub const sigset_t = u32;
/// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name. /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
pub const Sigaction = extern struct { pub const Sigaction = extern struct {
handler: extern fn(c_int)void, handler: extern fn(c_int) void,
sa_mask: sigset_t, sa_mask: sigset_t,
sa_flags: c_int, sa_flags: c_int,
}; };

12
std/c/index.zig
View File

@ -1,7 +1,7 @@
const builtin = @import("builtin"); const builtin = @import("builtin");
const Os = builtin.Os; const Os = builtin.Os;
pub use switch(builtin.os) { pub use switch (builtin.os) {
Os.linux => @import("linux.zig"), Os.linux => @import("linux.zig"),
Os.windows => @import("windows.zig"), Os.windows => @import("windows.zig"),
Os.macosx, Os.ios => @import("darwin.zig"), Os.macosx, Os.ios => @import("darwin.zig"),
@ -21,8 +21,7 @@ pub extern "c" fn raise(sig: c_int) c_int;
pub extern "c" fn read(fd: c_int, buf: &c_void, nbyte: usize) isize; pub extern "c" fn read(fd: c_int, buf: &c_void, nbyte: usize) isize;
pub extern "c" fn stat(noalias path: &const u8, noalias buf: &Stat) c_int; pub extern "c" fn stat(noalias path: &const u8, noalias buf: &Stat) c_int;
pub extern "c" fn write(fd: c_int, buf: &const c_void, nbyte: usize) isize; pub extern "c" fn write(fd: c_int, buf: &const c_void, nbyte: usize) isize;
pub extern "c" fn mmap(addr: ?&c_void, len: usize, prot: c_int, flags: c_int, pub extern "c" fn mmap(addr: ?&c_void, len: usize, prot: c_int, flags: c_int, fd: c_int, offset: isize) ?&c_void;
fd: c_int, offset: isize) ?&c_void;
pub extern "c" fn munmap(addr: &c_void, len: usize) c_int; pub extern "c" fn munmap(addr: &c_void, len: usize) c_int;
pub extern "c" fn unlink(path: &const u8) c_int; pub extern "c" fn unlink(path: &const u8) c_int;
pub extern "c" fn getcwd(buf: &u8, size: usize) ?&u8; pub extern "c" fn getcwd(buf: &u8, size: usize) ?&u8;
@ -34,8 +33,7 @@ pub extern "c" fn mkdir(path: &const u8, mode: c_uint) c_int;
pub extern "c" fn symlink(existing: &const u8, new: &const u8) c_int; pub extern "c" fn symlink(existing: &const u8, new: &const u8) c_int;
pub extern "c" fn rename(old: &const u8, new: &const u8) c_int; pub extern "c" fn rename(old: &const u8, new: &const u8) c_int;
pub extern "c" fn chdir(path: &const u8) c_int; pub extern "c" fn chdir(path: &const u8) c_int;
pub extern "c" fn execve(path: &const u8, argv: &const ?&const u8, pub extern "c" fn execve(path: &const u8, argv: &const ?&const u8, envp: &const ?&const u8) c_int;
envp: &const ?&const u8) c_int;
pub extern "c" fn dup(fd: c_int) c_int; pub extern "c" fn dup(fd: c_int) c_int;
pub extern "c" fn dup2(old_fd: c_int, new_fd: c_int) c_int; pub extern "c" fn dup2(old_fd: c_int, new_fd: c_int) c_int;
pub extern "c" fn readlink(noalias path: &const u8, noalias buf: &u8, bufsize: usize) isize; pub extern "c" fn readlink(noalias path: &const u8, noalias buf: &u8, bufsize: usize) isize;
@ -54,9 +52,7 @@ pub extern "c" fn realloc(&c_void, usize) ?&c_void;
pub extern "c" fn free(&c_void) void; pub extern "c" fn free(&c_void) void;
pub extern "c" fn posix_memalign(memptr: &&c_void, alignment: usize, size: usize) c_int; pub extern "c" fn posix_memalign(memptr: &&c_void, alignment: usize, size: usize) c_int;
pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t, pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t, noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void, noalias arg: ?&c_void) c_int;
noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void,
noalias arg: ?&c_void) c_int;
pub extern "pthread" fn pthread_attr_init(attr: &pthread_attr_t) c_int; pub extern "pthread" fn pthread_attr_init(attr: &pthread_attr_t) c_int;
pub extern "pthread" fn pthread_attr_setstack(attr: &pthread_attr_t, stackaddr: &c_void, stacksize: usize) c_int; pub extern "pthread" fn pthread_attr_setstack(attr: &pthread_attr_t, stackaddr: &c_void, stacksize: usize) c_int;
pub extern "pthread" fn pthread_attr_destroy(attr: &pthread_attr_t) c_int; pub extern "pthread" fn pthread_attr_destroy(attr: &pthread_attr_t) c_int;

138
std/crypto/md5.zig
View File

@ -6,12 +6,25 @@ const debug = @import("../debug/index.zig");
const fmt = @import("../fmt/index.zig"); const fmt = @import("../fmt/index.zig");
const RoundParam = struct { const RoundParam = struct {
a: usize, b: usize, c: usize, d: usize, a: usize,
k: usize, s: u32, t: u32 b: usize,
c: usize,
d: usize,
k: usize,
s: u32,
t: u32,
}; };
fn Rp(a: usize, b: usize, c: usize, d: usize, k: usize, s: u32, t: u32) RoundParam { fn Rp(a: usize, b: usize, c: usize, d: usize, k: usize, s: u32, t: u32) RoundParam {
return RoundParam { .a = a, .b = b, .c = c, .d = d, .k = k, .s = s, .t = t }; return RoundParam{
.a = a,
.b = b,
.c = c,
.d = d,
.k = k,
.s = s,
.t = t,
};
} }
pub const Md5 = struct { pub const Md5 = struct {
@ -99,7 +112,7 @@ pub const Md5 = struct {
d.round(d.buf[0..]); d.round(d.buf[0..]);
for (d.s) |s, j| { for (d.s) |s, j| {
mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Little); mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Little);
} }
} }
@ -112,30 +125,33 @@ pub const Md5 = struct {
while (i < 16) : (i += 1) { while (i < 16) : (i += 1) {
// NOTE: Performing or's separately improves perf by ~10% // NOTE: Performing or's separately improves perf by ~10%
s[i] = 0; s[i] = 0;
s[i] |= u32(b[i*4+0]); s[i] |= u32(b[i * 4 + 0]);
s[i] |= u32(b[i*4+1]) << 8; s[i] |= u32(b[i * 4 + 1]) << 8;
s[i] |= u32(b[i*4+2]) << 16; s[i] |= u32(b[i * 4 + 2]) << 16;
s[i] |= u32(b[i*4+3]) << 24; s[i] |= u32(b[i * 4 + 3]) << 24;
} }
var v: [4]u32 = []u32 { var v: [4]u32 = []u32{
d.s[0], d.s[1], d.s[2], d.s[3], d.s[0],
d.s[1],
d.s[2],
d.s[3],
}; };
const round0 = comptime []RoundParam { const round0 = comptime []RoundParam{
Rp(0, 1, 2, 3, 0, 7, 0xD76AA478), Rp(0, 1, 2, 3, 0, 7, 0xD76AA478),
Rp(3, 0, 1, 2, 1, 12, 0xE8C7B756), Rp(3, 0, 1, 2, 1, 12, 0xE8C7B756),
Rp(2, 3, 0, 1, 2, 17, 0x242070DB), Rp(2, 3, 0, 1, 2, 17, 0x242070DB),
Rp(1, 2, 3, 0, 3, 22, 0xC1BDCEEE), Rp(1, 2, 3, 0, 3, 22, 0xC1BDCEEE),
Rp(0, 1, 2, 3, 4, 7, 0xF57C0FAF), Rp(0, 1, 2, 3, 4, 7, 0xF57C0FAF),
Rp(3, 0, 1, 2, 5, 12, 0x4787C62A), Rp(3, 0, 1, 2, 5, 12, 0x4787C62A),
Rp(2, 3, 0, 1, 6, 17, 0xA8304613), Rp(2, 3, 0, 1, 6, 17, 0xA8304613),
Rp(1, 2, 3, 0, 7, 22, 0xFD469501), Rp(1, 2, 3, 0, 7, 22, 0xFD469501),
Rp(0, 1, 2, 3, 8, 7, 0x698098D8), Rp(0, 1, 2, 3, 8, 7, 0x698098D8),
Rp(3, 0, 1, 2, 9, 12, 0x8B44F7AF), Rp(3, 0, 1, 2, 9, 12, 0x8B44F7AF),
Rp(2, 3, 0, 1, 10, 17, 0xFFFF5BB1), Rp(2, 3, 0, 1, 10, 17, 0xFFFF5BB1),
Rp(1, 2, 3, 0, 11, 22, 0x895CD7BE), Rp(1, 2, 3, 0, 11, 22, 0x895CD7BE),
Rp(0, 1, 2, 3, 12, 7, 0x6B901122), Rp(0, 1, 2, 3, 12, 7, 0x6B901122),
Rp(3, 0, 1, 2, 13, 12, 0xFD987193), Rp(3, 0, 1, 2, 13, 12, 0xFD987193),
Rp(2, 3, 0, 1, 14, 17, 0xA679438E), Rp(2, 3, 0, 1, 14, 17, 0xA679438E),
Rp(1, 2, 3, 0, 15, 22, 0x49B40821), Rp(1, 2, 3, 0, 15, 22, 0x49B40821),
@ -145,22 +161,22 @@ pub const Md5 = struct {
v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s); v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
} }
const round1 = comptime []RoundParam { const round1 = comptime []RoundParam{
Rp(0, 1, 2, 3, 1, 5, 0xF61E2562), Rp(0, 1, 2, 3, 1, 5, 0xF61E2562),
Rp(3, 0, 1, 2, 6, 9, 0xC040B340), Rp(3, 0, 1, 2, 6, 9, 0xC040B340),
Rp(2, 3, 0, 1, 11, 14, 0x265E5A51), Rp(2, 3, 0, 1, 11, 14, 0x265E5A51),
Rp(1, 2, 3, 0, 0, 20, 0xE9B6C7AA), Rp(1, 2, 3, 0, 0, 20, 0xE9B6C7AA),
Rp(0, 1, 2, 3, 5, 5, 0xD62F105D), Rp(0, 1, 2, 3, 5, 5, 0xD62F105D),
Rp(3, 0, 1, 2, 10, 9, 0x02441453), Rp(3, 0, 1, 2, 10, 9, 0x02441453),
Rp(2, 3, 0, 1, 15, 14, 0xD8A1E681), Rp(2, 3, 0, 1, 15, 14, 0xD8A1E681),
Rp(1, 2, 3, 0, 4, 20, 0xE7D3FBC8), Rp(1, 2, 3, 0, 4, 20, 0xE7D3FBC8),
Rp(0, 1, 2, 3, 9, 5, 0x21E1CDE6), Rp(0, 1, 2, 3, 9, 5, 0x21E1CDE6),
Rp(3, 0, 1, 2, 14, 9, 0xC33707D6), Rp(3, 0, 1, 2, 14, 9, 0xC33707D6),
Rp(2, 3, 0, 1, 3, 14, 0xF4D50D87), Rp(2, 3, 0, 1, 3, 14, 0xF4D50D87),
Rp(1, 2, 3, 0, 8, 20, 0x455A14ED), Rp(1, 2, 3, 0, 8, 20, 0x455A14ED),
Rp(0, 1, 2, 3, 13, 5, 0xA9E3E905), Rp(0, 1, 2, 3, 13, 5, 0xA9E3E905),
Rp(3, 0, 1, 2, 2, 9, 0xFCEFA3F8), Rp(3, 0, 1, 2, 2, 9, 0xFCEFA3F8),
Rp(2, 3, 0, 1, 7, 14, 0x676F02D9), Rp(2, 3, 0, 1, 7, 14, 0x676F02D9),
Rp(1, 2, 3, 0, 12, 20, 0x8D2A4C8A), Rp(1, 2, 3, 0, 12, 20, 0x8D2A4C8A),
}; };
inline for (round1) |r| { inline for (round1) |r| {
@ -168,46 +184,46 @@ pub const Md5 = struct {
v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s); v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
} }
const round2 = comptime []RoundParam { const round2 = comptime []RoundParam{
Rp(0, 1, 2, 3, 5, 4, 0xFFFA3942), Rp(0, 1, 2, 3, 5, 4, 0xFFFA3942),
Rp(3, 0, 1, 2, 8, 11, 0x8771F681), Rp(3, 0, 1, 2, 8, 11, 0x8771F681),
Rp(2, 3, 0, 1, 11, 16, 0x6D9D6122), Rp(2, 3, 0, 1, 11, 16, 0x6D9D6122),
Rp(1, 2, 3, 0, 14, 23, 0xFDE5380C), Rp(1, 2, 3, 0, 14, 23, 0xFDE5380C),
Rp(0, 1, 2, 3, 1, 4, 0xA4BEEA44), Rp(0, 1, 2, 3, 1, 4, 0xA4BEEA44),
Rp(3, 0, 1, 2, 4, 11, 0x4BDECFA9), Rp(3, 0, 1, 2, 4, 11, 0x4BDECFA9),
Rp(2, 3, 0, 1, 7, 16, 0xF6BB4B60), Rp(2, 3, 0, 1, 7, 16, 0xF6BB4B60),
Rp(1, 2, 3, 0, 10, 23, 0xBEBFBC70), Rp(1, 2, 3, 0, 10, 23, 0xBEBFBC70),
Rp(0, 1, 2, 3, 13, 4, 0x289B7EC6), Rp(0, 1, 2, 3, 13, 4, 0x289B7EC6),
Rp(3, 0, 1, 2, 0, 11, 0xEAA127FA), Rp(3, 0, 1, 2, 0, 11, 0xEAA127FA),
Rp(2, 3, 0, 1, 3, 16, 0xD4EF3085), Rp(2, 3, 0, 1, 3, 16, 0xD4EF3085),
Rp(1, 2, 3, 0, 6, 23, 0x04881D05), Rp(1, 2, 3, 0, 6, 23, 0x04881D05),
Rp(0, 1, 2, 3, 9, 4, 0xD9D4D039), Rp(0, 1, 2, 3, 9, 4, 0xD9D4D039),
Rp(3, 0, 1, 2, 12, 11, 0xE6DB99E5), Rp(3, 0, 1, 2, 12, 11, 0xE6DB99E5),
Rp(2, 3, 0, 1, 15, 16, 0x1FA27CF8), Rp(2, 3, 0, 1, 15, 16, 0x1FA27CF8),
Rp(1, 2, 3, 0, 2, 23, 0xC4AC5665), Rp(1, 2, 3, 0, 2, 23, 0xC4AC5665),
}; };
inline for (round2) |r| { inline for (round2) |r| {
v[r.a] = v[r.a] +% (v[r.b] ^ v[r.c] ^ v[r.d]) +% r.t +% s[r.k]; v[r.a] = v[r.a] +% (v[r.b] ^ v[r.c] ^ v[r.d]) +% r.t +% s[r.k];
v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s); v[r.a] = v[r.b] +% math.rotl(u32, v[r.a], r.s);
} }
const round3 = comptime []RoundParam { const round3 = comptime []RoundParam{
Rp(0, 1, 2, 3, 0, 6, 0xF4292244), Rp(0, 1, 2, 3, 0, 6, 0xF4292244),
Rp(3, 0, 1, 2, 7, 10, 0x432AFF97), Rp(3, 0, 1, 2, 7, 10, 0x432AFF97),
Rp(2, 3, 0, 1, 14, 15, 0xAB9423A7), Rp(2, 3, 0, 1, 14, 15, 0xAB9423A7),
Rp(1, 2, 3, 0, 5, 21, 0xFC93A039), Rp(1, 2, 3, 0, 5, 21, 0xFC93A039),
Rp(0, 1, 2, 3, 12, 6, 0x655B59C3), Rp(0, 1, 2, 3, 12, 6, 0x655B59C3),
Rp(3, 0, 1, 2, 3, 10, 0x8F0CCC92), Rp(3, 0, 1, 2, 3, 10, 0x8F0CCC92),
Rp(2, 3, 0, 1, 10, 15, 0xFFEFF47D), Rp(2, 3, 0, 1, 10, 15, 0xFFEFF47D),
Rp(1, 2, 3, 0, 1, 21, 0x85845DD1), Rp(1, 2, 3, 0, 1, 21, 0x85845DD1),
Rp(0, 1, 2, 3, 8, 6, 0x6FA87E4F), Rp(0, 1, 2, 3, 8, 6, 0x6FA87E4F),
Rp(3, 0, 1, 2, 15, 10, 0xFE2CE6E0), Rp(3, 0, 1, 2, 15, 10, 0xFE2CE6E0),
Rp(2, 3, 0, 1, 6, 15, 0xA3014314), Rp(2, 3, 0, 1, 6, 15, 0xA3014314),
Rp(1, 2, 3, 0, 13, 21, 0x4E0811A1), Rp(1, 2, 3, 0, 13, 21, 0x4E0811A1),
Rp(0, 1, 2, 3, 4, 6, 0xF7537E82), Rp(0, 1, 2, 3, 4, 6, 0xF7537E82),
Rp(3, 0, 1, 2, 11, 10, 0xBD3AF235), Rp(3, 0, 1, 2, 11, 10, 0xBD3AF235),
Rp(2, 3, 0, 1, 2, 15, 0x2AD7D2BB), Rp(2, 3, 0, 1, 2, 15, 0x2AD7D2BB),
Rp(1, 2, 3, 0, 9, 21, 0xEB86D391), Rp(1, 2, 3, 0, 9, 21, 0xEB86D391),
}; };
inline for (round3) |r| { inline for (round3) |r| {
v[r.a] = v[r.a] +% (v[r.c] ^ (v[r.b] | ~v[r.d])) +% r.t +% s[r.k]; v[r.a] = v[r.a] +% (v[r.c] ^ (v[r.b] | ~v[r.d])) +% r.t +% s[r.k];
@ -255,7 +271,7 @@ test "md5 streaming" {
} }
test "md5 aligned final" { test "md5 aligned final" {
var block = []u8 {0} ** Md5.block_size; var block = []u8{0} ** Md5.block_size;
var out: [Md5.digest_size]u8 = undefined; var out: [Md5.digest_size]u8 = undefined;
var h = Md5.init(); var h = Md5.init();

86
std/crypto/sha1.zig
View File

@ -7,11 +7,23 @@ const builtin = @import("builtin");
pub const u160 = @IntType(false, 160); pub const u160 = @IntType(false, 160);
const RoundParam = struct { const RoundParam = struct {
a: usize, b: usize, c: usize, d: usize, e: usize, i: u32, a: usize,
b: usize,
c: usize,
d: usize,
e: usize,
i: u32,
}; };
fn Rp(a: usize, b: usize, c: usize, d: usize, e: usize, i: u32) RoundParam { fn Rp(a: usize, b: usize, c: usize, d: usize, e: usize, i: u32) RoundParam {
return RoundParam { .a = a, .b = b, .c = c, .d = d, .e = e, .i = i }; return RoundParam{
.a = a,
.b = b,
.c = c,
.d = d,
.e = e,
.i = i,
};
} }
pub const Sha1 = struct { pub const Sha1 = struct {
@ -99,7 +111,7 @@ pub const Sha1 = struct {
d.round(d.buf[0..]); d.round(d.buf[0..]);
for (d.s) |s, j| { for (d.s) |s, j| {
mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Big); mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
} }
} }
@ -108,21 +120,25 @@ pub const Sha1 = struct {
var s: [16]u32 = undefined; var s: [16]u32 = undefined;
var v: [5]u32 = []u32 { var v: [5]u32 = []u32{
d.s[0], d.s[1], d.s[2], d.s[3], d.s[4], d.s[0],
d.s[1],
d.s[2],
d.s[3],
d.s[4],
}; };
const round0a = comptime []RoundParam { const round0a = comptime []RoundParam{
Rp(0, 1, 2, 3, 4, 0), Rp(0, 1, 2, 3, 4, 0),
Rp(4, 0, 1, 2, 3, 1), Rp(4, 0, 1, 2, 3, 1),
Rp(3, 4, 0, 1, 2, 2), Rp(3, 4, 0, 1, 2, 2),
Rp(2, 3, 4, 0, 1, 3), Rp(2, 3, 4, 0, 1, 3),
Rp(1, 2, 3, 4, 0, 4), Rp(1, 2, 3, 4, 0, 4),
Rp(0, 1, 2, 3, 4, 5), Rp(0, 1, 2, 3, 4, 5),
Rp(4, 0, 1, 2, 3, 6), Rp(4, 0, 1, 2, 3, 6),
Rp(3, 4, 0, 1, 2, 7), Rp(3, 4, 0, 1, 2, 7),
Rp(2, 3, 4, 0, 1, 8), Rp(2, 3, 4, 0, 1, 8),
Rp(1, 2, 3, 4, 0, 9), Rp(1, 2, 3, 4, 0, 9),
Rp(0, 1, 2, 3, 4, 10), Rp(0, 1, 2, 3, 4, 10),
Rp(4, 0, 1, 2, 3, 11), Rp(4, 0, 1, 2, 3, 11),
Rp(3, 4, 0, 1, 2, 12), Rp(3, 4, 0, 1, 2, 12),
@ -131,32 +147,27 @@ pub const Sha1 = struct {
Rp(0, 1, 2, 3, 4, 15), Rp(0, 1, 2, 3, 4, 15),
}; };
inline for (round0a) |r| { inline for (round0a) |r| {
s[r.i] = (u32(b[r.i * 4 + 0]) << 24) | s[r.i] = (u32(b[r.i * 4 + 0]) << 24) | (u32(b[r.i * 4 + 1]) << 16) | (u32(b[r.i * 4 + 2]) << 8) | (u32(b[r.i * 4 + 3]) << 0);
(u32(b[r.i * 4 + 1]) << 16) |
(u32(b[r.i * 4 + 2]) << 8) |
(u32(b[r.i * 4 + 3]) << 0);
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
v[r.b] = math.rotl(u32, v[r.b], u32(30)); v[r.b] = math.rotl(u32, v[r.b], u32(30));
} }
const round0b = comptime []RoundParam { const round0b = comptime []RoundParam{
Rp(4, 0, 1, 2, 3, 16), Rp(4, 0, 1, 2, 3, 16),
Rp(3, 4, 0, 1, 2, 17), Rp(3, 4, 0, 1, 2, 17),
Rp(2, 3, 4, 0, 1, 18), Rp(2, 3, 4, 0, 1, 18),
Rp(1, 2, 3, 4, 0, 19), Rp(1, 2, 3, 4, 0, 19),
}; };
inline for (round0b) |r| { inline for (round0b) |r| {
const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf]; const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
s[r.i & 0xf] = math.rotl(u32, t, u32(1)); s[r.i & 0xf] = math.rotl(u32, t, u32(1));
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
v[r.b] = math.rotl(u32, v[r.b], u32(30)); v[r.b] = math.rotl(u32, v[r.b], u32(30));
} }
const round1 = comptime []RoundParam { const round1 = comptime []RoundParam{
Rp(0, 1, 2, 3, 4, 20), Rp(0, 1, 2, 3, 4, 20),
Rp(4, 0, 1, 2, 3, 21), Rp(4, 0, 1, 2, 3, 21),
Rp(3, 4, 0, 1, 2, 22), Rp(3, 4, 0, 1, 2, 22),
@ -179,15 +190,14 @@ pub const Sha1 = struct {
Rp(1, 2, 3, 4, 0, 39), Rp(1, 2, 3, 4, 0, 39),
}; };
inline for (round1) |r| { inline for (round1) |r| {
const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf]; const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
s[r.i & 0xf] = math.rotl(u32, t, u32(1)); s[r.i & 0xf] = math.rotl(u32, t, u32(1));
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x6ED9EBA1 +% s[r.i & 0xf] v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x6ED9EBA1 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+% (v[r.b] ^ v[r.c] ^ v[r.d]);
v[r.b] = math.rotl(u32, v[r.b], u32(30)); v[r.b] = math.rotl(u32, v[r.b], u32(30));
} }
const round2 = comptime []RoundParam { const round2 = comptime []RoundParam{
Rp(0, 1, 2, 3, 4, 40), Rp(0, 1, 2, 3, 4, 40),
Rp(4, 0, 1, 2, 3, 41), Rp(4, 0, 1, 2, 3, 41),
Rp(3, 4, 0, 1, 2, 42), Rp(3, 4, 0, 1, 2, 42),
@ -210,15 +220,14 @@ pub const Sha1 = struct {
Rp(1, 2, 3, 4, 0, 59), Rp(1, 2, 3, 4, 0, 59),
}; };
inline for (round2) |r| { inline for (round2) |r| {
const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf]; const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
s[r.i & 0xf] = math.rotl(u32, t, u32(1)); s[r.i & 0xf] = math.rotl(u32, t, u32(1));
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x8F1BBCDC +% s[r.i & 0xf] v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x8F1BBCDC +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
+% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
v[r.b] = math.rotl(u32, v[r.b], u32(30)); v[r.b] = math.rotl(u32, v[r.b], u32(30));
} }
const round3 = comptime []RoundParam { const round3 = comptime []RoundParam{
Rp(0, 1, 2, 3, 4, 60), Rp(0, 1, 2, 3, 4, 60),
Rp(4, 0, 1, 2, 3, 61), Rp(4, 0, 1, 2, 3, 61),
Rp(3, 4, 0, 1, 2, 62), Rp(3, 4, 0, 1, 2, 62),
@ -241,11 +250,10 @@ pub const Sha1 = struct {
Rp(1, 2, 3, 4, 0, 79), Rp(1, 2, 3, 4, 0, 79),
}; };
inline for (round3) |r| { inline for (round3) |r| {
const t = s[(r.i-3) & 0xf] ^ s[(r.i-8) & 0xf] ^ s[(r.i-14) & 0xf] ^ s[(r.i-16) & 0xf]; const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
s[r.i & 0xf] = math.rotl(u32, t, u32(1)); s[r.i & 0xf] = math.rotl(u32, t, u32(1));
v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0xCA62C1D6 +% s[r.i & 0xf] v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0xCA62C1D6 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+% (v[r.b] ^ v[r.c] ^ v[r.d]);
v[r.b] = math.rotl(u32, v[r.b], u32(30)); v[r.b] = math.rotl(u32, v[r.b], u32(30));
} }
@ -286,7 +294,7 @@ test "sha1 streaming" {
} }
test "sha1 aligned final" { test "sha1 aligned final" {
var block = []u8 {0} ** Sha1.block_size; var block = []u8{0} ** Sha1.block_size;
var out: [Sha1.digest_size]u8 = undefined; var out: [Sha1.digest_size]u8 = undefined;
var h = Sha1.init(); var h = Sha1.init();

875
std/crypto/sha2.zig
View File

@ -9,12 +9,31 @@ const htest = @import("test.zig");
// Sha224 + Sha256 // Sha224 + Sha256
const RoundParam256 = struct { const RoundParam256 = struct {
a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, a: usize,
i: usize, k: u32, b: usize,
c: usize,
d: usize,
e: usize,
f: usize,
g: usize,
h: usize,
i: usize,
k: u32,
}; };
fn Rp256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u32) RoundParam256 { fn Rp256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u32) RoundParam256 {
return RoundParam256 { .a = a, .b = b, .c = c, .d = d, .e = e, .f = f, .g = g, .h = h, .i = i, .k = k }; return RoundParam256{
.a = a,
.b = b,
.c = c,
.d = d,
.e = e,
.f = f,
.g = g,
.h = h,
.i = i,
.k = k,
};
} }
const Sha2Params32 = struct { const Sha2Params32 = struct {
@ -29,7 +48,7 @@ const Sha2Params32 = struct {
out_len: usize, out_len: usize,
}; };
const Sha224Params = Sha2Params32 { const Sha224Params = Sha2Params32{
.iv0 = 0xC1059ED8, .iv0 = 0xC1059ED8,
.iv1 = 0x367CD507, .iv1 = 0x367CD507,
.iv2 = 0x3070DD17, .iv2 = 0x3070DD17,
@ -41,7 +60,7 @@ const Sha224Params = Sha2Params32 {
.out_len = 224, .out_len = 224,
}; };
const Sha256Params = Sha2Params32 { const Sha256Params = Sha2Params32{
.iv0 = 0x6A09E667, .iv0 = 0x6A09E667,
.iv1 = 0xBB67AE85, .iv1 = 0xBB67AE85,
.iv2 = 0x3C6EF372, .iv2 = 0x3C6EF372,
@ -56,216 +75,215 @@ const Sha256Params = Sha2Params32 {
pub const Sha224 = Sha2_32(Sha224Params); pub const Sha224 = Sha2_32(Sha224Params);
pub const Sha256 = Sha2_32(Sha256Params); pub const Sha256 = Sha2_32(Sha256Params);
fn Sha2_32(comptime params: Sha2Params32) type { return struct { fn Sha2_32(comptime params: Sha2Params32) type {
const Self = this; return struct {
const block_size = 64; const Self = this;
const digest_size = params.out_len / 8; const block_size = 64;
const digest_size = params.out_len / 8;
s: [8]u32, s: [8]u32,
// Streaming Cache // Streaming Cache
buf: [64]u8, buf: [64]u8,
buf_len: u8, buf_len: u8,
total_len: u64, total_len: u64,
pub fn init() Self { pub fn init() Self {
var d: Self = undefined; var d: Self = undefined;
d.reset(); d.reset();
return d; return d;
} }
pub fn reset(d: &Self) void { pub fn reset(d: &Self) void {
d.s[0] = params.iv0; d.s[0] = params.iv0;
d.s[1] = params.iv1; d.s[1] = params.iv1;
d.s[2] = params.iv2; d.s[2] = params.iv2;
d.s[3] = params.iv3; d.s[3] = params.iv3;
d.s[4] = params.iv4; d.s[4] = params.iv4;
d.s[5] = params.iv5; d.s[5] = params.iv5;
d.s[6] = params.iv6; d.s[6] = params.iv6;
d.s[7] = params.iv7; d.s[7] = params.iv7;
d.buf_len = 0;
d.total_len = 0;
}
pub fn hash(b: []const u8, out: []u8) void {
var d = Self.init();
d.update(b);
d.final(out);
}
pub fn update(d: &Self, b: []const u8) void {
var off: usize = 0;
// Partial buffer exists from previous update. Copy into buffer then hash.
if (d.buf_len != 0 and d.buf_len + b.len > 64) {
off += 64 - d.buf_len;
mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
d.round(d.buf[0..]);
d.buf_len = 0; d.buf_len = 0;
d.total_len = 0;
} }
// Full middle blocks. pub fn hash(b: []const u8, out: []u8) void {
while (off + 64 <= b.len) : (off += 64) { var d = Self.init();
d.round(b[off..off + 64]); d.update(b);
d.final(out);
} }
// Copy any remainder for next pass. pub fn update(d: &Self, b: []const u8) void {
mem.copy(u8, d.buf[d.buf_len..], b[off..]); var off: usize = 0;
d.buf_len += u8(b[off..].len);
d.total_len += b.len; // Partial buffer exists from previous update. Copy into buffer then hash.
} if (d.buf_len != 0 and d.buf_len + b.len > 64) {
off += 64 - d.buf_len;
mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
pub fn final(d: &Self, out: []u8) void { d.round(d.buf[0..]);
debug.assert(out.len >= params.out_len / 8); d.buf_len = 0;
}
// The buffer here will never be completely full. // Full middle blocks.
mem.set(u8, d.buf[d.buf_len..], 0); while (off + 64 <= b.len) : (off += 64) {
d.round(b[off..off + 64]);
}
// Append padding bits. // Copy any remainder for next pass.
d.buf[d.buf_len] = 0x80; mem.copy(u8, d.buf[d.buf_len..], b[off..]);
d.buf_len += 1; d.buf_len += u8(b[off..].len);
d.total_len += b.len;
}
pub fn final(d: &Self, out: []u8) void {
debug.assert(out.len >= params.out_len / 8);
// The buffer here will never be completely full.
mem.set(u8, d.buf[d.buf_len..], 0);
// Append padding bits.
d.buf[d.buf_len] = 0x80;
d.buf_len += 1;
// > 448 mod 512 so need to add an extra round to wrap around.
if (64 - d.buf_len < 8) {
d.round(d.buf[0..]);
mem.set(u8, d.buf[0..], 0);
}
// Append message length.
var i: usize = 1;
var len = d.total_len >> 5;
d.buf[63] = u8(d.total_len & 0x1f) << 3;
while (i < 8) : (i += 1) {
d.buf[63 - i] = u8(len & 0xff);
len >>= 8;
}
// > 448 mod 512 so need to add an extra round to wrap around.
if (64 - d.buf_len < 8) {
d.round(d.buf[0..]); d.round(d.buf[0..]);
mem.set(u8, d.buf[0..], 0);
// May truncate for possible 224 output
const rr = d.s[0..params.out_len / 32];
for (rr) |s, j| {
mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
}
} }
// Append message length. fn round(d: &Self, b: []const u8) void {
var i: usize = 1; debug.assert(b.len == 64);
var len = d.total_len >> 5;
d.buf[63] = u8(d.total_len & 0x1f) << 3; var s: [64]u32 = undefined;
while (i < 8) : (i += 1) {
d.buf[63 - i] = u8(len & 0xff); var i: usize = 0;
len >>= 8; while (i < 16) : (i += 1) {
s[i] = 0;
s[i] |= u32(b[i * 4 + 0]) << 24;
s[i] |= u32(b[i * 4 + 1]) << 16;
s[i] |= u32(b[i * 4 + 2]) << 8;
s[i] |= u32(b[i * 4 + 3]) << 0;
}
while (i < 64) : (i += 1) {
s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], u32(7)) ^ math.rotr(u32, s[i - 15], u32(18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], u32(17)) ^ math.rotr(u32, s[i - 2], u32(19)) ^ (s[i - 2] >> 10));
}
var v: [8]u32 = []u32{
d.s[0],
d.s[1],
d.s[2],
d.s[3],
d.s[4],
d.s[5],
d.s[6],
d.s[7],
};
const round0 = comptime []RoundParam256{
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x71374491),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCF),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA5),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25B),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B01),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A7),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C1),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC6),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DC),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C8),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF3),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x14292967),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A85),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B2138),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D13),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A7354),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C85),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A1),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664B),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A3),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD6990624),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E3585),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA070),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C08),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774C),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4A),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC70208),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEB),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
};
inline for (round0) |r| {
v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], u32(6)) ^ math.rotr(u32, v[r.e], u32(11)) ^ math.rotr(u32, v[r.e], u32(25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
v[r.h] = v[r.h] +% (math.rotr(u32, v[r.a], u32(2)) ^ math.rotr(u32, v[r.a], u32(13)) ^ math.rotr(u32, v[r.a], u32(22))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
d.s[1] +%= v[1];
d.s[2] +%= v[2];
d.s[3] +%= v[3];
d.s[4] +%= v[4];
d.s[5] +%= v[5];
d.s[6] +%= v[6];
d.s[7] +%= v[7];
} }
};
d.round(d.buf[0..]); }
// May truncate for possible 224 output
const rr = d.s[0 .. params.out_len / 32];
for (rr) |s, j| {
mem.writeInt(out[4*j .. 4*j + 4], s, builtin.Endian.Big);
}
}
fn round(d: &Self, b: []const u8) void {
debug.assert(b.len == 64);
var s: [64]u32 = undefined;
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = 0;
s[i] |= u32(b[i*4+0]) << 24;
s[i] |= u32(b[i*4+1]) << 16;
s[i] |= u32(b[i*4+2]) << 8;
s[i] |= u32(b[i*4+3]) << 0;
}
while (i < 64) : (i += 1) {
s[i] =
s[i-16] +% s[i-7] +%
(math.rotr(u32, s[i-15], u32(7)) ^ math.rotr(u32, s[i-15], u32(18)) ^ (s[i-15] >> 3)) +%
(math.rotr(u32, s[i-2], u32(17)) ^ math.rotr(u32, s[i-2], u32(19)) ^ (s[i-2] >> 10));
}
var v: [8]u32 = []u32 {
d.s[0], d.s[1], d.s[2], d.s[3], d.s[4], d.s[5], d.s[6], d.s[7],
};
const round0 = comptime []RoundParam256 {
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x71374491),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCF),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA5),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25B),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B01),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A7),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C1),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC6),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DC),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C8),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF3),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x14292967),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A85),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B2138),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D13),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A7354),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C85),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A1),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664B),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A3),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD6990624),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E3585),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA070),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C08),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774C),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4A),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3),
Rp256(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE),
Rp256(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F),
Rp256(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814),
Rp256(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC70208),
Rp256(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA),
Rp256(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEB),
Rp256(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7),
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
};
inline for (round0) |r| {
v[r.h] =
v[r.h] +%
(math.rotr(u32, v[r.e], u32(6)) ^ math.rotr(u32, v[r.e], u32(11)) ^ math.rotr(u32, v[r.e], u32(25))) +%
(v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +%
r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
v[r.h] =
v[r.h] +%
(math.rotr(u32, v[r.a], u32(2)) ^ math.rotr(u32, v[r.a], u32(13)) ^ math.rotr(u32, v[r.a], u32(22))) +%
((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
d.s[1] +%= v[1];
d.s[2] +%= v[2];
d.s[3] +%= v[3];
d.s[4] +%= v[4];
d.s[5] +%= v[5];
d.s[6] +%= v[6];
d.s[7] +%= v[7];
}
};}
test "sha224 single" { test "sha224 single" {
htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", ""); htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");
@ -320,7 +338,7 @@ test "sha256 streaming" {
} }
test "sha256 aligned final" { test "sha256 aligned final" {
var block = []u8 {0} ** Sha256.block_size; var block = []u8{0} ** Sha256.block_size;
var out: [Sha256.digest_size]u8 = undefined; var out: [Sha256.digest_size]u8 = undefined;
var h = Sha256.init(); var h = Sha256.init();
@ -328,17 +346,35 @@ test "sha256 aligned final" {
h.final(out[0..]); h.final(out[0..]);
} }
///////////////////// /////////////////////
// Sha384 + Sha512 // Sha384 + Sha512
const RoundParam512 = struct { const RoundParam512 = struct {
a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, a: usize,
i: usize, k: u64, b: usize,
c: usize,
d: usize,
e: usize,
f: usize,
g: usize,
h: usize,
i: usize,
k: u64,
}; };
fn Rp512(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u64) RoundParam512 { fn Rp512(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u64) RoundParam512 {
return RoundParam512 { .a = a, .b = b, .c = c, .d = d, .e = e, .f = f, .g = g, .h = h, .i = i, .k = k }; return RoundParam512{
.a = a,
.b = b,
.c = c,
.d = d,
.e = e,
.f = f,
.g = g,
.h = h,
.i = i,
.k = k,
};
} }
const Sha2Params64 = struct { const Sha2Params64 = struct {
@ -353,7 +389,7 @@ const Sha2Params64 = struct {
out_len: usize, out_len: usize,
}; };
const Sha384Params = Sha2Params64 { const Sha384Params = Sha2Params64{
.iv0 = 0xCBBB9D5DC1059ED8, .iv0 = 0xCBBB9D5DC1059ED8,
.iv1 = 0x629A292A367CD507, .iv1 = 0x629A292A367CD507,
.iv2 = 0x9159015A3070DD17, .iv2 = 0x9159015A3070DD17,
@ -365,7 +401,7 @@ const Sha384Params = Sha2Params64 {
.out_len = 384, .out_len = 384,
}; };
const Sha512Params = Sha2Params64 { const Sha512Params = Sha2Params64{
.iv0 = 0x6A09E667F3BCC908, .iv0 = 0x6A09E667F3BCC908,
.iv1 = 0xBB67AE8584CAA73B, .iv1 = 0xBB67AE8584CAA73B,
.iv2 = 0x3C6EF372FE94F82B, .iv2 = 0x3C6EF372FE94F82B,
@ -374,242 +410,241 @@ const Sha512Params = Sha2Params64 {
.iv5 = 0x9B05688C2B3E6C1F, .iv5 = 0x9B05688C2B3E6C1F,
.iv6 = 0x1F83D9ABFB41BD6B, .iv6 = 0x1F83D9ABFB41BD6B,
.iv7 = 0x5BE0CD19137E2179, .iv7 = 0x5BE0CD19137E2179,
.out_len = 512 .out_len = 512,
}; };
pub const Sha384 = Sha2_64(Sha384Params); pub const Sha384 = Sha2_64(Sha384Params);
pub const Sha512 = Sha2_64(Sha512Params); pub const Sha512 = Sha2_64(Sha512Params);
fn Sha2_64(comptime params: Sha2Params64) type { return struct { fn Sha2_64(comptime params: Sha2Params64) type {
const Self = this; return struct {
const block_size = 128; const Self = this;
const digest_size = params.out_len / 8; const block_size = 128;
const digest_size = params.out_len / 8;
s: [8]u64, s: [8]u64,
// Streaming Cache // Streaming Cache
buf: [128]u8, buf: [128]u8,
buf_len: u8, buf_len: u8,
total_len: u128, total_len: u128,
pub fn init() Self { pub fn init() Self {
var d: Self = undefined; var d: Self = undefined;
d.reset(); d.reset();
return d; return d;
} }
pub fn reset(d: &Self) void { pub fn reset(d: &Self) void {
d.s[0] = params.iv0; d.s[0] = params.iv0;
d.s[1] = params.iv1; d.s[1] = params.iv1;
d.s[2] = params.iv2; d.s[2] = params.iv2;
d.s[3] = params.iv3; d.s[3] = params.iv3;
d.s[4] = params.iv4; d.s[4] = params.iv4;
d.s[5] = params.iv5; d.s[5] = params.iv5;
d.s[6] = params.iv6; d.s[6] = params.iv6;
d.s[7] = params.iv7; d.s[7] = params.iv7;
d.buf_len = 0;
d.total_len = 0;
}
pub fn hash(b: []const u8, out: []u8) void {
var d = Self.init();
d.update(b);
d.final(out);
}
pub fn update(d: &Self, b: []const u8) void {
var off: usize = 0;
// Partial buffer exists from previous update. Copy into buffer then hash.
if (d.buf_len != 0 and d.buf_len + b.len > 128) {
off += 128 - d.buf_len;
mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
d.round(d.buf[0..]);
d.buf_len = 0; d.buf_len = 0;
d.total_len = 0;
} }
// Full middle blocks. pub fn hash(b: []const u8, out: []u8) void {
while (off + 128 <= b.len) : (off += 128) { var d = Self.init();
d.round(b[off..off + 128]); d.update(b);
d.final(out);
} }
// Copy any remainder for next pass. pub fn update(d: &Self, b: []const u8) void {
mem.copy(u8, d.buf[d.buf_len..], b[off..]); var off: usize = 0;
d.buf_len += u8(b[off..].len);
d.total_len += b.len; // Partial buffer exists from previous update. Copy into buffer then hash.
} if (d.buf_len != 0 and d.buf_len + b.len > 128) {
off += 128 - d.buf_len;
mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
pub fn final(d: &Self, out: []u8) void { d.round(d.buf[0..]);
debug.assert(out.len >= params.out_len / 8); d.buf_len = 0;
}
// The buffer here will never be completely full. // Full middle blocks.
mem.set(u8, d.buf[d.buf_len..], 0); while (off + 128 <= b.len) : (off += 128) {
d.round(b[off..off + 128]);
}
// Append padding bits. // Copy any remainder for next pass.
d.buf[d.buf_len] = 0x80; mem.copy(u8, d.buf[d.buf_len..], b[off..]);
d.buf_len += 1; d.buf_len += u8(b[off..].len);
d.total_len += b.len;
}
pub fn final(d: &Self, out: []u8) void {
debug.assert(out.len >= params.out_len / 8);
// The buffer here will never be completely full.
mem.set(u8, d.buf[d.buf_len..], 0);
// Append padding bits.
d.buf[d.buf_len] = 0x80;
d.buf_len += 1;
// > 896 mod 1024 so need to add an extra round to wrap around.
if (128 - d.buf_len < 16) {
d.round(d.buf[0..]);
mem.set(u8, d.buf[0..], 0);
}
// Append message length.
var i: usize = 1;
var len = d.total_len >> 5;
d.buf[127] = u8(d.total_len & 0x1f) << 3;
while (i < 16) : (i += 1) {
d.buf[127 - i] = u8(len & 0xff);
len >>= 8;
}
// > 896 mod 1024 so need to add an extra round to wrap around.
if (128 - d.buf_len < 16) {
d.round(d.buf[0..]); d.round(d.buf[0..]);
mem.set(u8, d.buf[0..], 0);
// May truncate for possible 384 output
const rr = d.s[0..params.out_len / 64];
for (rr) |s, j| {
mem.writeInt(out[8 * j..8 * j + 8], s, builtin.Endian.Big);
}
} }
// Append message length. fn round(d: &Self, b: []const u8) void {
var i: usize = 1; debug.assert(b.len == 128);
var len = d.total_len >> 5;
d.buf[127] = u8(d.total_len & 0x1f) << 3; var s: [80]u64 = undefined;
while (i < 16) : (i += 1) {
d.buf[127 - i] = u8(len & 0xff); var i: usize = 0;
len >>= 8; while (i < 16) : (i += 1) {
s[i] = 0;
s[i] |= u64(b[i * 8 + 0]) << 56;
s[i] |= u64(b[i * 8 + 1]) << 48;
s[i] |= u64(b[i * 8 + 2]) << 40;
s[i] |= u64(b[i * 8 + 3]) << 32;
s[i] |= u64(b[i * 8 + 4]) << 24;
s[i] |= u64(b[i * 8 + 5]) << 16;
s[i] |= u64(b[i * 8 + 6]) << 8;
s[i] |= u64(b[i * 8 + 7]) << 0;
}
while (i < 80) : (i += 1) {
s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u64, s[i - 15], u64(1)) ^ math.rotr(u64, s[i - 15], u64(8)) ^ (s[i - 15] >> 7)) +% (math.rotr(u64, s[i - 2], u64(19)) ^ math.rotr(u64, s[i - 2], u64(61)) ^ (s[i - 2] >> 6));
}
var v: [8]u64 = []u64{
d.s[0],
d.s[1],
d.s[2],
d.s[3],
d.s[4],
d.s[5],
d.s[6],
d.s[7],
};
const round0 = comptime []RoundParam512{
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98D728AE22),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x7137449123EF65CD),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCFEC4D3B2F),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA58189DBBC),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25BF348B538),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1B605D019),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4AF194F9B),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5DA6D8118),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98A3030242),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B0145706FBE),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE4EE4B28C),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3D5FFB4E2),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74F27B896F),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE3B1696B1),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A725C71235),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174CF692694),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C19EF14AD2),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786384F25E3),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC68B8CD5B5),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC77AC9C65),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F592B0275),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA6EA6E483),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DCBD41FBD4),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA831153B5),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152EE66DFAB),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D2DB43210),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C898FB213F),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7BEEF0EE4),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF33DA88FC2),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147930AA725),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351E003826F),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x142929670A0E6E70),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A8546D22FFC),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B21385C26C926),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC5AC42AED),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D139D95B3DF),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A73548BAF63DE),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB3C77B2A8),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E47EDAEE6),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C851482353B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A14CF10364),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664BBC423001),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70D0F89791),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A30654BE30),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819D6EF5218),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD69906245565A910),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E35855771202A),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA07032BBD1B8),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116B8D2D0C8),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C085141AB53),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774CDF8EEB99),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5E19B48A8),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3C5C95A63),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4AE3418ACB),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F7763E373),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3D6B2B8A3),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE5DEFB2FC),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F43172F60),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814A1F0AB72),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC702081A6439EC),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA23631E28),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEBDE82BDE9),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7B2C67915),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2E372532B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 64, 0xCA273ECEEA26619C),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 65, 0xD186B8C721C0C207),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 66, 0xEADA7DD6CDE0EB1E),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 67, 0xF57D4F7FEE6ED178),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 68, 0x06F067AA72176FBA),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 69, 0x0A637DC5A2C898A6),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 70, 0x113F9804BEF90DAE),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 71, 0x1B710B35131C471B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 72, 0x28DB77F523047D84),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 73, 0x32CAAB7B40C72493),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 74, 0x3C9EBE0A15C9BEBC),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 75, 0x431D67C49C100D4C),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 76, 0x4CC5D4BECB3E42B6),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 77, 0x597F299CFC657E2A),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 78, 0x5FCB6FAB3AD6FAEC),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 79, 0x6C44198C4A475817),
};
inline for (round0) |r| {
v[r.h] = v[r.h] +% (math.rotr(u64, v[r.e], u64(14)) ^ math.rotr(u64, v[r.e], u64(18)) ^ math.rotr(u64, v[r.e], u64(41))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
v[r.h] = v[r.h] +% (math.rotr(u64, v[r.a], u64(28)) ^ math.rotr(u64, v[r.a], u64(34)) ^ math.rotr(u64, v[r.a], u64(39))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
d.s[1] +%= v[1];
d.s[2] +%= v[2];
d.s[3] +%= v[3];
d.s[4] +%= v[4];
d.s[5] +%= v[5];
d.s[6] +%= v[6];
d.s[7] +%= v[7];
} }
};
d.round(d.buf[0..]); }
// May truncate for possible 384 output
const rr = d.s[0 .. params.out_len / 64];
for (rr) |s, j| {
mem.writeInt(out[8*j .. 8*j + 8], s, builtin.Endian.Big);
}
}
fn round(d: &Self, b: []const u8) void {
debug.assert(b.len == 128);
var s: [80]u64 = undefined;
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = 0;
s[i] |= u64(b[i*8+0]) << 56;
s[i] |= u64(b[i*8+1]) << 48;
s[i] |= u64(b[i*8+2]) << 40;
s[i] |= u64(b[i*8+3]) << 32;
s[i] |= u64(b[i*8+4]) << 24;
s[i] |= u64(b[i*8+5]) << 16;
s[i] |= u64(b[i*8+6]) << 8;
s[i] |= u64(b[i*8+7]) << 0;
}
while (i < 80) : (i += 1) {
s[i] =
s[i-16] +% s[i-7] +%
(math.rotr(u64, s[i-15], u64(1)) ^ math.rotr(u64, s[i-15], u64(8)) ^ (s[i-15] >> 7)) +%
(math.rotr(u64, s[i-2], u64(19)) ^ math.rotr(u64, s[i-2], u64(61)) ^ (s[i-2] >> 6));
}
var v: [8]u64 = []u64 {
d.s[0], d.s[1], d.s[2], d.s[3], d.s[4], d.s[5], d.s[6], d.s[7],
};
const round0 = comptime []RoundParam512 {
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98D728AE22),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x7137449123EF65CD),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCFEC4D3B2F),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA58189DBBC),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25BF348B538),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1B605D019),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4AF194F9B),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5DA6D8118),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98A3030242),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B0145706FBE),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE4EE4B28C),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3D5FFB4E2),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74F27B896F),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE3B1696B1),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A725C71235),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174CF692694),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C19EF14AD2),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786384F25E3),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC68B8CD5B5),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC77AC9C65),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F592B0275),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA6EA6E483),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DCBD41FBD4),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA831153B5),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152EE66DFAB),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D2DB43210),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C898FB213F),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7BEEF0EE4),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF33DA88FC2),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147930AA725),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351E003826F),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x142929670A0E6E70),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A8546D22FFC),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B21385C26C926),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC5AC42AED),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D139D95B3DF),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A73548BAF63DE),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB3C77B2A8),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E47EDAEE6),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C851482353B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A14CF10364),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664BBC423001),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70D0F89791),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A30654BE30),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819D6EF5218),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD69906245565A910),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E35855771202A),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA07032BBD1B8),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116B8D2D0C8),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C085141AB53),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774CDF8EEB99),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5E19B48A8),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3C5C95A63),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4AE3418ACB),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F7763E373),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3D6B2B8A3),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE5DEFB2FC),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F43172F60),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814A1F0AB72),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC702081A6439EC),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA23631E28),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEBDE82BDE9),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7B2C67915),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2E372532B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 64, 0xCA273ECEEA26619C),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 65, 0xD186B8C721C0C207),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 66, 0xEADA7DD6CDE0EB1E),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 67, 0xF57D4F7FEE6ED178),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 68, 0x06F067AA72176FBA),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 69, 0x0A637DC5A2C898A6),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 70, 0x113F9804BEF90DAE),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 71, 0x1B710B35131C471B),
Rp512(0, 1, 2, 3, 4, 5, 6, 7, 72, 0x28DB77F523047D84),
Rp512(7, 0, 1, 2, 3, 4, 5, 6, 73, 0x32CAAB7B40C72493),
Rp512(6, 7, 0, 1, 2, 3, 4, 5, 74, 0x3C9EBE0A15C9BEBC),
Rp512(5, 6, 7, 0, 1, 2, 3, 4, 75, 0x431D67C49C100D4C),
Rp512(4, 5, 6, 7, 0, 1, 2, 3, 76, 0x4CC5D4BECB3E42B6),
Rp512(3, 4, 5, 6, 7, 0, 1, 2, 77, 0x597F299CFC657E2A),
Rp512(2, 3, 4, 5, 6, 7, 0, 1, 78, 0x5FCB6FAB3AD6FAEC),
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 79, 0x6C44198C4A475817),
};
inline for (round0) |r| {
v[r.h] =
v[r.h] +%
(math.rotr(u64, v[r.e], u64(14)) ^ math.rotr(u64, v[r.e], u64(18)) ^ math.rotr(u64, v[r.e], u64(41))) +%
(v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +%
r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
v[r.h] =
v[r.h] +%
(math.rotr(u64, v[r.a], u64(28)) ^ math.rotr(u64, v[r.a], u64(34)) ^ math.rotr(u64, v[r.a], u64(39))) +%
((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
d.s[1] +%= v[1];
d.s[2] +%= v[2];
d.s[3] +%= v[3];
d.s[4] +%= v[4];
d.s[5] +%= v[5];
d.s[6] +%= v[6];
d.s[7] +%= v[7];
}
};}
test "sha384 single" { test "sha384 single" {
const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"; const h1 = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b";
@ -680,7 +715,7 @@ test "sha512 streaming" {
} }
test "sha512 aligned final" { test "sha512 aligned final" {
var block = []u8 {0} ** Sha512.block_size; var block = []u8{0} ** Sha512.block_size;
var out: [Sha512.digest_size]u8 = undefined; var out: [Sha512.digest_size]u8 = undefined;
var h = Sha512.init(); var h = Sha512.init();

2
std/crypto/test.zig
View File

@ -14,7 +14,7 @@ pub fn assertEqualHash(comptime Hasher: var, comptime expected: []const u8, inpu
pub fn assertEqual(comptime expected: []const u8, input: []const u8) void { pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {
var expected_bytes: [expected.len / 2]u8 = undefined; var expected_bytes: [expected.len / 2]u8 = undefined;
for (expected_bytes) |*r, i| { for (expected_bytes) |*r, i| {
r.* = fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable; r.* = fmt.parseInt(u8, expected[2 * i..2 * i + 2], 16) catch unreachable;
} }
debug.assert(mem.eql(u8, expected_bytes, input)); debug.assert(mem.eql(u8, expected_bytes, input));

2
std/crypto/throughput_test.zig
View File

@ -11,7 +11,7 @@ const Timer = time.Timer;
const HashFunction = @import("md5.zig").Md5; const HashFunction = @import("md5.zig").Md5;
const MiB = 1024 * 1024; const MiB = 1024 * 1024;
const BytesToHash = 1024 * MiB; const BytesToHash = 1024 * MiB;
pub fn main() !void { pub fn main() !void {
var stdout_file = try std.io.getStdOut(); var stdout_file = try std.io.getStdOut();

4
std/cstr.zig
View File

@ -9,7 +9,6 @@ pub const line_sep = switch (builtin.os) {
else => "\n", else => "\n",
}; };
pub fn len(ptr: &const u8) usize { pub fn len(ptr: &const u8) usize {
var count: usize = 0; var count: usize = 0;
while (ptr[count] != 0) : (count += 1) {} while (ptr[count] != 0) : (count += 1) {}
@ -95,7 +94,7 @@ pub const NullTerminated2DArray = struct {
} }
index_buf[i] = null; index_buf[i] = null;
return NullTerminated2DArray { return NullTerminated2DArray{
.allocator = allocator, .allocator = allocator,
.byte_count = byte_count, .byte_count = byte_count,
.ptr = @ptrCast(?&?&u8, buf.ptr), .ptr = @ptrCast(?&?&u8, buf.ptr),
@ -107,4 +106,3 @@ pub const NullTerminated2DArray = struct {
self.allocator.free(buf[0..self.byte_count]); self.allocator.free(buf[0..self.byte_count]);
} }
}; };

4
std/debug/failing_allocator.zig
View File

@ -13,14 +13,14 @@ pub const FailingAllocator = struct {
deallocations: usize, deallocations: usize,
pub fn init(allocator: &mem.Allocator, fail_index: usize) FailingAllocator { pub fn init(allocator: &mem.Allocator, fail_index: usize) FailingAllocator {
return FailingAllocator { return FailingAllocator{
.internal_allocator = allocator, .internal_allocator = allocator,
.fail_index = fail_index, .fail_index = fail_index,
.index = 0, .index = 0,
.allocated_bytes = 0, .allocated_bytes = 0,
.freed_bytes = 0, .freed_bytes = 0,
.deallocations = 0, .deallocations = 0,
.allocator = mem.Allocator { .allocator = mem.Allocator{
.allocFn = alloc, .allocFn = alloc,
.reallocFn = realloc, .reallocFn = realloc,
.freeFn = free, .freeFn = free,

18
std/debug/index.zig
View File

@ -227,8 +227,7 @@ fn printSourceAtAddress(debug_info: &ElfStackTrace, out_stream: var, address: us
else => return err, else => return err,
} }
} else |err| switch (err) { } else |err| switch (err) {
error.MissingDebugInfo, error.MissingDebugInfo, error.InvalidDebugInfo => {
error.InvalidDebugInfo => {
try out_stream.print(ptr_hex ++ " in ??? ({})\n", address, compile_unit_name); try out_stream.print(ptr_hex ++ " in ??? ({})\n", address, compile_unit_name);
}, },
else => return err, else => return err,
@ -597,10 +596,12 @@ fn parseFormValueBlock(allocator: &mem.Allocator, in_stream: var, size: usize) !
} }
fn parseFormValueConstant(allocator: &mem.Allocator, in_stream: var, signed: bool, size: usize) !FormValue { fn parseFormValueConstant(allocator: &mem.Allocator, in_stream: var, signed: bool, size: usize) !FormValue {
return FormValue{ .Const = Constant{ return FormValue{
.signed = signed, .Const = Constant{
.payload = try readAllocBytes(allocator, in_stream, size), .signed = signed,
} }; .payload = try readAllocBytes(allocator, in_stream, size),
},
};
} }
fn parseFormValueDwarfOffsetSize(in_stream: var, is_64: bool) !u64 { fn parseFormValueDwarfOffsetSize(in_stream: var, is_64: bool) !u64 {
@ -621,7 +622,7 @@ fn parseFormValueRef(allocator: &mem.Allocator, in_stream: var, comptime T: type
return parseFormValueRefLen(allocator, in_stream, block_len); return parseFormValueRefLen(allocator, in_stream, block_len);
} }
const ParseFormValueError = error { const ParseFormValueError = error{
EndOfStream, EndOfStream,
Io, Io,
BadFd, BadFd,
@ -645,8 +646,7 @@ fn parseFormValue(allocator: &mem.Allocator, in_stream: var, form_id: u64, is_64
DW.FORM_data2 => parseFormValueConstant(allocator, in_stream, false, 2), DW.FORM_data2 => parseFormValueConstant(allocator, in_stream, false, 2),
DW.FORM_data4 => parseFormValueConstant(allocator, in_stream, false, 4), DW.FORM_data4 => parseFormValueConstant(allocator, in_stream, false, 4),
DW.FORM_data8 => parseFormValueConstant(allocator, in_stream, false, 8), DW.FORM_data8 => parseFormValueConstant(allocator, in_stream, false, 8),
DW.FORM_udata, DW.FORM_udata, DW.FORM_sdata => {
DW.FORM_sdata => {
const block_len = try readULeb128(in_stream); const block_len = try readULeb128(in_stream);
const signed = form_id == DW.FORM_sdata; const signed = form_id == DW.FORM_sdata;
return parseFormValueConstant(allocator, in_stream, signed, block_len); return parseFormValueConstant(allocator, in_stream, signed, block_len);

2
std/dwarf.zig
View File

@ -337,7 +337,6 @@ pub const AT_PGI_lbase = 0x3a00;
pub const AT_PGI_soffset = 0x3a01; pub const AT_PGI_soffset = 0x3a01;
pub const AT_PGI_lstride = 0x3a02; pub const AT_PGI_lstride = 0x3a02;
pub const OP_addr = 0x03; pub const OP_addr = 0x03;
pub const OP_deref = 0x06; pub const OP_deref = 0x06;
pub const OP_const1u = 0x08; pub const OP_const1u = 0x08;
@ -577,7 +576,6 @@ pub const ATE_HP_unsigned_fixed = 0x8e; // Cobol.
pub const ATE_HP_VAX_complex_float = 0x8f; // F or G floating complex. pub const ATE_HP_VAX_complex_float = 0x8f; // F or G floating complex.
pub const ATE_HP_VAX_complex_float_d = 0x90; // D floating complex. pub const ATE_HP_VAX_complex_float_d = 0x90; // D floating complex.
pub const CFA_advance_loc = 0x40; pub const CFA_advance_loc = 0x40;
pub const CFA_offset = 0x80; pub const CFA_offset = 0x80;
pub const CFA_restore = 0xc0; pub const CFA_restore = 0xc0;

42
std/elf.zig
View File

@ -123,13 +123,11 @@ pub const DT_SYMINFO = 0x6ffffeff;
pub const DT_ADDRRNGHI = 0x6ffffeff; pub const DT_ADDRRNGHI = 0x6ffffeff;
pub const DT_ADDRNUM = 11; pub const DT_ADDRNUM = 11;
pub const DT_VERSYM = 0x6ffffff0; pub const DT_VERSYM = 0x6ffffff0;
pub const DT_RELACOUNT = 0x6ffffff9; pub const DT_RELACOUNT = 0x6ffffff9;
pub const DT_RELCOUNT = 0x6ffffffa; pub const DT_RELCOUNT = 0x6ffffffa;
pub const DT_FLAGS_1 = 0x6ffffffb; pub const DT_FLAGS_1 = 0x6ffffffb;
pub const DT_VERDEF = 0x6ffffffc; pub const DT_VERDEF = 0x6ffffffc;
@ -139,13 +137,10 @@ pub const DT_VERNEED = 0x6ffffffe;
pub const DT_VERNEEDNUM = 0x6fffffff; pub const DT_VERNEEDNUM = 0x6fffffff;
pub const DT_VERSIONTAGNUM = 16; pub const DT_VERSIONTAGNUM = 16;
pub const DT_AUXILIARY = 0x7ffffffd; pub const DT_AUXILIARY = 0x7ffffffd;
pub const DT_FILTER = 0x7fffffff; pub const DT_FILTER = 0x7fffffff;
pub const DT_EXTRANUM = 3; pub const DT_EXTRANUM = 3;
pub const DT_SPARC_REGISTER = 0x70000001; pub const DT_SPARC_REGISTER = 0x70000001;
pub const DT_SPARC_NUM = 2; pub const DT_SPARC_NUM = 2;
@ -434,9 +429,7 @@ pub const Elf = struct {
try elf.in_file.seekForward(4); try elf.in_file.seekForward(4);
const header_size = try in.readInt(elf.endian, u16); const header_size = try in.readInt(elf.endian, u16);
if ((elf.is_64 and header_size != 64) or if ((elf.is_64 and header_size != 64) or (!elf.is_64 and header_size != 52)) {
(!elf.is_64 and header_size != 52))
{
return error.InvalidFormat; return error.InvalidFormat;
} }
@ -467,16 +460,16 @@ pub const Elf = struct {
if (sh_entry_size != 64) return error.InvalidFormat; if (sh_entry_size != 64) return error.InvalidFormat;
for (elf.section_headers) |*elf_section| { for (elf.section_headers) |*elf_section| {
elf_section.name = try in.readInt(elf.endian, u32); elf_section.name = try in.readInt(elf.endian, u32);
elf_section.sh_type = try in.readInt(elf.endian, u32); elf_section.sh_type = try in.readInt(elf.endian, u32);
elf_section.flags = try in.readInt(elf.endian, u64); elf_section.flags = try in.readInt(elf.endian, u64);
elf_section.addr = try in.readInt(elf.endian, u64); elf_section.addr = try in.readInt(elf.endian, u64);
elf_section.offset = try in.readInt(elf.endian, u64); elf_section.offset = try in.readInt(elf.endian, u64);
elf_section.size = try in.readInt(elf.endian, u64); elf_section.size = try in.readInt(elf.endian, u64);
elf_section.link = try in.readInt(elf.endian, u32); elf_section.link = try in.readInt(elf.endian, u32);
elf_section.info = try in.readInt(elf.endian, u32); elf_section.info = try in.readInt(elf.endian, u32);
elf_section.addr_align = try in.readInt(elf.endian, u64); elf_section.addr_align = try in.readInt(elf.endian, u64);
elf_section.ent_size = try in.readInt(elf.endian, u64); elf_section.ent_size = try in.readInt(elf.endian, u64);
} }
} else { } else {
if (sh_entry_size != 40) return error.InvalidFormat; if (sh_entry_size != 40) return error.InvalidFormat;
@ -513,8 +506,7 @@ pub const Elf = struct {
pub fn close(elf: &Elf) void { pub fn close(elf: &Elf) void {
elf.allocator.free(elf.section_headers); elf.allocator.free(elf.section_headers);
if (elf.auto_close_stream) if (elf.auto_close_stream) elf.in_file.close();
elf.in_file.close();
} }
pub fn findSection(elf: &Elf, name: []const u8) !?&SectionHeader { pub fn findSection(elf: &Elf, name: []const u8) !?&SectionHeader {
@ -852,27 +844,27 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
flags2: Elf32_Word, flags2: Elf32_Word,
}; };
pub const Ehdr = switch(@sizeOf(usize)) { pub const Ehdr = switch (@sizeOf(usize)) {
4 => Elf32_Ehdr, 4 => Elf32_Ehdr,
8 => Elf64_Ehdr, 8 => Elf64_Ehdr,
else => @compileError("expected pointer size of 32 or 64"), else => @compileError("expected pointer size of 32 or 64"),
}; };
pub const Phdr = switch(@sizeOf(usize)) { pub const Phdr = switch (@sizeOf(usize)) {
4 => Elf32_Phdr, 4 => Elf32_Phdr,
8 => Elf64_Phdr, 8 => Elf64_Phdr,
else => @compileError("expected pointer size of 32 or 64"), else => @compileError("expected pointer size of 32 or 64"),
}; };
pub const Sym = switch(@sizeOf(usize)) { pub const Sym = switch (@sizeOf(usize)) {
4 => Elf32_Sym, 4 => Elf32_Sym,
8 => Elf64_Sym, 8 => Elf64_Sym,
else => @compileError("expected pointer size of 32 or 64"), else => @compileError("expected pointer size of 32 or 64"),
}; };
pub const Verdef = switch(@sizeOf(usize)) { pub const Verdef = switch (@sizeOf(usize)) {
4 => Elf32_Verdef, 4 => Elf32_Verdef,
8 => Elf64_Verdef, 8 => Elf64_Verdef,
else => @compileError("expected pointer size of 32 or 64"), else => @compileError("expected pointer size of 32 or 64"),
}; };
pub const Verdaux = switch(@sizeOf(usize)) { pub const Verdaux = switch (@sizeOf(usize)) {
4 => Elf32_Verdaux, 4 => Elf32_Verdaux,
8 => Elf64_Verdaux, 8 => Elf64_Verdaux,
else => @compileError("expected pointer size of 32 or 64"), else => @compileError("expected pointer size of 32 or 64"),

13
std/event.zig
View File

@ -76,19 +76,14 @@ pub const TcpServer = struct {
} }
continue; continue;
}, },
error.ConnectionAborted, error.ConnectionAborted, error.FileDescriptorClosed => continue,
error.FileDescriptorClosed => continue,
error.PageFault => unreachable, error.PageFault => unreachable,
error.InvalidSyscall => unreachable, error.InvalidSyscall => unreachable,
error.FileDescriptorNotASocket => unreachable, error.FileDescriptorNotASocket => unreachable,
error.OperationNotSupported => unreachable, error.OperationNotSupported => unreachable,
error.SystemFdQuotaExceeded, error.SystemFdQuotaExceeded, error.SystemResources, error.ProtocolFailure, error.BlockedByFirewall, error.Unexpected => {
error.SystemResources,
error.ProtocolFailure,
error.BlockedByFirewall,
error.Unexpected => {
@panic("TODO handle this error"); @panic("TODO handle this error");
}, },
} }
@ -121,7 +116,6 @@ pub const Loop = struct {
pub fn removeFd(self: &Loop, fd: i32) void { pub fn removeFd(self: &Loop, fd: i32) void {
std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_DEL, fd, undefined) catch {}; std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_DEL, fd, undefined) catch {};
} }
async fn waitFd(self: &Loop, fd: i32) !void { async fn waitFd(self: &Loop, fd: i32) !void {
defer self.removeFd(fd); defer self.removeFd(fd);
suspend |p| { suspend |p| {
@ -169,7 +163,6 @@ test "listen on a port, send bytes, receive bytes" {
tcp_server: TcpServer, tcp_server: TcpServer,
const Self = this; const Self = this;
async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address, _socket: &const std.os.File) void { async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address, _socket: &const std.os.File) void {
const self = @fieldParentPtr(Self, "tcp_server", tcp_server); const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733 var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
@ -184,7 +177,6 @@ test "listen on a port, send bytes, receive bytes" {
cancel p; cancel p;
} }
} }
async fn errorableHandler(self: &Self, _addr: &const std.net.Address, _socket: &const std.os.File) !void { async fn errorableHandler(self: &Self, _addr: &const std.net.Address, _socket: &const std.os.File) !void {
const addr = _addr.*; // TODO https://github.com/ziglang/zig/issues/733 const addr = _addr.*; // TODO https://github.com/ziglang/zig/issues/733
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733 var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
@ -207,7 +199,6 @@ test "listen on a port, send bytes, receive bytes" {
defer cancel p; defer cancel p;
loop.run(); loop.run();
} }
async fn doAsyncTest(loop: &Loop, address: &const std.net.Address) void { async fn doAsyncTest(loop: &Loop, address: &const std.net.Address) void {
errdefer @panic("test failure"); errdefer @panic("test failure");

7
std/fmt/errol/enum3.zig
View File

@ -1,4 +1,4 @@
pub const enum3 = []u64 { pub const enum3 = []u64{
0x4e2e2785c3a2a20b, 0x4e2e2785c3a2a20b,
0x240a28877a09a4e1, 0x240a28877a09a4e1,
0x728fca36c06cf106, 0x728fca36c06cf106,
@ -439,13 +439,13 @@ const Slab = struct {
}; };
fn slab(str: []const u8, exp: i32) Slab { fn slab(str: []const u8, exp: i32) Slab {
return Slab { return Slab{
.str = str, .str = str,
.exp = exp, .exp = exp,
}; };
} }
pub const enum3_data = []Slab { pub const enum3_data = []Slab{
slab("40648030339495312", 69), slab("40648030339495312", 69),
slab("4498645355592131", -134), slab("4498645355592131", -134),
slab("678321594594593", 244), slab("678321594594593", 244),
@ -879,4 +879,3 @@ pub const enum3_data = []Slab {
slab("32216657306260762", 218), slab("32216657306260762", 218),
slab("30423431424080128", 219), slab("30423431424080128", 219),
}; };