file_text stringlengths 1 2.1M ⌀ | language stringclasses 416
values | file_name stringlengths 1 185 ⌀ |
|---|---|---|
const tester = @import("../test/tester.zig");
const std = @import("std");
const strings = @import("../string_immutable.zig");
const FeatureFlags = @import("../feature_flags.zig");
const default_allocator = @import("../memory_allocator.zig").c_allocator;
const bun = @import("root").bun;
const Fs = @import("../fs.zig");
... | Zig | resolve_path.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const FeatureFlags = bun.FeatureFlags;
const PathString = bun.PathString;
const stringZ = bun.strin... | Zig | resolver.zig |
const std = @import("std");
const Api = @import("../../api/schema.zig").Api;
const bun = @import("root").bun;
const MimeType = bun.http.MimeType;
const ZigURL = @import("../../url.zig").URL;
const http = @import("root").bun.http;
const FetchRedirect = http.FetchRedirect;
const JSC = @import("root").bun.JSC;
const js = ... | Zig | response.zig |
pub fn Result(comptime T: type, comptime E: type) type {
return union(enum) {
ok: T,
err: E,
pub inline fn asErr(this: *const @This()) ?E {
if (this.* == .err) return this.err;
return null;
}
};
}
| Zig | result.zig |
pub usingnamespace @import("./src/main.zig");
/// These functions are used throughout Bun's codebase.
pub const bun = @import("./src/bun.zig");
pub const content = struct {
pub const error_js_path = "packages/bun-error/dist/index.js";
pub const error_js = @embedFile(error_js_path);
pub const error_css_pa... | Zig | root.zig |
const std = @import("std");
const testing = std.testing;
export fn add(a: i32, b: i32) i32 {
return a + b;
}
test "basic add functionality" {
try testing.expect(add(3, 7) == 10);
}
| Zig | root_1.zig |
pub usingnamespace @import("src/main_wasm.zig");
pub const bun = @import("src/bun.zig");
pub const content = struct {
pub const error_js_path = "packages/bun-error/dist/index.js";
pub const error_js = @embedFile(error_js_path);
pub const error_css_path = "packages/bun-error/dist/bun-error.css";
pub c... | Zig | root_wasm.zig |
// This is a Next.js-compatible file-system router.
// It uses the filesystem to infer entry points.
// Despite being Next.js-compatible, it's not tied to Next.js.
// It does not handle the framework parts of rendering pages.
// All it does is resolve URL paths to the appropriate entry point and parse URL params/query.... | Zig | router.zig |
const bun = @import("root").bun;
const Async = bun.Async;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocat... | Zig | run_command.zig |
const options = @import("./options.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bu... | Zig | runtime.zig |
const std = @import("std");
pub const Reader = struct {
const Self = @This();
pub const ReadError = error{EOF};
buf: []u8,
remain: []u8,
allocator: std.mem.Allocator,
pub fn init(buf: []u8, allocator: std.mem.Allocator) Reader {
return Reader{
.buf = buf,
.rema... | Zig | schema.zig |
const JSC = @import("root").bun.JSC;
pub const ScriptExecutionContext = extern struct {
main_file_path: JSC.ZigString,
is_macro: bool = false,
js_global_object: bool = false,
};
| Zig | script_execution_context.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const utils = @import("utils.zig");
const buildTree = utils.buildTree;
const queryParser = @import("../../query_parser.zig");
const RawDecl = @import("utils.zig").RawDecl;
const Variance = @import("../variance.zig").Variance;
test "function ... | Zig | search_with_variance_test.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const... | Zig | semver.zig |
const Bun = @This();
const default_allocator = @import("root").bun.default_allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const Global = bun.Global;
const strings = bun.strings;
const string = bun.string;
const Output = @import("root").bun.Output;
const MutableString = @import("root")... | Zig | server.zig |
const std = @import("std");
const net = std.net;
const Allocator = std.mem.Allocator;
const RndGen = std.rand.DefaultPrng;
const common = @import("common.zig");
const queryParser = @import("../query_parser.zig");
const tree = @import("../engine/tree.zig");
const Tree = @import("../engine/tree.zig").Tree;
const Declar... | Zig | server_1.zig |
const BoringSSL = @import("root").bun.BoringSSL;
const std = @import("std");
pub const bun = if (@import("build_options").project.len == 0) @import("./bun.zig") else @import("root").bun;
fn NewHasher(comptime digest_size: comptime_int, comptime ContextType: type, comptime Full: anytype, comptime Init: anytype, compti... | Zig | sha.zig |
const bun = @import("root").bun;
const std = @import("std");
const builtin = @import("builtin");
const Arena = std.heap.ArenaAllocator;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const JSC = bun.JSC;
const JSValue = bun.JSC.JSValue;
const JSPromise = bun.JSC.JSPromise;
const JSGlobalObject = ... | Zig | shell.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allo... | Zig | shell_completions.zig |
const std = @import("std");
const StaticExport = @import("./static_export.zig");
const Sizes = @import("./sizes.zig");
pub const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
const headers = @import("./headers.zig");
fn isNullableType(comptime Type: type) bool {
return @typeInfo(Type) == ... | Zig | shimmer.zig |
// Auto-generated by src/bun.js/headergen/sizegen.cpp at 2022-11-24 20:03:1669349010.
// These are the byte sizes for the different object types with bindings in JavaScriptCore.
// This allows us to safely return stack allocated C++ types to Zig.
// It is only safe to do this when these sizes are correct.
// That means... | Zig | sizes.zig |
const std = @import("std");
const bun = @import("root").bun;
const default_allocator = bun.default_allocator;
const string = bun.string;
const MutableString = bun.MutableString;
const strings = bun.strings;
const logger = bun.logger;
const jest = @import("./jest.zig");
const Jest = jest.Jest;
const TestRunner = jest.Te... | Zig | snapshot.zig |
const default_allocator = @import("root").bun.default_allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const Global = bun.Global;
const strings = bun.strings;
const string = bun.string;
const Output = @import("root").bun.Output;
const MutableString = @import("root").bun.MutableString;
c... | Zig | socket.zig |
pub const VLQ_BASE_SHIFT: u32 = 5;
pub const VLQ_BASE: u32 = 1 << VLQ_BASE_SHIFT;
pub const VLQ_BASE_MASK: u32 = VLQ_BASE - 1;
pub const VLQ_CONTINUATION_BIT: u32 = VLQ_BASE;
pub const VLQ_CONTINUATION_MASK: u32 = 1 << VLQ_CONTINUATION_BIT;
const std = @import("std");
const bun = @import("root").bun;
const string = bun... | Zig | sourcemap.zig |
const JSC = @import("root").bun.JSC;
const bun = @import("root").bun;
const string = bun.string;
const std = @import("std");
fn _getSystem() type {
// this is a workaround for a Zig stage1 bug
// the "usingnamespace" is evaluating in dead branches
return brk: {
if (comptime bun.Environment.isLinux)... | Zig | spawn.zig |
const std = @import("std");
Type: type,
symbol_name: []const u8,
local_name: []const u8,
Parent: type,
pub fn Decl(comptime this: *const @This()) std.builtin.Type.Declaration {
return comptime std.meta.declarationInfo(this.Parent, this.local_name);
}
pub fn wrappedName(comptime this: *const @This()) []const u8 {... | Zig | static_export.zig |
const builtin = @import("builtin");
const clap = @import("../clap.zig");
const std = @import("std");
const Output = @import("root").bun.Output;
const args = clap.args;
const debug = std.debug;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const os = std.os;
const testing = std.testing;
// Disabled be... | Zig | streaming.zig |
const std = @import("std");
const Api = @import("../../api/schema.zig").Api;
const bun = @import("root").bun;
const MimeType = HTTPClient.MimeType;
const ZigURL = @import("../../url.zig").URL;
const HTTPClient = bun.http;
const JSC = @import("root").bun.JSC;
const js = JSC.C;
const Method = @import("../../http/method.... | Zig | streams.zig |
const strings = @import("root").bun.strings;
const std = @import("std");
pub fn main() anyerror!void {
const args = try std.process.argsAlloc(std.heap.c_allocator);
const filepath = args[args.len - 3];
const find = args[args.len - 2];
const amount = try std.fmt.parseInt(usize, args[args.len - 1], 10);
... | Zig | string-handling.zig |
const std = @import("std");
const bun = @import("root").bun;
const JSC = bun.JSC;
const JSValue = bun.JSC.JSValue;
const Parent = @This();
pub const BufferOwnership = enum(u32) {
BufferInternal,
BufferOwned,
BufferSubstring,
BufferExternal,
};
pub const WTFStringImpl = *WTFStringImplStruct;
pub const... | Zig | string.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const string = @import("string_types.zig").string;
const StringBuilder = @This();
const assert = std.debug.assert;
const DebugHashTable = if (Environment.allow_assert) std.AutoHashMapU... | Zig | string_builder.zig |
const std = @import("std");
const expect = std.testing.expect;
const Environment = @import("./env.zig");
const string = bun.string;
const stringZ = bun.stringZ;
const CodePoint = bun.CodePoint;
const bun = @import("root").bun;
pub const joiner = @import("./string_joiner.zig");
const log = bun.Output.scoped(.STR, true);... | Zig | string_immutable.zig |
/// Rope-like data structure for joining many small strings into one big string.
const std = @import("std");
const default_allocator = bun.default_allocator;
const bun = @import("root").bun;
const string = bun.string;
const Allocator = std.mem.Allocator;
const ObjectPool = @import("./pool.zig").ObjectPool;
const Joiner... | Zig | string_joiner.zig |
const std = @import("std");
const expect = std.testing.expect;
const bun = @import("root").bun;
const strings = bun.strings;
const js_lexer = bun.js_lexer;
const string = bun.string;
const stringZ = bun.stringZ;
const CodePoint = bun.CodePoint;
pub const MutableString = struct {
allocator: std.mem.Allocator,
... | Zig | string_mutable.zig |
const std = @import("std");
const BabyList = @import("./baby_list.zig").BabyList;
pub const string = []const u8;
pub const stringZ = [:0]const u8;
pub const stringMutable = []u8;
pub const CodePoint = i32;
const bun = @import("root").bun;
// macOS sets file path limit to 1024
// Since a pointer on x64 is 64 bits and on... | Zig | string_types.zig |
pub const Loop = opaque {};
pub const KeepAlive = opaque {};
pub const FilePoll = opaque {};
| Zig | stub_event_loop.zig |
const default_allocator = @import("root").bun.default_allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const NetworkThread = @import("root").bun.http.NetworkThread;
const Global = bun.Global;
const strings = bun.strings;
const string = bun.string;
const Output = @import("root").bun.Outpu... | Zig | subproc.zig |
const default_allocator = @import("root").bun.default_allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const Global = bun.Global;
const strings = bun.strings;
const string = bun.string;
const Output = @import("root").bun.Output;
const MutableString = @import("root").bun.MutableString;
c... | Zig | subprocess.zig |
const std = @import("std");
const system = if (bun.Environment.isWindows) std.os.windows else std.os.system;
const bun = @import("root").bun;
// https://gist.github.com/kprotty/0d2dc3da4840341d6ff361b27bdac7dc
pub const ThreadPool = struct {
state: usize = 0,
spawned: usize = 0,
run_queue: Queue,
idle_... | Zig | sync.zig |
// This file is entirely based on Zig's std.os
// The differences are in error handling
const std = @import("std");
const builtin = @import("builtin");
const bun = @import("root").bun;
const os = std.os;
const assertIsValidWindowsPath = bun.strings.assertIsValidWindowsPath;
const default_allocator = bun.default_alloc... | Zig | sys.zig |
//! bun.sys.sys_uv is a polyfill of bun.sys but with libuv.
//! TODO: Probably should merge this into bun.sys itself with isWindows checks
const std = @import("std");
const os = std.os;
const bun = @import("root").bun;
const assertIsValidWindowsPath = bun.strings.assertIsValidWindowsPath;
const fd_t = bun.FileDescript... | Zig | sys_uv.zig |
const Environment = @import("./env.zig");
const std = @import("std");
fn NewTimer() type {
if (Environment.isWasm) {
return struct {
pub fn start() anyerror!@This() {
return @This(){};
}
pub fn read(_: anytype) u64 {
@compileError("Featur... | Zig | system_timer.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const default_allocator = bun.default_allocator;
const C = bun.C;
const typeBaseName = @import("./meta.zig").typ... | Zig | tagged_pointer.zig |
pub const TCCState = opaque {};
pub const TCCErrorFunc = ?*const fn (?*anyopaque, [*c]const u8) callconv(.C) void;
pub extern fn tcc_new() ?*TCCState;
pub extern fn tcc_delete(s: *TCCState) void;
pub extern fn tcc_set_lib_path(s: *TCCState, path: [*c]const u8) void;
pub extern fn tcc_set_error_func(s: *TCCState, error_... | Zig | tcc.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | test_command.zig |
const std = @import("std");
const string = []const u8;
const RED = "\x1b[31;1m";
const GREEN = "\x1b[32;1m";
const CYAN = "\x1b[36;1m";
const WHITE = "\x1b[37;1m";
const DIM = "\x1b[2m";
const RESET = "\x1b[0m";
pub const Tester = struct {
pass: std.ArrayList(Expectation),
fail: std.ArrayList(Expectation),
... | Zig | tester.zig |
const std = @import("std");
const path_handler = @import("../src/resolver/resolve_path.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
cons... | Zig | tgz.zig |
// Thank you @kprotty.
// https://github.com/kprotty/zap/blob/blog/src/thread_pool.zig
const std = @import("std");
const bun = @import("root").bun;
const ThreadPool = @This();
const Futex = @import("./futex.zig");
const Environment = bun.Environment;
const assert = std.debug.assert;
const Atomic = std.atomic.Value;
p... | Zig | thread_pool.zig |
const std = @import("std");
const assert = std.debug.assert;
const is_darwin = @import("builtin").target.isDarwin();
pub const Time = struct {
const Self = @This();
/// Hardware and/or software bugs can mean that the monotonic clock may regress.
/// One example (of many): https://bugzilla.redhat.com/show_... | Zig | time.zig |
// -------------------------------------------------------------------------- //
// Copyright (c) 2019, Jairus Martin. //
// Distributed under the terms of the MIT License. //
// The full license is in the file LICENSE, distributed with this software. ... | Zig | timezones.zig |
const bun = @import("root").bun;
const std = @import("std");
const Environment = bun.Environment;
const O = std.os.O;
// O_TMPFILE doesn't seem to work very well.
const allow_tmpfile = false;
// To be used with files
// not folders!
pub const Tmpfile = struct {
destination_dir: bun.FileDescriptor = bun.invalid_fd... | Zig | tmp.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const js_ast = bun.JSAst;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const CodePoint = bun.CodePoint;
const Mut... | Zig | toml_lexer.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const toml_lexer = @import("./toml_lexer.zig");
const Lexer = toml_lexer.Lexer;
const importRecord = @import("../import_record.zig");
const js_ast = bun.JSAst;
const options = @import("../options.zig");
const fs = @import("../fs.zig");
const bun = ... | Zig | toml_parser.zig |
/// https://github.com/wolfpld/tracy
/// To use this module, you must have Tracy installed on your system.
/// On macOS, you can install it with `brew install tracy`.
///
/// This file is based on the code from Zig's transpiler source.
/// Thank you to the Zig team
///
const std = @import("std");
const builtin = @impor... | Zig | tracy.zig |
/// Returns true if the passed type will coerce to []const u8.
/// Any of the following are considered strings:
/// ```
/// []const u8, [:S]const u8, *const [N]u8, *const [N:S]u8,
/// []u8, [:S]u8, *[:S]u8, *[N:S]u8.
/// ```
/// These types are not considered strings:
/// ```
/// u8, [N]u8, [*]const u8, [*:0]const u8,
... | Zig | trait.zig |
const std = @import("std");
const net = std.net;
const Allocator = @import("std").mem.Allocator;
const Arena = @import("std").heap.ArenaAllocator;
const SegmentedList = @import("std").SegmentedList;
const queryParser = @import("../query_parser.zig");
const utils = @import("utils.zig");
const constants = @import("const... | Zig | tree.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | tsconfig_json.zig |
const std = @import("std");
const builtin = @import("builtin");
const bun = @import("root").bun;
const meta = bun.meta;
const windows = bun.windows;
const heap_allocator = bun.default_allocator;
const is_bindgen: bool = meta.globalOption("bindgen", bool) orelse false;
const kernel32 = windows.kernel32;
const logger = b... | Zig | types.zig |
const std = @import("std");
const os = std.os;
const mem = std.mem;
const meta = std.meta;
const atomic = std.atomic;
const builtin = std.builtin;
const testing = std.testing;
const assert = std.debug.assert;
const mpsc = @This();
pub const cache_line_length = switch (@import("builtin").target.cpu.arch) {
.x86_... | Zig | unbounded_queue.zig |
const Command = @import("../cli.zig").Command;
const PackageManager = @import("../install/install.zig").PackageManager;
pub const UnlinkCommand = struct {
pub fn exec(ctx: Command.Context) !void {
try PackageManager.unlink(ctx);
}
};
| Zig | unlink_command.zig |
const Command = @import("../cli.zig").Command;
const PackageManager = @import("../install/install.zig").PackageManager;
pub const UpdateCommand = struct {
pub fn exec(ctx: Command.Context) !void {
try PackageManager.update(ctx);
}
};
| Zig | update_command.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | upgrade_command.zig |
const std = @import("std");
const Api = @import("./api/schema.zig").Api;
const resolve_path = @import("./resolver/resolve_path.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const ... | Zig | url.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
con... | Zig | url_path.zig |
const IPC = @import("../bun.js/ipc.zig");
const Allocator = std.mem.Allocator;
const uws = bun.uws;
const std = @import("std");
const default_allocator = @import("root").bun.default_allocator;
const bun = @import("root").bun;
const Environment = bun.Environment;
const Async = bun.Async;
const JSC = @import("root").bun.... | Zig | util.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const queryParser = @import("../../query_parser.zig");
const Tree = @import("../tree.zig").Tree;
const Declaration = @import("../entities.zig").Declaration;
pub const RawDecl = struct {
ty: []const u8,
name: []const u8,
};
pub fn bu... | Zig | utils.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const main = @import("../main.zig");
const EngineError = @import("error.zig").EngineError;
const Declaration = @import("entities.zig").Declaration;
const Node = @import("Node.zig");
const TypeNode = @import("TypeNode.zig");
const Type = @impo... | Zig | utils_1.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const RndGen = std.rand.DefaultPrng;
const main = @import("main.zig");
const queryParser = @import("query_parser.zig");
const TypeC = queryParser.TypeC;
const List = queryParser.List;
pub fn randomName(allocator: Allocator) anyerror![]const u... | Zig | utils_2.zig |
//https://github.com/dmgk/zig-uuid
const std = @import("std");
const crypto = std.crypto;
const fmt = std.fmt;
const testing = std.testing;
const bun = @import("root").bun;
pub const Error = error{InvalidUUID};
const UUID = @This();
bytes: [16]u8,
pub fn init() UUID {
var uuid = UUID{ .bytes = undefined };
... | Zig | uuid.zig |
pub const is_bindgen = @import("std").meta.globalOption("bindgen", bool) orelse false;
const bun = @import("root").bun;
const Api = bun.ApiSchema;
const std = @import("std");
const Environment = bun.Environment;
pub const u_int8_t = u8;
pub const u_int16_t = c_ushort;
pub const u_int32_t = c_uint;
pub const u_int64_t =... | Zig | uws.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const JSC = @import("root").bun.JSC;
const JSValue = JSC.JSValue;
const JSGlobalObject = JSC.JSGlobalObject;
const ZigString = JSC.ZigString;
pub fn getTypeName(globalObject: *JSGlobalObject, value: JSValue) ZigString {
var js_... | Zig | validators.zig |
const Semver = @import("./semver.zig");
const String = @import("./semver.zig").String;
pub const VersionedURL = extern struct {
url: String,
version: Semver.Version,
pub fn eql(this: VersionedURL, other: VersionedURL) bool {
return this.version.eql(other.version);
}
pub fn order(this: Ver... | Zig | versioned_url.zig |
const std = @import("std");
const SourceMap = struct {
const base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const vlq_lookup_table: [256]VLQ = brk: {
var entries: [256]VLQ = undefined;
var i: usize = 0;
var j: i32 = 0;
while (i < 256) : (i += 1) {
... | Zig | vlq_bench.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const Walker = @This();
const bun = @import("root").bun;
const path = std.fs.path;
const DirIterator = bun.DirIterator;
const Environment = bun.Environment;
const OSPathSlice = bun.OSPathSlice;
stack: std.ArrayList(StackItem),
name_buffer: NameBufferList... | Zig | walker_skippable.zig |
export fn hello() i32 {
return 1;
}
pub fn main() void {}
| Zig | wasm-return-1-test.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const stringZ = bun.stringZ;
const FeatureFlags = bun.FeatureFlags;
const options = @import("./options.zig");
c... | Zig | watcher.zig |
const bun = @import("root").bun;
const JSC = bun.JSC;
const Output = bun.Output;
const log = Output.scoped(.Worker, true);
const std = @import("std");
const JSValue = JSC.JSValue;
const Async = bun.Async;
const WTFStringImpl = @import("../string.zig").WTFStringImpl;
/// Shared implementation of Web and Node `Worker`
p... | Zig | web_worker.zig |
pub usingnamespace @import("./webcore/response.zig");
pub usingnamespace @import("./webcore/encoding.zig");
pub usingnamespace @import("./webcore/streams.zig");
pub usingnamespace @import("./webcore/blob.zig");
pub usingnamespace @import("./webcore/request.zig");
pub usingnamespace @import("./webcore/body.zig");
const... | Zig | webcore.zig |
// This code is based on https://github.com/frmdstryr/zhp/blob/a4b5700c289c3619647206144e10fb414113a888/src/websocket.zig
// Thank you @frmdstryr.
const std = @import("std");
const os = std.os;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Envir... | Zig | websocket.zig |
// This code is based on https://github.com/frmdstryr/zhp/blob/a4b5700c289c3619647206144e10fb414113a888/src/websocket.zig
// Thank you @frmdstryr.
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Enviro... | Zig | websocket_http_client.zig |
const std = @import("std");
const bun = @import("root").bun;
const PosixToWinNormalizer = bun.path.PosixToWinNormalizer;
fn isValid(buf: *bun.PathBuffer, segment: []const u8, bin: []const u8) ?u16 {
bun.copy(u8, buf, segment);
buf[segment.len] = std.fs.path.sep;
bun.copy(u8, buf[segment.len + 1 ..], bin);
... | Zig | which.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
con... | Zig | which_npm_client.zig |
const std = @import("std");
const bun = @import("root").bun;
const windows = bun.windows;
const uv = windows.libuv;
const Path = @import("../../resolver/resolve_path.zig");
const Fs = @import("../../fs.zig");
const Mutex = @import("../../lock.zig").Lock;
const string = bun.string;
const JSC = bun.JSC;
const VirtualMach... | Zig | win_watcher.zig |
const bun = @import("root").bun;
const windows = std.os.windows;
const win32 = windows;
pub const PATH_MAX_WIDE = windows.PATH_MAX_WIDE;
pub const MAX_PATH = windows.MAX_PATH;
pub const WORD = windows.WORD;
pub const DWORD = windows.DWORD;
pub const CHAR = windows.CHAR;
pub const BOOL = windows.BOOL;
pub const LPVOID =... | Zig | windows.zig |
const std = @import("std");
const bun = @import("root").bun;
const builtin = @import("builtin");
const win32 = std.os.windows;
const os = std.os;
const mem = std.mem;
const Stat = std.fs.File.Stat;
const Kind = std.fs.File.Kind;
const StatError = std.fs.File.StatError;
pub fn getTotalMemory() usize {
return uv.uv_... | Zig | windows_c.zig |
const bun = @import("root").bun;
const Output = bun.Output;
const JSC = bun.JSC;
const uws = bun.uws;
const Environment = bun.Environment;
const std = @import("std");
const uv = bun.windows.libuv;
pub const Loop = uv.Loop;
pub const KeepAlive = struct {
status: Status = .inactive,
const log = Output.scoped(.K... | Zig | windows_event_loop.zig |
const ThreadPool = @import("root").bun.ThreadPool;
const std = @import("std");
pub const Batch = ThreadPool.Batch;
pub const Task = ThreadPool.Task;
pub fn NewWorkPool(comptime max_threads: ?usize) type {
return struct {
var pool: ThreadPool = undefined;
var loaded: bool = false;
fn creat... | Zig | work_pool.zig |
//
// this file is a copy of Wyhash from the zig standard library, version v0.11.0-dev.2609+5e19250a1
//
const std = @import("std");
const mem = std.mem;
const primes = [_]u64{
0xa0761d6478bd642f,
0xe7037ed1a0b428db,
0x8ebc6af09c88c6e3,
0x589965cc75374cc3,
0x1d8e4e27c47d124f,
};
fn read_bytes(com... | Zig | wyhash.zig |
const BoringSSL = bun.BoringSSL;
const bun = @import("root").bun;
const ZigString = JSC.ZigString;
const std = @import("std");
const JSC = @import("root").bun.JSC;
const JSValue = JSC.JSValue;
const JSGlobalObject = JSC.JSGlobalObject;
fn x509GetNameObject(globalObject: *JSGlobalObject, name: ?*BoringSSL.X509_NAME) JS... | Zig | x509.zig |
const uInt = c_uint;
const uLong = c_ulong;
pub const struct_internal_state = extern struct {
dummy: c_int,
};
// https://zlib.net/manual.html#Stream
const Byte = u8;
const Bytef = Byte;
const charf = u8;
const intf = c_int;
const uIntf = uInt;
const uLongf = uLong;
const voidpc = ?*const anyopaque;
const voidpf =... | Zig | zlib.posix.zig |
// #define Z_BINARY 0
// #define Z_TEXT 1
// #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
// #define Z_UNKNOWN 2
pub const DataType = enum(c_int) {
Binary = 0,
Text = 1,
Unknown = 2,
};
// #define Z_OK 0
// #define Z_STREAM_END 1
// #define Z_NEED_DICT ... | Zig | zlib.shared.zig |
// zig translate-c -I${VCPKG_ROOT}/installed/x64-windows/include/ ${VCPKG_ROOT}/current/installed/x64-windows/include/zlib.h -target x86_64-windows-msvc -lc > src/deps/zlib.win32.zig
pub const rsize_t = usize;
pub const _ino_t = c_ushort;
pub const ino_t = _ino_t;
pub const _dev_t = c_uint;
pub const dev_t = _dev_t;
... | Zig | zlib.win32.zig |
// @link "deps/zlib/libz.a"
const std = @import("std");
const bun = @import("root").bun;
const mimalloc = @import("./allocators/mimalloc.zig");
pub const MAX_WBITS = 15;
test "Zlib Read" {
const expected_text = @embedFile("./zlib.test.txt");
const input = bun.asByteSlice(@embedFile("./zlib.test.gz"));
s... | Zig | zlib.zig |
pub extern fn ZSTD_versionNumber() c_uint;
pub extern fn ZSTD_versionString() [*c]const u8;
pub extern fn ZSTD_compress(dst: ?*anyopaque, dstCapacity: usize, src: ?*const anyopaque, srcSize: usize, compressionLevel: c_int) usize;
pub extern fn ZSTD_decompress(dst: ?*anyopaque, dstCapacity: usize, src: ?*const anyopaque... | Zig | zstd.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.