code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const sf = @import("../sfml.zig");
pub const Sprite = struct {
const Self = @This();
// Constructor/destructor
/// Inits a sprite with no texture
pub fn init() !Self {
var sprite = sf.c.sfSprite_create();
if (sprite == null)
return sf.Error.nullptrUnknownReason;
... | src/sfml/graphics/sprite.zig |
const std = @import("std");
const Answer = struct { @"0": u32, @"1": u32 };
const AugmentedPoint = struct { x: usize, y: usize, cost: u32 };
const Point = struct { x: usize, y: usize };
fn wrappingAdd(x: u32, a: u32) u32 {
if (x + a > 9) {
return (x + a) % 9;
} else {
return x + a;
}
}
fn... | src/day15.zig |
const Benchmark = @import("benchmark.zig");
const Atom = Benchmark.Atom;
const Counters = Benchmark.Counters;
pub const descr =
\\- delta from `mikdusan.0`
\\- iterator does NOT return EOF
;
pub fn spin(self: *Atom, bm: Benchmark, counters: *Counters, magnify: usize) Atom.Error!void {
var it: Iterator = u... | src/atom.mikdusan.1.zig |
const std = @import("std");
/// Import the C implementations of termios for use when linking libc.
const c = @cImport({
@cInclude("termios.h");
@cInclude("sys/ioctl.h");
});
/// Linux has a syscall-based Termios implementation in stdlib, but
/// has no implementation for BSDs or Darwin. Those operating system... | src/posix/termios.zig |
const std = @import("std");
usingnamespace @import("util");
usingnamespace @import("context.zig");
usingnamespace @import("unit.zig");
usingnamespace @import("source.zig");
pub const log = struct {
pub const Level = enum {
err,
warn,
};
const Self = @This();
const EscapedStrin... | src/compile/log.zig |
const std = @import("std");
const nanovg = std.build.Pkg{
.name = "nanovg",
.path = std.build.FileSource.relative("deps/nanovg/src/nanovg.zig"),
};
const zalgebra = std.build.Pkg{
.name = "zalgebra",
.path = std.build.FileSource.relative("deps/zalgebra/src/main.zig"),
};
pub fn build(b: *std.build.Bu... | build.zig |
const sabaton = @import("root").sabaton;
comptime {
asm (
// We pack the CPU boot trampolines into the stack slots, because reasons.
\\ .section .data
\\ .balign 8
\\ .global smp_tag
\\smp_tag:
\\ .8byte 0x34d1d96339647025 // smp identifier
\\ .8byte 0 ... | src/platform/pine_aarch64/smp.zig |
const std = @import("std");
const assert = std.debug.assert;
const expect = std.testing.expect;
const mem = std.mem;
const bits = @import("./bits.zig");
test "reverse8" {
try expect(bits.reverse8(0x00) == 0x00);
try expect(bits.reverse8(0x01) == 0x80);
try expect(bits.reverse8(0x08) == 0x10);
try exp... | src/bits_test.zig |
const std = @import("std");
const lib = @import("lib");
const mem = std.mem;
const assert = std.debug.assert;
const testing = std.testing;
const meta = std.meta;
const fs = std.fs;
const fmt = std.fmt;
const io = std.io;
const os = std.os;
const math = std.math;
const stdout = io.getStdOut().writer();
const stdin = io.... | src/main.zig |
const builtin = @import("builtin");
const std = @import("std");
const math = std.math;
const testing = @import("std").testing;
// mulo - multiplication overflow
// * return a*%b.
// * return if a*b overflows => 1 else => 0
// - mulo_genericSmall as default
// * optimized version with ca. 5% performance gain over mul... | src/crt/mulo_noptr.zig |
const stdx = @import("stdx");
const Function = stdx.Function;
const graphics = @import("graphics");
const Color = graphics.Color;
const platform = @import("platform");
const ui = @import("../ui.zig");
const widgets = ui.widgets;
const Row = widgets.Row;
const Column = widgets.Column;
const Flex = widgets.Flex;
const S... | ui/src/widgets/color_picker.zig |
const cc_bake = @import("cc_bake");
const cc_gfx = @import("cc_gfx");
const cc_math = @import("cc_math");
const cc_res = @import("cc_res");
const cc_time = @import("cc_time");
const cc_wnd = @import("cc_wnd");
const cc_wnd_gfx = @import("cc_wnd_gfx");
const std = @import("std");
const Vertex = struct {
position: c... | ex/cube/cube.zig |
const std = @import("std");
pub const Colorspace = enum { RGB, RGBA };
/// 8-bit sRGB color with transparency as 32 bits ordered RGBA
pub const Color = packed struct {
red: u8,
green: u8,
blue: u8,
alpha: u8 = 255,
pub const black = Color.comptimeFromString("#000000");
pub const red = Color.c... | src/color.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
const SFDigit = struct {
n: u16,
depth: u8,
};
const SFNum = struct {
const TQ = std.TailQueue(*SFDigit);
nums: std.TailQueue(*SFDigit),
alloc: std.mem.Allocator,
pub fn fromInput(alloc: std.mem.Allocator, inp: []const u8) !*SFNu... | 2021/18/aoc.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
test "examples" {
const test1 = aoc.readLines(aoc.talloc, aoc.test1file);
defer aoc.talloc.free(test1);
const test2 = aoc.readLines(aoc.talloc, aoc.test2file);
defer aoc.talloc.free(test2);
const inp = aoc.readLines(aoc.talloc, aoc.inp... | 2020/11/aoc.zig |
const GBA = @import("core.zig").GBA;
const BIOS = @import("bios.zig").BIOS;
pub const OAM = struct {
pub const ObjMode = enum(u2) {
Normal,
SemiTransparent,
ObjWindow,
};
pub const FlipSettings = packed struct {
dummy: u3 = 0,
horizontalFlip: u1 = 0,
vertica... | GBA/oam.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = &gpa.allocator;
defer _ = gpa.deinit();
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
if (a... | src/day04.zig |
const std = @import("std");
pub const RollType = enum {
Normal,
Advantage,
Disadvantage,
pub fn jsonStringify(
self: RollType,
_: std.json.StringifyOptions,
out_stream: anytype,
) !void {
try out_stream.writeByte('\"');
try out_stream.writeAll(@tagName(self... | src/dnd/dice.zig |
usingnamespace @import("raylib-zig.zig");
pub extern fn Clamp(value: f32, min: f32, max: f32) f32;
pub extern fn Lerp(start: f32, end: f32, amount: f32) f32;
pub extern fn Vector2Zero() Vector2;
pub extern fn Vector2One() Vector2;
pub extern fn Vector2Add(v1: Vector2, v2: Vector2) Vector2;
pub extern fn Vector2Subtrac... | lib/raylib-zig-math.zig |
const std = @import("std");
const log = std.log;
const mem = std.mem;
const assert = std.debug.assert;
const TokenType = enum {
const Self = @This();
lbrace,
rbrace,
lbracket,
rbracket,
colon,
comma,
number,
word,
pub fn format(
self: Self,
comptime fmt: []con... | zig-1/src/main.zig |
const std = @import("std");
const fs = std.fs;
const Answer = struct {
unmarked_sum: u32 = 0,
win_number: u32 = 0,
};
const Board = struct {
entries: [25]u8,
// bit i in `mask` is set if the corresponding entry was drawn
mask: u25 = 0,
};
fn board_is_winning(mask: u25) bool {
const patterns ... | day4/main.zig |
const std = @import("std");
const builtin = @import("builtin");
const gba = @import("gba.zig");
const nds = @import("nds/index.zig");
const utils = @import("utils.zig");
const randomizer = @import("randomizer.zig");
const clap = @import("clap.zig");
const pokemon = @import("pokemon/index.zig");
const gen3 = pokemon.gen... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const uart = @import("./uart.zig");
/// A Page descriptor, stored starting at __heap_start.
const Page = extern struct {
flags: u8,
pub const Flags = enum(u8) {
empty = 0b0000_0000,
taken = 0b0000_0001,
last = 0b0000_00010,... | src/heap.zig |
const std = @import("std");
fn root() []const u8 {
return std.fs.path.dirname(@src().file) orelse ".";
}
const root_path = root() ++ "/";
pub const include_dir = root_path ++ "curl/include";
const package_path = root_path ++ "src/main.zig";
const lib_dir = root_path ++ "curl/lib";
pub const Define = struct {
... | .gyro/zig-libcurl-mattnite-github.com-f1f316dc/pkg/libcurl.zig |
const DEBUGMODE = @import("builtin").mode == @import("builtin").Mode.Debug;
const std = @import("std");
const sg = @import("sokol").gfx;
const sapp = @import("sokol").app;
const stime = @import("sokol").time;
const sgapp = @import("sokol").app_gfx_glue;
const sdtx = @import("sokol").debugtext;
const sa = @import("sok... | src/test_kbrd.zig |
const builtin = @import("builtin");
const std = @import("std");
// popcount - population count
// counts the number of 1 bits
// SWAR-Popcount: count bits of duos, aggregate to nibbles, and bytes inside
// x-bit register in parallel to sum up all bytes
// SWAR-Masks and factors can be defined as 2-adic fractions
... | lib/std/special/compiler_rt/popcount.zig |
const std = @import("std");
const utils = @import("utils.zig");
const gl = @import("gl.zig");
const vec2 = @import("math/vec2.zig");
const vec3 = @import("math/vec3.zig");
const Vec2f = vec2.Generic(f32);
const Vec3f = vec3.Generic(f32);
/// Error set
pub const Error = error{ FailedToGenerateBuffers, ObjectOverflo... | src/kiragine/kira/renderer.zig |
const std = @import("std");
const fomu = @import("./fomu.zig");
pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
@setCold(true);
fomu.panic(message, stack_trace);
}
fn rgb_init() void {
// Turn on the RGB block and current enable, as well as enabling led control
fomu... | riscv-zig-blink/src/main.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day14.txt");
const Value = struct {
result : u8,
lastVisitCount : u64,
nextVisitCount : u64,
};
pub fn main() !void {
var timer = try std.time.Timer.start();
... | src/day14.zig |
const std = @import("std");
/// Parses arguments for the given specification and our current process.
/// - `Spec` is the configuration of the arguments.
/// - `allocator` is the allocator that is used to allocate all required memory
/// - `error_handling` defines how parser errors will be handled.
pub fn parseForCurr... | args.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/day05.txt");
//... | src/day05.zig |
const std = @import("std");
const TermGUI = @import("TermGUI.zig");
const cli = @import("cli.zig");
fn renderJsonNode(out: anytype, key: []const u8, value: *const std.json.Value, indent: u32) @TypeOf(out).Error!void {
const collapsible = switch (value.*) {
.Object => true,
.Array => true,
... | src/main.zig |
usingnamespace @import("constants.zig");
usingnamespace @import("../include/pspge.zig");
usingnamespace @import("../include/pspdisplay.zig");
usingnamespace @import("../include/pspthreadman.zig");
usingnamespace @import("../include/psploadexec.zig");
const builtin = @import("builtin");
//Internal variables for the sc... | src/psp/utils/debug.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const data = @embedFile("../inputs/day21.txt");
pub fn main() anyerror!void {
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_impl.deinit();
const gpa = gpa_impl.allocator();
return m... | src/day21.zig |
const std = @import("std");
const builtin = @import("builtin");
const CallingConvention = @import("std").builtin.CallingConvention;
const is_nvptx = builtin.cpu.arch == .nvptx64;
const PtxKernel = if (is_nvptx) CallingConvention.PtxKernel else CallingConvention.Unspecified;
pub export fn transposeCpu(data: []const u32... | CS344/src/lesson5_kernel.zig |
const std = @import("std");
const root = @import("./dns.zig");
const dns = root;
const resolvconf = @import("./resolvconf.zig");
pub fn randomId() u16 {
const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
var r = std.rand.DefaultPrng.init(seed);
return r.random.int(u16);
}
/// Open a s... | src/pkg2/helpers.zig |
const std = @import("std");
const linux = std.os.linux;
const prot = @import("../protocols.zig");
const renderer = @import("../renderer.zig");
const compositor = @import("../compositor.zig");
const Context = @import("../client.zig").Context;
const Object = @import("../client.zig").Object;
const Client = @import("../cli... | src/implementations/wl_surface.zig |
const graphics = @import("graphics.zig");
pub const Glyph = struct {
pub const Padding = 1;
// Glyph id used in the ttf file.
glyph_id: u16,
image: graphics.ImageTex,
// Top-left tex coords.
u0: f32,
v0: f32,
// Bot-right tex coords.
u1: f32,
v1: f32,
// for shaping, px... | graphics/src/backend/gpu/glyph.zig |
const std = @import("std.zig");
const assert = std.debug.assert;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const mem = std.mem;
const math = std.math;
const ziggurat = @import("rand/ziggurat.zig");
const maxInt = std.math.maxInt;
/// Fast unbiased random numbers.
pub const Defaul... | lib/std/rand.zig |
const index = @import("index.zig");
const std = @import("std");
const mem = std.mem;
const math = std.math;
pub const Fs = struct {
const Lookup = std.AutoHashMap([]const u8, usize);
const Files = std.SegmentedList(FileData, 16);
const FileData = std.ArrayList(u8);
allocator: *mem.Allocator,
files... | src/mem.zig |
const root = @import("root");
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
var argc_ptr: [*]usize = undefined;
const is_wasm = switch (builtin.arch) {
.wasm32, .wasm64 => true,
else => false,
};
comptime {
if (builtin.link_libc) {
@export("main... | std/special/start.zig |
const std = @import("std");
const ConstantOrBuffer = @import("trigger.zig").ConstantOrBuffer;
const Span = @import("basics.zig").Span;
inline fn sin(t: f32) f32 {
return std.math.sin(t * std.math.pi * 2.0);
}
pub const SineOsc = struct {
pub const num_outputs = 1;
pub const num_temps = 0;
pub const Pa... | src/zang/mod_sineosc.zig |
const expect = @import("std").testing.expect;
test "if statement" {
const a = true;
var x: u16 = 0;
if (a) {
x += 1;
} else {
x += 2;
}
expect(x == 1);
}
test "if statement expression" {
const a = true;
var x: u16 = 0;
x += if (a) 1 else 2;
expect(x == 1);
}
te... | chapter-1-passing-tests.zig |
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
const ArenaAllocator = std.heap.ArenaAllocator;
const Allocator = std.mem.Allocator;
const StringHashMap = std.hash_map.StringHashMap;
const fmt = std.fmt;
const builtin = @import("builtin");
const routez = @import("routez");
const Routez... | src/server.zig |
const std = @import("std");
const builtin = std.builtin;
// Format reference: http://grub.gibibit.com/New_font_format
pub const PF2Font = struct {
name: []const u8,
family: []const u8,
weight: Weight,
slant: Slant,
pointSize: u16,
maxWidth: u16,
maxHeight: u16,
ascent: u16,
descent... | src/pf2.zig |
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const warn = std.debug.warn;
const fepsilon = @import("fepsilon.zig").fepsilon;
// Set to true for debug output
const DBG = false;
/// Return true if x is approximat... | approxeql.zig |
//--------------------------------------------------------------------------------
// Section: Types (4)
//--------------------------------------------------------------------------------
const IID_IWindowsDevicesAllJoynBusAttachmentInterop_Value = @import("../../zig.zig").Guid.initString("fd89c65b-b50e-4a19-9d0c-b42b... | win32/system/win_rt/all_joyn.zig |
const std = @import("std");
const fmt = std.fmt;
const testing = std.testing;
/// Parses Redis Set values.
pub const SetParser = struct {
// TODO: prevent users from unmarshaling structs out of strings
pub fn isSupported(comptime T: type) bool {
return switch (@typeInfo(T)) {
.Array => true... | src/parser/t_set.zig |
const std = @import("std");
pub const Timings = &[_][]const u8{
&[_]u8{4}, // 0x00 - NOP
&[_]u8{}, // 0x01
&[_]u8{}, // 0x02
&[_]u8{}, // 0x03
&[_]u8{}, // 0x04
&[_]u8{}, // 0x05
&[_]u8{ 4, 3 }, // 0x06 - LD B,n
&[_]u8{}, // 0x07
&[_]u8{}, // 0x08
&[_]u8{}, // 0x09
&[_]u8{},... | lib/cpu/z80/timings.zig |
const std = @import("std");
const builtin = @import("builtin");
const normalize = @import("divdf3.zig").normalize;
const wideMultiply = @import("divdf3.zig").wideMultiply;
pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
@setRuntimeSafety(builtin.is_test);
const Z = std.meta.Int(false, 128);
const Si... | lib/std/special/compiler_rt/divtf3.zig |
const std = @import("std");
const builtin = @import("builtin");
const riscv = std.Target.riscv;
pub const arch = comptime Arch.default();
pub const Arch = struct {
features: std.Target.Cpu.Feature.Set,
XLEN: type = u32,
XLENi: type = i32,
XLENd: type = u64,
XLENb: u8 = 32,
vendorId: u32 = 0,
... | src/cpu.zig |
const os = @import("root").os;
const std = @import("std");
pub const paging = @import("paging.zig");
pub const thread = @import("thread.zig");
pub const InterruptFrame = interrupts.InterruptFrame;
pub const InterruptState = interrupts.InterruptState;
pub const get_and_disable_interrupts = interrupts.get_and_disable_i... | src/platform/aarch64/aarch64.zig |
pub const Mnemonic = enum {
pub const count: usize = @enumToInt(Mnemonic._mnemonic_final);
pub const first: Mnemonic = Mnemonic.AAA;
pub const last: Mnemonic = Mnemonic.XTEST;
AAA,
AAD,
AAM,
AAS,
ADC,
ADCX,
ADD,
ADDPD,
ADDPS,
ADDSD,
ADDSS,
ADDSUBPD,
ADDSU... | src/x86/mnemonic.zig |
// This code was generated by a tool.
// IUP Metadata Code Generator
// https://github.com/batiati/IUPMetadata
//
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
const std = @import("std");
const ascii = std.ascii;
const testing = std.testing;
const Impl =... | src/IupMetadata/CodeGenerators/Zig/templates/elements.zig |
const wapc = @import("wapc");
const std = @import("std");
const mem = std.mem;
const json = std.json;
const testing = std.testing;
const fmt = std.fmt;
const RndGen = std.rand.DefaultPrng;
extern "wapc" fn __console_log(ptr: [*]u8, len: usize) void;
export fn __guest_call(operation_size: usize, payload_size: usize) ... | main.zig |
const Allocator = std.mem.Allocator;
const Buffer = std.ArrayList(u8);
const BodyReader = @import("../readers/readers.zig").BodyReader;
const Data = @import("../events/events.zig").Data;
const Event = @import("../events/events.zig").Event;
const Method = @import("http").Method;
const Request = @import("../events/events... | src/state_machines/server.zig |
const std = @import("std");
const process = std.process;
const stdx = @import("stdx");
const string = stdx.string;
const ds = stdx.ds;
const graphics = @import("graphics");
const Color = graphics.Color;
const sdl = @import("sdl");
const v8 = @import("v8");
const build_options = @import("build_options");
const v8x = @i... | runtime/main.zig |
const sdl = @import("sdl");
const std = @import("std");
const stdx = @import("stdx");
const t = stdx.testing;
const platform = @import("platform.zig");
const KeyDownEvent = platform.KeyDownEvent;
const KeyUpEvent = platform.KeyUpEvent;
const KeyCode = platform.KeyCode;
const MouseDownEvent = platform.MouseDownEvent;
c... | platform/input_sdl.zig |
const std = @import("std");
const DW = std.dwarf;
const assert = std.debug.assert;
const testing = std.testing;
/// General purpose registers in the SPARCv9 instruction set
pub const Register = enum(u6) {
// zig fmt: off
g0, g1, g2, g3, g4, g5, g6, g7,
o0, o1, o2, o3, o4, ... | src/arch/sparcv9/bits.zig |
const Archive = @This();
const builtin = @import("builtin");
const std = @import("std");
const fmt = std.fmt;
const fs = std.fs;
const mem = std.mem;
const log = std.log.scoped(.archive);
const Allocator = std.mem.Allocator;
file: fs.File,
name: []const u8,
// We need to differentiate between inferred and output ar... | src/archive/Archive.zig |
// Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS
pub const FNC_RETURN: usize = 0xFEFFFFFF; // bit [0] ignored when processing a branch
/// These EXC_RETURN mask values are used to evaluate the LR on exception entry.
pub const EXC_RETURN = struct {
pub con... | src/drivers/arm_m.zig |
const builtin = @import("builtin");
const std = @import("std");
const testing = std.testing;
const fmt = std.fmt;
const FixBuf = @import("../types/fixbuf.zig").FixBuf;
const perfectHash = @import("../lib/perfect_hash.zig").perfectHash;
// // TODO: decide what tho do with this weird trait.
// inline fn isFragmentType(c... | src/parser/t_map.zig |
const std = @import("std");
const warn = std.debug.warn;
const utils = @import("utils.zig");
const ReverseSliceIterator = @import("utils.zig").ReverseSliceIterator;
// TODO: fix entity_mask. it should come from EntityTraitsDefinition.
pub fn SparseSet(comptime SparseT: type) type {
return struct {
const Se... | src/ecs/ecs/sparse_set.zig |
const builtin = @import("builtin");
const std = @import("std");
const EXIT_FAILURE = 1;
pub fn initIface() !void {
try switch (builtin.os.tag) {
.linux => linuxIface(),
.freebsd => freebsdIface(),
.netbsd => netbsdIface(),
else => {},
};
}
fn linuxIface() !void {
var aren... | src/interface.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const mem = std.mem;
const math = std.math;
const Queue = std.atomic.Queue;
const Timer = std.os.time.Timer;
const builtin = @import("builtin");
const AtomicOrder = builtin.AtomicOrder;
const AtomicRmwOp = builtin.AtomicRmwOp;
c... | futex.zig |
const std = @import("std");
const build_options = @import("build_options");
const ascii = std.ascii;
const debug = std.debug;
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const net = std.net;
const os = std.os;
const time = std.time;
const Atomic = std.atomic.Atomic;
const assert... | src/lib.zig |
const build_options = @import("build_options");
const utils = @import("utils");
const georgios = @import("georgios");
const keyboard = georgios.keyboard;
const Key = keyboard.Key;
const Event = keyboard.Event;
const kernel = @import("root").kernel;
const print = kernel.print;
const key_to_char = kernel.keys.key_to_c... | kernel/platform/ps2.zig |
const std = @import("std");
const states = @import("state.zig");
const Node = std.zig.ast.Node;
const Tree = std.zig.ast.Tree;
const State = states.State;
pub fn appendNamespace(
allocator: *std.mem.Allocator,
namespace: []const u8,
element: []const u8,
) ![]const u8 {
return try std.mem.join(allocato... | src/build_map.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const Peer = @import("../Peer.zig");
const Handshake = @import("Handshake.zig");
const Message = @import("message.zig").Message;
const TcpClient = @This();
/// peer we are connected to
peer: Peer,
/// bit representation of the pieces we have
bitfield: ... | src/net/Tcp_client.zig |
const std = @import("std");
pub const TokenType = enum {
unknown,
multiply,
divide,
mod,
add,
subtract,
negate,
less,
less_equal,
greater,
greater_equal,
equal,
not_equal,
not,
assign,
bool_and,
bool_or,
left_paren,
right_paren,
left_brace... | lexer.zig |
usingnamespace @import("root").preamble;
const log = lib.output.log.scoped(.{
.prefix = "x86_64 Paging",
.filter = .info,
}).write;
const paging_common = @import("../paging.zig");
pub var page_sizes: []const usize = undefined;
const pages_4K = [_]usize{
0x1000, // 4K << 0
0x200000, // 4K << 9
0x... | subprojects/flork/src/platform/aarch64/paging.zig |
const Builder = @import("std").build.Builder;
const Build = @import("std").build;
const Builtin = @import("std").builtin;
const Zig = @import("std").zig;
usingnamespace @import("libbuild.zig");
pub fn build(b: *Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions... | build.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/day05.txt");
c... | src/day05.zig |
const std = @import("std");
pub fn Bitset(comptime S: type) type {
return struct {
const Self = @This();
pub const Elem = S;
pub const Bits = std.meta.IntType(false, @typeInfo(S).Enum.fields.len);
bits: Bits,
pub const empty = Self{ .bits = 0 };
pub fn singleton(el... | src/util.zig |
const std = @import("std");
const Image = @import("image.zig").Image;
const Allocator = std.mem.Allocator;
const BmpError = error {
InvalidHeader,
InvalidCompression,
UnsupportedFormat
};
pub fn read(allocator: *Allocator, reader: anytype, seekable: anytype) !Image {
const signature = try reader.readB... | didot-image/bmp.zig |
const internal = @import("./internal.zig");
const string = []const u8;
const Top = @This();
pub const Port = struct {
IP: ?string = null,
PrivatePort: i32,
PublicPort: ?i32 = null,
Type: enum {
tcp,
udp,
sctp,
},
};
pub const MountPoint = struct {
Type: string,
Name... | src/direct.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const eql = std.meta.eql;
const panic = std.debug.panic;
const strings_module = @import("strings.zig");
const Strings = strings_module.Strings;
const InternedString = strings_module.InternedString;
const Entity = @import(... | src/components.zig |
const std = @import("std");
const testing = std.testing;
const meta = std.meta;
const unicode = std.unicode;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const math = std.math;
const Uuid = @import("uuid6");
const serde = @import("serde.zig");
const nbt = @import("nbt.zig");
const VarNum = @i... | src/mcproto.zig |
const std = @import("std");
// source: https://github.com/raysan5/raylib/blob/cba412cc313e4f95eafb3fba9303400e65c98984/src/str.c#L1615
pub fn nextCodepoint(str: []const u8, bytesprocessed: *i32) i32 {
var code: i32 = 0x3f; // codepoint (defaults to '?');
var octet: i32 = @intCast(i32, str[0]); // the first UT... | src/core/utf8.zig |
const std = @import("std");
const builtin = @import("builtin");
const os = builtin.os;
const fmt = std.fmt;
const mem = std.mem;
const testing = std.testing;
const io = std.io;
const heap = std.heap;
const fs = std.fs;
const clap = @import("clap");
const version = "0.1.0";
const maxLineLength = 4096;
pub fn main() a... | src/main.zig |
const std = @import("std");
pub const gpu = @import("gpu/build.zig");
const gpu_dawn = @import("gpu-dawn/build.zig");
pub const glfw = @import("glfw/build.zig");
pub fn build(b: *std.build.Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const gpu_dawn_... | build.zig |
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const Pkg = std.build.Pkg;
pub const EngineConfig = struct {
windowModule: []const u8 = "didot-glfw",
physicsModule: []const u8 = "didot-ode",
/// Whether or not to automatically set the window mod... | build.zig |
const std = @import("std");
const Image = @import("image.zig").Image;
const printError = @import("../application/print_error.zig").printError;
const ImageHeader = struct {
size: i32,
width: i32,
height: i32,
planes: i16,
bit_count: i16,
compression: i32,
size_image: i32,
xpels_per_me... | src/image/bmp.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;
const Vec2 = tool... | 2019/day15.zig |
const std = @import("std");
const assert = std.debug.assert;
const pagez = @import("pagez.zig");
const Point = pagez.Point;
const Position = pagez.Position;
const Size = pagez.Size;
fn to16bitColor(r: u8, g: u8, b: u8) [4]u8 {
assert(r < 32);
assert(g < 64);
assert(b < 32);
var color: [4]u8 = undefined... | libs/core/gui.zig |
const std = @import("std");
const c = @import("c.zig");
const android = @import("android-bind.zig");
const build_options = @import("build_options");
pub const egl = @import("egl.zig");
pub const JNI = @import("jni.zig").JNI;
const app_log = std.log.scoped(.app_glue);
// Export the flat functions for now
// pub con... | src/android-support.zig |
const std = @import("std");
const os = std.os;
const fs = std.fs;
const proto = @import("protocol.zig");
const wire = @import("wire.zig");
const Header = @import("wire.zig").Header;
const WireBuffer = @import("wire.zig").WireBuffer;
const Connection = @import("connection.zig").Connection;
// TODO: think up a better na... | src/connector.zig |
const std = @import("std.zig");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const mem = std.mem;
const Allocator = mem.Allocator;
/// A contiguous, growable list of items in memory.
/// This is a wrapper around an array of T values. Initialize with `init`.
pub fn ArrayList(compti... | lib/std/array_list.zig |
const root = @import("root");
const std = @import("std.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
const elf = std.elf;
const dl = @import("dynamic_library.zig");
const MAX_PATH_BYTES = std.fs.MAX_PATH_BYTES;
pub const darwin = @import("os/da... | lib/std/os.zig |
const std = @import("std");
const stb = @import("stb_image");
const gl = @import("gl");
const Self = @This();
id: c_uint = undefined,
width: f32 = undefined,
height: f32 = undefined,
dead: bool = true,
/// Loads an already existing opengl texture from a c_uint
/// inDepth optionally inspects the opengl texture to fil... | src/zt/texture.zig |
const Builder = @import("std").build.Builder;
const packages = @import("zig-cache/packages.zig").list;
pub fn build(b: *Builder) void {
var target = b.standardTargetOptions(.{});
if (target.abi == null) {
target.abi = .musl;
}
const exe = b.addExecutable("toybox", "src/main.zig");
// TODO... | build.zig |
const math3d = @import("math3d.zig");
const Vec4 = math3d.Vec4;
const Mat4x4 = math3d.Mat4x4;
const mat4x4_identity = math3d.mat4x4_identity;
const tetris = @import("tetris.zig");
const Tetris = tetris.Tetris;
const std = @import("std");
const panic = std.debug.panic;
const assert = std.debug.assert;
const bufPrint = s... | src/main.zig |
const std = @import("std");
const Compilation = @import("../Compilation.zig");
const Object = @import("../Object.zig");
const Elf = @This();
const Section = struct {
data: std.ArrayList(u8),
relocations: std.ArrayListUnmanaged(Relocation) = .{},
flags: u64,
type: u32,
index: u16 = undefined,
};
c... | src/object/Elf.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Probe = struct {
const V2 = struct {
x: isize,
y: isize,
pub fn init(x: isize, y: isize) V2 {
var self = V2{ .x = x, .y = y };
return self;
}
};
... | 2021/p17/probe.zig |
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const L = std.unicode.utf8ToUtf16LeStringLiteral;
const zwin32 = @import("zwin32");
const w = zwin32.base;
const d3d12 = zwin32.d3d12;
const wasapi = zwin32.wasapi;
const mf = zwin32.mf;
const hrPanic = zwin32.hrPanic;
const hrPanicOnFa... | samples/audio_playback_test/src/audio_playback_test.zig |
const std = @import("../std.zig");
const math = std.math;
const DefaultPrng = std.rand.DefaultPrng;
const Random = std.rand.Random;
const SplitMix64 = std.rand.SplitMix64;
const DefaultCsprng = std.rand.DefaultCsprng;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const SequentialPrng ... | lib/std/rand/test.zig |
const std = @import("std");
const max = std.math.max;
const min = std.math.min;
const warn = std.debug.warn;
/// Fixed-length element sliding window.
/// Write to the very end.
/// Read from an offset from the end or theoretical start.
/// Older elements are removed.
/// Useful for audio processing and LZ77-style comp... | src/sliding_window.zig |
usingnamespace @import("bits.zig");
pub const MMRESULT = UINT;
pub const MMSYSERR_BASE = 0;
pub const TIMERR_BASE = 96;
pub const MMSYSERR_ERROR = MMSYSERR_BASE + 1;
pub const MMSYSERR_BADDEVICEID = MMSYSERR_BASE + 2;
pub const MMSYSERR_NOTENABLED = MMSYSERR_BASE + 3;
pub const MMSYSERR_ALLOCATED = MMSYSERR_BASE + 4;
... | lib/std/os/windows/winmm.zig |
const std = @import("std");
usingnamespace (@import("../machine.zig"));
usingnamespace (@import("../util.zig"));
// QuickRef: https://www.felixcloutier.com/x86/push
const imm = Operand.immediate;
const reg = Operand.register;
const regRm = Operand.registerRm;
const memRm = Operand.memoryRmDef;
test "push" {
con... | src/x86/tests/push.zig |
const math = @import("std").math;
const c = @import("c.zig");
const vec2_zero = c.ImVec2{ .x = 0, .y = 0 };
const vec2_one = c.ImVec2{ .x = 1, .y = 1 };
const vec4_zero = c.ImVec4{ .x = 0, .y = 0, .z = 0, .w = 0 };
const vec4_one = c.ImVec4{ .x = 1, .y = 1, .z = 1, .w = 1 };
pub const Font = c.ImFont;
pub const getIO =... | src/deps/imgui/api.zig |