code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const c = @import("c.zig");
const getElapsedTime = @import("glfw.zig").getElapsedTime;
const utils = @import("utils.zig");
const time = @import("std").time;
const print = @import("std").debug.print;
pub const FrameTime = struct {
update: f64 = 0,
draw: f64 = 0,
delta: f64 = 0,
last: f64 = 0,
curr... | src/kiragine/kira/window.zig |
const std = @import("std");
usingnamespace (@import("../machine.zig"));
usingnamespace (@import("../util.zig"));
test "MMX" {
const m32 = Machine.init(.x86_32);
const m64 = Machine.init(.x64);
const reg = Operand.register;
const regRm = Operand.registerRm;
const imm = Operand.immediate;
debug... | src/x86/tests/mmx.zig |
const builtin = @import("builtin");
const build_options = @import("build_options");
const std = @import("std");
const big = std.math.big;
const heap = std.heap;
const io = std.io;
const log = std.log;
const mem = std.mem;
const net = std.net;
const Connection = @import("connection.zig").Connection;
const PrimitiveWri... | src/client.zig |
const std = @import("std");
const webgpu = @import("./webgpu.zig");
pub const Buffer = struct {
pub const VTable = struct {
destroy_fn: fn(*Buffer) void,
get_const_mapped_range_fn: fn(*Buffer, usize, usize) GetConstMappedRangeError![]align(16) const u8,
get_mapped_range_fn: fn(*Buffer, usiz... | src/resource.zig |
const std = @import("std");
const sqlite = @import("sqlite");
const manage_main = @import("main.zig");
const libpcre = @import("libpcre");
const Context = manage_main.Context;
const log = std.log.scoped(.atags);
const VERSION = "0.0.1";
const HELPTEXT =
\\ atags: manage your tags
\\
\\ usage:
\\ atag... | src/tags_main.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const math = std.math;
const assert = std.debug.assert;
const Air = @import("Air.zig");
const Zir = @import("Zir.zig");
const Liveness = @import("Liveness.zig");
const Type = @import("type.zig").Type;
const Value = @import("value.zig")... | src/codegen.zig |
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const Status = uefi.Status;
/// Random Number Generator protocol
pub const RNGProtocol = extern struct {
_get_info: extern fn (*const RNGProtocol, *usize, [*]align(8) Guid) Status,
_get_rng: extern fn (*const RNGProtocol, ?*align(8) const Guid, usize... | lib/std/os/uefi/protocols/rng_protocol.zig |
const sdl = @import("sdl2");
const std = @import("std");
const log = std.log.scoped(.Texture);
pub const TextureError = error{
CreationFailure,
};
const Texture = @This();
handle: sdl.Texture,
pixels: []const u8,
stride: u8,
colors: ?[]sdl.Color,
width: usize,
height: usize,
pub fn load_file(filename: [:0]cons... | src/Texture.zig |
const std = @import("std");
const mem = std.mem;
const fmt = std.fmt;
const print = std.debug.print;
const alloc = std.heap.page_allocator;
const ArrayList = std.ArrayList;
const eql = std.ascii.eqlIgnoreCase;
const ascii = std.ascii;
pub fn main() !void {
const file = @embedFile("../inputs/day_04");
var passp... | src/04.zig |
//--------------------------------------------------------------------------------
// Section: Types (2)
//--------------------------------------------------------------------------------
pub const CreateProcessMethod = enum(i32) {
CreateProcess = 0,
CreateProcessAsUser = 1,
AicLaunchAdminProcess = 2,
};
p... | win32/system/win_rt/shell.zig |
const builtin = @import("builtin");
const std = @import("std");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test "super basic invocations" {
const foo = struct {
fn foo() i32 {
return 1234;
}
}.foo;
try expect(@call(.{}, foo, .{}) == 1234);
... | test/behavior/call.zig |
const Allocator = @import("std").mem.Allocator;
const ArrayList = @import("std").ArrayList;
const Header = @import("header.zig").Header;
const HeaderName = @import("name.zig").HeaderName;
const HeaderType = @import("name.zig").HeaderType;
const HeaderValue = @import("value.zig").HeaderValue;
const std = @import("std");... | src/headers/headers.zig |
const std = @import("std");
const CFO = @import("./CFO.zig");
const debug = std.debug;
const os = std.os;
const io = std.io;
var the_cfo: ?*CFO = null;
fn sigHandler(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const anyopaque) callconv(.C) void {
const s = io.getStdErr().writer();
const addr = @ptrToInt(... | src/OSHA.zig |
const mecha = @import("mecha");
const std = @import("std");
const event = std.event;
const fs = std.fs;
const heap = std.heap;
const log = std.log;
const Message = @import("../message.zig").Message;
pub fn cpu(channel: *event.Channel(Message)) void {
const loop = event.Loop.instance.?;
const cwd = fs.cwd();
... | src/producer/cpu.zig |
const std = @import("std");
const builtin = @import("builtin");
const config = @import("./config.zig");
const os = std.os;
const assert = std.debug.assert;
const is_darwin = builtin.target.os.tag.isDarwin();
const is_windows = builtin.target.os.tag == .windows;
pub const Time = struct {
const Self = @This();
... | src/time.zig |
const std = @import("std");
const TestContext = @import("../../src/test.zig").TestContext;
// These tests should work with all platforms, but we're using linux_x64 for
// now for consistency. Will be expanded eventually.
const linux_x64 = std.zig.CrossTarget{
.cpu_arch = .x86_64,
.os_tag = .linux,
};
pub fn a... | test/stage2/cbe.zig |
const std = @import("std");
const zlm = @import("zlm");
const graphics = @import("didot-graphics");
const Mesh = graphics.Mesh;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const OBJError = error {
};
const Element = struct {
posIdx: usize,
texIdx: usize,
normalIdx: usize
};
pub ... | didot-models/obj.zig |
const std = @import("std");
usingnamespace @import("parse_helpers.zig");
usingnamespace @import("../winmd.zig");
const mem = @This();
const meta = std.meta;
const trait = meta.trait;
/// DatabaseFile is the core of how TypeReader traverses the winmd file
/// It will iterate over the bytes and store meta info about ta... | src/winmd/database_file.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const panic = std.debug.panic;
const vk = @import("vk.zig");
usingnamespace @import("device.zig");
pub const Image = struct {
const Self = @This();
device: Device,
handle: vk.Image,
memory: vk.DeviceMemory,
image_view: vk.ImageView,... | src/vulkan/image.zig |
const sf = @import("../sfml.zig");
const std = @import("std");
const assert = std.debug.assert;
const TextureType = enum {
ptr, const_ptr
};
pub const Texture = union(TextureType) {
const Self = @This();
// Constructor/destructor
/// Creates a texture from nothing
pub fn init(size: sf.Vector2u)... | src/sfml/graphics/texture.zig |
const std = @import("std");
const testing = std.testing;
pub fn isWhitespace(c: u8) bool {
return c == ' ' or c == '\t' or c == '\n' or c == '\r' or c == '\x0b' or c == '\x0c';
}
pub fn isNewline(c: u8) bool {
return c == '\n' or c == '\r';
}
pub fn isWhitespaceNonNewline(c: u8) bool {
return c == ' ' or... | src/String.zig |
fn bgfx_attachment_init(bgfx_attachment_t* _this, bgfx_texture_handle_t _handle, bgfx_access_t _access, uint16_t _layer, uint16_t _mip, uint8_t _resolve); = enum {};
/// Decode attribute.
/// @param[in] _attrib Attribute semantics. See: `bgfx::Attrib`
/// @param[out] _num Number of elements.
/// @param[out] _type Elem... | lib/bgfx.zig |
const std = @import("std");
const mem = std.mem;
const net = std.net;
const PrimitiveReader = @import("primitive/reader.zig").PrimitiveReader;
const PrimitiveWriter = @import("primitive/writer.zig").PrimitiveWriter;
const testing = @import("testing.zig");
pub const TopologyChangeType = enum {
NEW_NODE,
REMOV... | src/event.zig |
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const zp = @import("../../zplay.zig");
const drawcall = zp.graphics.common.drawcall;
const VertexArray = zp.graphics.common.VertexArray;
const alg = zp.deps.alg;
const Vec2 = alg.Vec2;
const Vec3 = alg.Vec3;
const Vec4 = alg.Vec4;
const... | src/graphics/3d/Mesh.zig |
const buffer = @import("buffer.zig");
const std = @import("std");
pub const TestSchema = struct {
pub const PackageProvider = enum(u8) {
_none,
/// npm
npm,
/// git
git,
/// https
https,
/// tgz
tgz,
/// other
other,
_,
pub fn jsonStringify(self: *const @This(), opts: any... | js/lockfile.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const nvg = @import("nanovg");
const s2s = @import("s2s");
const gui = @import("gui");
const geometry = gui.geometry;
const Point = geometry.Point;
const Pointi = Point(i32);
const Pointu = Point(u32);
const Rect = geomet... | src/Document.zig |
const std = @import("std");
const alka = @import("alka");
const m = alka.math;
usingnamespace alka.log;
pub const mlog = std.log.scoped(.app);
pub const log_level: std.log.Level = .info;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const Transform = struct {
r: m.Rectangle = m.Rectangle{},
colour: alk... | examples/shooter.zig |
const cc_gfx = @import("cc_gfx");
const cc_mem = @import("cc_mem");
const cc_ui = @import("cc_ui");
const cc_ui_gfx = @import("cc_ui_gfx");
const cc_ui_res = @import("cc_ui_res");
const cc_wnd = @import("cc_wnd");
const cc_wnd_gfx = @import("cc_wnd_gfx");
const Example = struct {
ba: cc_mem.BumpAllocator,
wind... | ex/ui/ui.zig |
const std = @import("std");
const json = std.json;
const clibs = @import("clibs.zig");
const curl = clibs.curl;
var tractor_tsid: ?[36:0]u8 = null;
pub const Messages = struct {
active: u32 = 0,
blocked: u32 = 0,
done: u32 = 0,
err: u32 = 0,
};
pub fn postTractor(allocator: *std.mem.Allocator, post:... | src/tractor.zig |
const std = @import("std");
const base32 = @import("base32");
const t = std.testing;
const stdout = std.io.getStdOut().writer();
pub const ULID = struct {
const Self = @This();
data: [16]u8 = [_]u8{0} ** 16,
pub fn random(rand: std.rand.Random) ULID {
// Get a calendar timestamp, in milliseconds,... | src/ulid.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day01.txt");
p... | src/day01.zig |
const std = @import("std");
const zlm = @import("zlm");
const gl = @import("gl.zig");
pub const VertexList = struct {
vao: gl.VertexArray,
vbo: gl.Buffer,
data: std.ArrayListUnmanaged(Vertex),
pub fn init() VertexList {
const vao = gl.VertexArray.init();
const vbo = gl.Buffer.init();... | src/render/vertex.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const mem = std.mem;
const math = std.math;
const builtin = @import("builtin");
const AtomicOrder = builtin.AtomicOrder;
const AtomicRmwOp = builtin.AtomicRmwOp;
const linux = switch(builtin.os) {
builtin.Os.linux => std.os.... | mutex.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "GLX", .global_id = 0 };
pub const PIXMAP = u32;
pub const CONTEXT = u32;
pub const PBUFFER = u32;
pub const WINDOW = u32;
pub const FBCONFIG = u32;
pub const DRAWABLE = u32;
pub const FLOAT32 = f32;
pub const FLOAT64 = f64;
pub const B... | src/auto/glx.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "RANDR", .global_id = 0 };
pub const MODE = u32;
pub const CRTC = u32;
pub const OUTPUT = u32;
pub const PROVIDER = u32;
/// Opcode for BadOutput.
pub const BadOutputOpcode = 0;
/// @brief BadOutputError
pub const BadOutputError = struct {... | src/auto/randr.zig |
const std = @import("std");
const cgltf = @import("cgltf");
const vk = @import("vk");
const engine = @import("engine.zig");
const render = engine.render;
const Child = std.meta.Child;
pub const Buffer = struct {
raw: *cgltf.Buffer,
usageFlags: vk.BufferUsageFlags = vk.BufferUsageFlags{},
updateRate: engin... | src/gltf_wrap.zig |
const std = @import("std");
const audiometa = @import("audiometa");
const assert = std.debug.assert;
pub fn main() anyerror!void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer assert(gpa.deinit() == false);
const allocator = gpa.allocator();
var args = try std.process.argsAlloc(allocator);... | tools/extract_tag.zig |
const std = @import("std");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const alloc = gpa.allocator();
pub const World = struct {
entity_count: usize,
pools: std.AutoHashMap(usize, *c_void),
pub fn init() World {
return World{
.entity_count = 0,
.pools = std.AutoHas... | src/ecs.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const int = i64;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../dat... | src/day10.zig |
const std = @import("std");
const os = std.os;
const index = @import("index.zig");
const ptrace = index.ptrace;
const c = index.c;
const events = @import("events.zig");
const waitpid = @import("waitpid.zig").waitpid;
pub const Context = events.Context;
pub const Options = struct {
multithread: bool = true,
... | src/syspect.zig |
const std = @import("std");
const kernel = @import("root");
const mm = kernel.mm;
const x86 = @import("../x86.zig");
const apic = x86.apic;
const elf = std.elf;
const MMIORegion = kernel.mmio.DynamicMMIORegion;
const lib = kernel.lib;
var logger = @TypeOf(x86.logger).childOf(@typeName(@This())){};
const TRAMPOLINE_BA... | kernel/arch/x86/smp.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const math = std.math;
const assert = std.debug.assert;
const log = @import("./log.zig").log;
const render = @import("./render.zig");
const Pixel = render.Pixel;
const Canvas = render.Canvas;
const math_utils = @import("./math_utils.zig");
const Point = m... | night-math/src/star_math.zig |
const std = @import("std");
const root = @import("./dns.zig");
const Name = root.Name;
const ResourceType = root.ResourceType;
const ResourceClass = root.ResourceClass;
pub const ResponseCode = enum(u4) {
NoError = 0,
FormatError = 1,
ServFail = 2,
NameError = 3,
NotImplemented = 4,
Refused = ... | src/pkg2/packet.zig |
const Module = @This();
const std = @import("std");
const Compilation = @import("Compilation.zig");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const ArrayListUnmanaged = std.ArrayListUnmanaged;
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const TypedValue = @import("Ty... | src/Module.zig |
const std = @import("std");
const clap = @import("clap");
const version = @import("version");
const zzz = @import("zzz");
const api = @import("api.zig");
const Project = @import("Project.zig");
const Lockfile = @import("Lockfile.zig");
const Dependency = @import("Dependency.zig");
const DependencyTree = @import("Depend... | src/commands.zig |
const std = @import("std");
const mem = std.mem;
const log = std.log.scoped(.c);
const Writer = std.ArrayList(u8).Writer;
const link = @import("../link.zig");
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const Inst = @import("../ir.zig").Inst;
const Value = @import("../va... | src/codegen/c.zig |
const std = @import("std");
pub const Lock = if (std.builtin.os.tag == .windows)
WindowsLock
else if (std.Target.current.isDarwin())
DarwinLock
else if (std.builtin.link_libc)
PosixLock
else if (std.builtin.os.tag == .linux)
LinuxLock
else
@compileError("Platform not supported");
const WindowsLock... | src/runtime/Lock.zig |
const Allocator = std.mem.Allocator;
const crc = std.hash.crc;
const FormatInterface = @import("../format_interface.zig").FormatInterface;
const ImageFormat = image.ImageFormat;
const ImageReader = image.ImageReader;
const ImageInfo = image.ImageInfo;
const ImageSeekStream = image.ImageSeekStream;
const PixelFormat = @... | src/formats/png.zig |
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const bu = @import("bits_utils.zig");
const ddec = @import("dict_decoder.zig");
const deflate_const = @import("deflate_const.zig");
const mu = ... | lib/std/compress/deflate/decompressor.zig |
const std = @import("../std.zig");
/// A protocol is an interface identified by a GUID.
pub const protocols = @import("uefi/protocols.zig");
/// Status codes returned by EFI interfaces
pub const Status = @import("uefi/status.zig").Status;
pub const tables = @import("uefi/tables.zig");
/// The memory type to allocate... | lib/std/os/uefi.zig |
const std = @import("std");
const QueueCacheConfig = struct {
T: type,
Owner: type,
next_name: []const u8 = "next_in_cache",
prev_name: []const u8 = "prev_in_cache",
};
/// Cache of nodes.disposeFn is used to drop nodes from cache. disposeFn does not have to held
/// exclusive ownership of the cache w... | cache.zig |
const std = @import("std");
const array = @import("array.zig");
const Array = array.Array;
const tensor = @import("tensor.zig");
const Tensor = tensor.Tensor;
const funcs = @import("funcs.zig");
const optim = @import("optim.zig");
pub const Parameter = struct {
path: []const u8,
value: Tensor,
};
... | src/module.zig |
const std = @import("std");
const zig = std.zig;
const Ast = zig.Ast;
const Node = Ast.Node;
const Token = Ast.TokenIndex;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const assert = std.debug.assert;
pub const ZigSource = struct {
arena: std.heap.ArenaAllocator,
decls: []const Dec... | src/main.zig |
const std = @import("std");
const riscv = @import("../riscv.zig");
const Csr = riscv.Csr;
// Machine Information Registers
pub const mvendorid = Csr(0xF11, packed struct { offset: u7, bank: u25, _reserved_32: riscv.unsignedIntegerWithSize(riscv.xlen - 32) });
pub const marchid = Csr(0xF12, riscv.unsignedIntegerWithS... | src/target/arch/riscv/mcsr.zig |
const std = @import("std");
/// Super simple "perfect hash" algorithm
/// Only really useful for switching on strings
// TODO: can we auto detect and promote the underlying type?
pub fn Swhash(comptime max_bytes: comptime_int) type {
const T = std.meta.Int(.unsigned, max_bytes * 8);
return struct {
pub... | src/util.zig |
const std = @import("std");
const Compilation = @import("Compilation.zig");
const Preprocessor = @import("Preprocessor.zig");
const Parser = @import("Parser.zig");
const TokenIndex = @import("Tree.zig").TokenIndex;
const Pragma = @This();
pub const Error = Compilation.Error || error{ UnknownPragma, StopPreprocessing ... | src/Pragma.zig |
// kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
// Input x is assumed to be bounded by ~pi/4 in magnitude.
// Input y is the tail of x.
//
// Algorithm
// 1. Since cos(-x) = cos(x), we need only to consider positive x.
// 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0.
// 3... | lib/std/math/__trig.zig |
const std = @import("std");
const Client = @import("requestz").Client;
const Allocator = std.mem.Allocator;
const Headers = @import("http").Headers;
var cloudflareApi ="https://api.cloudflare.com/client/v4/";
pub const Cloudflare = struct {
allocator: *Allocator,
email: []const u8,
apikey: []const u... | src/cloudflare.zig |
const std = @import("std");
// First command-line argument: memory dump (defaults to `challenge.bin`)
// Second command-line argument: command
// - If `history`, writes a history file
// - If `explain`, writes commands to stderr
//
// Memory dump is written when stdin ends (C-d or redirect stdin from history
// fi... | synacor.zig |
const std = @import("std");
const builtin = @import("builtin");
const Pkg = std.build.Pkg;
const string = []const u8;
pub const cache = ".zigmod/deps";
pub fn addAllTo(
exe: *std.build.LibExeObjStep,
b: *std.build.Builder,
target: std.zig.CrossTarget,
mode: std.builtin.Mode,
) *std.build.LibExeObjStep... | deps.zig |
const std = @import("std");
// dross-zig
const Vector2 = @import("../core/vector2.zig").Vector2;
const TextureRegion = @import("../renderer/texture_region.zig").TextureRegion;
const Texture = @import("../renderer/texture.zig").Texture;
const Frame2d = @import("frame_2d.zig").Frame2d;
const Math = @import("../math... | src/animation/animation_2d.zig |
const std = @import("std");
pub fn RaxStack(comptime NodeT: type, comptime StaticSize: usize) type {
return struct {
maxItems: usize,
staticItems: [StaticSize]*NodeT,
stack: []*NodeT,
const Self = @This();
pub fn init(self: *Self) void {
self.* = Self{
... | src/simple/stack.zig |
const std = @import("std");
const builtin = @import("builtin");
const os = std.os;
const io = std.io;
const mem = std.mem;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const Buffer = std.Buffer;
const ast = std.zig.ast;
const arg = @import("fmt/arg.zig");
const self_hosted_main = @import("fmt/mai... | std/special/fmt_runner.zig |
const std = @import("std");
const blo = @import("blo.zig");
pub const Token = struct {
color: blo.Color,
start: usize,
end: usize,
};
pub const Language = enum {
json,
};
pub const Theme = struct {
string: blo.Color,
keyword: blo.Color,
number: blo.Color,
operator: blo.Color,
brac... | src/syntax.zig |
const std = @import("std");
usingnamespace (@import("../machine.zig"));
usingnamespace (@import("../util.zig"));
const imm = Operand.immediate;
const mem = Operand.memory;
const memRm = Operand.memoryRm;
const reg = Operand.register;
test "string and XLAT instructions" {
const m16 = Machine.init(.x86_16);
con... | src/x86/tests/special_mem.zig |
const std = @import("std");
const build_options = @import("build_options");
const dcommon = @import("../common/dcommon.zig");
pub var base: ?u64 = null;
pub var width: ?u3 = null;
pub fn init(entry_data: *dcommon.EntryData) void {
base = entry_data.uart_base;
width = entry_data.uart_width;
carefully(.{ "... | dainkrnl/src/hw/entry_uart.zig |
pub const SI_TEMPORARY = @as(u32, 2147483648);
pub const SUBSINFO_ALLFLAGS = @as(u32, 61311);
pub const RS_READY = @as(u32, 1);
pub const RS_SUSPENDED = @as(u32, 2);
pub const RS_UPDATING = @as(u32, 4);
pub const RS_SUSPENDONIDLE = @as(u32, 65536);
pub const RS_MAYBOTHERUSER = @as(u32, 131072);
pub const RS_COMPLETED =... | deps/zigwin32/win32/system/search.zig |
const std = @import("std");
// ----------------------------------------------------------------------------
const arm_cmse = @import("arm_cmse");
const arm_m = @import("arm_m");
const EXC_RETURN = arm_m.EXC_RETURN;
const getMspNs = arm_m.getMspNs;
const getPspNs = arm_m.getPspNs;
const getPsp = arm_m.getPsp;
const get... | examples/secure/main.zig |
const kernel = @import("../../kernel.zig");
const virtio = @import("virtio.zig");
const SplitQueue = virtio.SplitQueue;
const MMIO = virtio.MMIO;
const Descriptor = virtio.Descriptor;
const sector_size = kernel.arch.sector_size;
const Disk = kernel.Disk;
const GenericDriver = kernel.driver;
const Driver = @This();
di... | src/kernel/arch/riscv64/virtio_block.zig |
const std = @import("std");
const testing = std.testing;
const StringTable = @import("./strtab.zig").StringTable;
const allocator = std.heap.page_allocator;
pub const DB = struct {
pub const Ticket = struct {
values: std.ArrayList(usize),
valid: bool,
pub fn init() *Ticket {
v... | 2020/p16/ticket.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
fn pgcd(_a: u64, _b: u64) u64 {
var a = _a;
var b = _b;
while (b != 0) {
var t = b;
b = a % b;
a = t;
}
return a;
}
const Registers = [6]u48;
const Opcode = enum { addi, addr, muli,... | 2018/day21_nocomptime.zig |
const std = @import("std");
const os = @import("root").os;
/// HandleTable is the class for table of generic handles
/// It manages a map from integers to handles (type T)
/// TODO: Add more methods like dup2 and reserve
pub fn HandleTable(comptime T: type) type {
return struct {
/// Result type for a new ... | src/lib/handle_table.zig |
const std = @import("std");
const util = @import("util");
usingnamespace @import("context.zig");
usingnamespace @import("unit.zig");
const Allocator = std.mem.Allocator;
const ZigSrcLoc = std.builtin.SourceLocation;
pub const Source = struct {
allocator: *Allocator,
path: []const u8,
text: []const u8,
... | src/compile/source.zig |
const std = @import("std");
pub const ErrorSet = error{InvalidGeoJson} || std.mem.Allocator.Error || std.json.TokenStream.Error || std.fmt.ParseIntError;
const log = std.log.scoped(.zig_geojson);
pub const GeoJson = struct {
arena: std.heap.ArenaAllocator,
bbox: ?BBox,
content: union(enum) {
featu... | src/main.zig |
const std = @import("std");
const warn = std.debug.warn;
const Allocator = std.mem.Allocator;
const testing = std.testing;
const util = @import("util.zig");
pub const Type = Toot();
pub fn Toot() type {
return struct {
hashmap: Toothashmap,
tagList: TagList,
imgList: ImgList,
con... | src/toot.zig |
const expectEqual = @import("std").testing.expectEqual;
const Vector = @import("std").meta.Vector;
const math = @import("math.zig").math;
pub fn Matrix(comptime T: type, rows: comptime_int, columns: comptime_int) type {
switch (@typeInfo(T)) {
.Int, .Float => {},
else => @compileError("Matrix only... | src/mat.zig |
const std = @import("std");
const os = std.os;
const mem = std.mem;
const assert = std.debug.assert;
const log = std.log.scoped(.io);
const config = @import("../config.zig");
const FIFO = @import("../fifo.zig").FIFO;
const Time = @import("../time.zig").Time;
const buffer_limit = @import("../io.zig").buffer_limit;
pub... | src/io/darwin.zig |
const std = @import("../index.zig");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Endian = @import("builtin").Endian;
pub fn SipHash64(comptime c_rounds: usize, comptime d_rounds: usize) type {
return SipHash(u64, c_rounds, d_rounds);
}
pub fn SipHash128(comptime c_rounds: usize, c... | std/hash/siphash.zig |
const std = @import("../../std.zig");
const net = @import("net.zig");
const os = std.os;
const fmt = std.fmt;
const mem = std.mem;
const time = std.time;
/// A generic socket abstraction.
const Socket = @This();
/// A socket-address pair.
pub const Connection = struct {
socket: Socket,
address: Socket.Addre... | lib/std/x/os/Socket.zig |
const std = @import("std.zig");
const tokenizer = @import("zig/tokenizer.zig");
pub const Token = tokenizer.Token;
pub const Tokenizer = tokenizer.Tokenizer;
pub const parse = @import("zig/parse.zig").parse;
pub const parseStringLiteral = @import("zig/string_literal.zig").parse;
pub const render = @import("zig/render.... | lib/std/zig.zig |
const builtin = @import("builtin");
const std = @import("std");
const os = std.os;
const tests = @import("tests.zig");
pub fn addCases(cases: *tests.CompareOutputContext) void {
cases.addC("hello world with libc",
\\const c = @cImport({
\\ // See https://github.com/ziglang/zig/issues/515
... | test/compare_output.zig |
const builtin = @import("builtin");
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
var options = Options{
.build_mode = b.standardReleaseOptions(),
.target = b.standardTargetOptions(.{}),
};
options.enable_tracy = b.option(bool, "enable-tracy", "Enable Tracy profile... | build.zig |
const std = @import("std");
const nvg = @import("nanovg");
const gui = @import("gui.zig");
usingnamespace @import("event.zig");
const Point = @import("geometry.zig").Point;
const Application = @This();
pub const SystemCallbacks = struct {
// essential
createWindow: fn ([:0]const u8, u32, u32, gui.Window.Creat... | src/gui/Application.zig |
const std = @import("std");
const testing = std.testing;
const expect = testing.expect;
const expectEqual = testing.expectEqual;
const expectApproxEqRel = testing.expectApproxEqRel;
pub const Vector4 = packed struct {
x: f32,
y: f32,
z: f32,
w: f32,
pub fn init(x: f32, y: f32, z: f32, w: f32) Vect... | src/vector4.zig |
const std = @import("std");
const mem = std.mem;
const math = std.math;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const Stream = std.net.Stream;
const assert = std.debug.assert;
pub const Bytes = std.ArrayList(u8);
pub const native_endian = std.builtin.target.cpu.arch.endian();
pub inline fn ... | packages/zhp/src/util.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/14.txt", .{});
defer input_file.close();
var buffe... | src/14_2.zig |
pub const BracketPairing = struct {
codepoint: u21,
pair: u21,
type: Type,
pub const Type = enum {
o,
c,
n,
};
};
pub const data = [_]BracketPairing{
.{ .codepoint = 0x0028, .pair = 0x0029, .type = .o }, // LEFT PARENTHESIS
.{ .codepoint = 0x0029, .pair = 0x0028, .... | src/bidi_brackets.zig |
const std = @import("std");
const termelot = @import("termelot");
const Position = termelot.Position;
const Cell = termelot.Cell;
usingnamespace termelot.style;
pub fn log(
comptime level: std.log.Level,
comptime scope: @TypeOf(.EnumLiteral),
comptime format: []const u8,
args: anytype,
) void {
t... | examples/donut.zig |
const std = @import("std");
const log = std.log;
const mem = std.mem;
const os = std.os;
const c = std.c;
const integer_t = c_int;
const task_flavor_t = c.natural_t;
const task_info_t = *integer_t;
const task_name_t = c.mach_port_name_t;
const vm_address_t = c.vm_offset_t;
const vm_size_t = c.mach_vm_size_t;
const vm_... | src/main.zig |
const std = @import("std");
const getty = @import("getty");
const assert = std.debug.assert;
const expectEqual = std.testing.expectEqual;
const expectEqualSlices = std.testing.expectEqualSlices;
const Token = @import("common/token.zig").Token;
pub const Deserializer = struct {
allocator: std.mem.Allocator,
t... | src/tests/de/deserializer.zig |
const Allocator = std.mem.Allocator;
const h11 = @import("h11");
const Method = @import("http").Method;
const TcpSocket = @import("socket.zig").TcpSocket;
const Request = @import("request.zig").Request;
const Response = @import("response.zig").Response;
const std = @import("std");
const StreamingResponse = @import("res... | src/connection.zig |
const std = @import("std");
const c = @import("c.zig");
const shaderc = @import("shaderc.zig");
const png = @import("png.zig");
const AsyncShaderc = @import("async_shaderc.zig").AsyncShaderc;
const Blit = @import("blit.zig").Blit;
const Preview = @import("preview.zig").Preview;
const Scene = @import("scene.zig").Scen... | src/renderer.zig |
const std = @import("std");
const stdx = @import("stdx");
const Backend = @import("build_options").GraphicsBackend;
const graphics = @import("graphics.zig");
const FontGroupId = graphics.FontGroupId;
const gpu = @import("backend/gpu/graphics.zig");
const testg = @import("backend/test/graphics.zig");
pub const TextMet... | graphics/src/text.zig |
const std = @import("../std.zig");
const assert = std.debug.assert;
const builtin = @import("builtin");
const macho = std.macho;
usingnamespace @import("../os/bits.zig");
extern "c" fn __error() *c_int;
pub extern "c" fn _NSGetExecutablePath(buf: [*]u8, bufsize: *u32) c_int;
pub extern "c" fn _dyld_get_image_header(i... | lib/std/c/darwin.zig |
const std = @import("std");
const realmode = @import("realmode.zig");
const RegisterState = realmode.RegisterState;
// Global allocator
const Allocator = std.mem.Allocator;
const FixedBufferAllocator = std.heap.FixedBufferAllocator;
var high_memory_allocator: FixedBufferAllocator = undefined;
pub var GlobalAllocator... | src/mm.zig |
const std = @import("std");
const input = @embedFile("data/input14");
usingnamespace @import("util.zig");
pub fn main() !void {
var allocator_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer allocator_state.deinit();
const allocator = &allocator_state.allocator;
const part1 = getSu... | src/day14.zig |
const c = @import("c.zig");
const nk = @import("../nuklear.zig");
const std = @import("std");
const builtin = std.builtin;
const debug = std.debug;
const heap = std.heap;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const testing = std.testing;
/// Same as `beginTitled` but instead of taking a `... | src/group.zig |
const std = @import("std");
pub const io_mode = .evented;
pub fn main() !void {
var cpu: u64 = try std.Thread.getCpuCount();
std.debug.print("CPUS online... {d} \n", .{cpu});
// Allocate room for an async frame for every
// logical cpu core
var promises =
try std.heap.page_allocator.allo... | src/main.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
const with_dissassemble = false;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Computer = tools.IntCode_Computer;
pub fn run(input... | 2019/day23.zig |
const std = @import("std");
const fs = std.fs;
const hm = std.hash_map;
const Bitmask = struct {
and_mask: u64 = 0xFFFFFFFFFFFFFFFF,
or_mask: u64 = 0,
const Self = @This();
pub fn fromString(str: []const u8) Self {
const bits = str.len - 1;
var am: u64 = 0;
var om: u64 = 0;
... | 2020/src/day_14.zig |