blob: faa885c6ecbb8ca4e42abb66ea5da523ebfc33a6 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
const std = @import("std");
const wasm = @import("../wasm.zig");
// Use the correct implementation
pub const log = Freestanding.log;
/// Freestanding implementation calls an extern "log" function.
pub const Freestanding = struct {
// The function std.log will call.
pub fn log(
comptime level: std.log.Level,
comptime scope: @TypeOf(.EnumLiteral),
comptime format: []const u8,
args: anytype,
) void {
// The buffer for putting our log message. We try to use a stack-allocated
// buffer first because we want to avoid allocation. If we are logging
// an error DUE to an OOM, allocating will of course fail and we'd like
// to see the error message so we prefer to use this.
var buf: [2048]u8 = undefined;
// Build the string
const level_txt = comptime level.asText();
const prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
const txt = level_txt ++ prefix ++ format;
// Format. We attempt to use a stack-allocated string first and if that
// fails we'll try to allocate.
var allocated: bool = false;
const str = nosuspend std.fmt.bufPrint(&buf, txt, args) catch str: {
allocated = true;
break :str std.fmt.allocPrint(wasm.alloc, txt, args) catch return;
};
defer if (allocated) wasm.alloc.free(str);
// Send it over to the JS side
JS.log(str.ptr, str.len);
}
// We wrap our externs in this namespace so we can reuse symbols, otherwise
// "log" would collide.
const JS = struct {
extern "env" fn log(ptr: [*]const u8, len: usize) void;
};
};
|
