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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
const std = @import("std");
const Environment = @import("./env.zig");
const Output = @import("output.zig");
const use_mimalloc = @import("./global.zig").use_mimalloc;
const StringTypes = @import("./string_types.zig");
pub const build_id = std.fmt.parseInt(u64, std.mem.trim(u8, @embedFile("../build-id"), "\n \r\t"), 10) catch unreachable;
pub const package_json_version = if (Environment.isDebug)
std.fmt.comptimePrint("0.0.{d}_debug", .{build_id})
else
std.fmt.comptimePrint("0.0.{d}", .{build_id});
pub const os_name = if (Environment.isWindows)
"win32"
else if (Environment.isMac)
"darwin"
else if (Environment.isLinux)
"linux"
else if (Environment.isWasm)
"wasm"
else
"unknown";
pub const arch_name = if (Environment.isX64)
"x64"
else if (Environment.isAarch64)
"arm64"
else
"unknown";
pub inline fn getStartTime() i128 {
if (Environment.isTest) return 0;
return @import("root").start_time;
}
pub fn setThreadName(name: StringTypes.stringZ) void {
if (Environment.isLinux) {
_ = std.os.prctl(.SET_NAME, .{@ptrToInt(name.ptr)}) catch 0;
} else if (Environment.isMac) {
_ = std.c.pthread_setname_np(name);
}
}
pub fn exit(code: u8) noreturn {
Output.flush();
std.os.exit(code);
}
pub const AllocatorConfiguration = struct {
verbose: bool = false,
long_running: bool = false,
};
pub const Mimalloc = @import("./allocators/mimalloc.zig");
pub inline fn mimalloc_cleanup(force: bool) void {
if (comptime use_mimalloc) {
Mimalloc.mi_collect(force);
}
}
pub const versions = @import("./generated_versions_list.zig");
// Enabling huge pages slows down bun by 8x or so
// Keeping this code for:
// 1. documentation that an attempt was made
// 2. if I want to configure allocator later
pub inline fn configureAllocator(_: AllocatorConfiguration) void {
// if (comptime !use_mimalloc) return;
// const Mimalloc = @import("./allocators/mimalloc.zig");
// Mimalloc.mi_option_set_enabled(Mimalloc.mi_option_verbose, config.verbose);
// Mimalloc.mi_option_set_enabled(Mimalloc.mi_option_large_os_pages, config.long_running);
// if (!config.long_running) Mimalloc.mi_option_set(Mimalloc.mi_option_reset_delay, 0);
}
pub fn panic(comptime fmt: string, args: anytype) noreturn {
@setCold(true);
if (comptime Environment.isWasm) {
Output.printErrorln(fmt, args);
Output.flush();
@panic(fmt);
} else {
Output.prettyErrorln(fmt, args);
Output.flush();
std.debug.panic(fmt, args);
}
}
// std.debug.assert but happens at runtime
pub fn invariant(condition: bool, comptime fmt: string, args: anytype) void {
if (!condition) {
_invariant(fmt, args);
}
}
inline fn _invariant(comptime fmt: string, args: anytype) noreturn {
@setCold(true);
if (comptime Environment.isWasm) {
Output.printErrorln(fmt, args);
Output.flush();
@panic(fmt);
} else {
Output.prettyErrorln(fmt, args);
Output.flush();
Global.exit(1);
}
}
pub fn notimpl() noreturn {
@setCold(true);
Global.panic("Not implemented yet!!!!!", .{});
}
// Make sure we always print any leftover
pub fn crash() noreturn {
@setCold(true);
Output.flush();
Global.exit(1);
}
const Global = @This();
const string = @import("./global.zig").string;
pub const BunInfo = struct {
bun_version: string,
platform: Analytics.GenerateHeader.GeneratePlatform.Platform = undefined,
framework: string = "",
framework_version: string = "",
const Analytics = @import("./analytics/analytics_thread.zig");
const JSON = @import("./json_parser.zig");
const JSAst = @import("./js_ast.zig");
pub fn generate(comptime Bundler: type, bundler: Bundler, allocator: std.mem.Allocator) !JSAst.Expr {
var info = BunInfo{
.bun_version = Global.package_json_version,
.platform = Analytics.GenerateHeader.GeneratePlatform.forOS(),
};
if (bundler.options.framework) |framework| {
info.framework = framework.package;
info.framework_version = framework.version;
}
return try JSON.toAST(allocator, BunInfo, info);
}
};
|
