lithdew

const std = @import("std");
const c = @cImport(@cInclude("uv.h"));

const assert = std.debug.assert;

var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);

pub fn onClose(handle: ?*c.uv_handle_t) callconv(.C) void {
    const allocator = &arena.allocator; // get allocator here
    allocator.destroy(handle.?);

lithdew

const Builder = @import("std").build.Builder;

pub fn build(b: *Builder) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});

    // Standard release options allow the person running `zig build` to select

lithdew

const Builder = @import("std").build.Builder;

pub fn build(b: *Builder) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});

    // Standard release options allow the person running `zig build` to select

lithdew

const std = @import("std");

pub const KV = struct {
    key: []const u8,
    val: []const u8,

    pub fn init(key: []const u8, val: []const u8) KV {
        return KV{ .key = key, .val = val };
    }
};

lithdew

const std = @import("std");

pub fn concat(bufs: []const []const u8) ![]const u8 {
    // var buf: [11]u8 = undefined;
    // var buffer = std.heap.FixedBufferAllocator.init(&buf);
    return std.mem.concat(std.heap.c_allocator, u8, bufs);
    // return std.mem.concat(&buffer.allocator, u8, bufs);
}

pub fn main() !void {

lithdew

const std = @import("std");

const Node = struct {
    left: ?*Node = null,
    right: ?*Node = null,

    pub fn new(allocator: *std.mem.Allocator) !Node {
        return Node{
            .left = try allocator.create(Node),
            .right = try allocator.create(Node),

lithdew

const std = @import("std");
const os = std.os;

const File = std.fs.File;

pub fn shutdown(fd: os.fd_t, how: i32) !void {
    const rc = os.system.shutdown(fd, how);
    switch (os.errno(rc)) {
        0 => return,
        os.EBADF => unreachable,

lithdew

pub const B = struct {
    const Self = @This();

    data: []const u8,

    pub fn getParent(self: *Self) *A {
        return @fieldParentPtr(A, "child", self);
    }
};

lithdew

const std = @import("std");
const os = std.os;
const net = std.net;

const windows = os.windows;
const ws2_32 = windows.ws2_32;

const pike = @import("pike.zig");

fn socket(address: net.Address, socket_type: u32) !os.fd_t {

lithdew

const std = @import("std");
const os = std.os;
const windows = os.windows;

pub const HANDLER_ROUTINE = fn(dwCtrlType: windows.DWORD) callconv(.Stdcall) windows.BOOL;

const funcs = struct {
    extern "kernel32" fn SetConsoleCtrlHandler(HandlerRoutine: ?HANDLER_ROUTINE, Add: windows.BOOL) callconv(.Stdcall) windows.BOOL;
};