code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const zs = @import("zstack.zig");
pub const LockStyle = enum {
/// Lock delay is reset on entry of new piece.
Entry,
/// Lock delay is reset on downwards movement.
Step,
/// Lock delay is reset on any successful movement.
Move,
};
pub const InitialActionStyle = e... | src/config.zig |
usingnamespace @import("Zig-PSP/src/psp/include/pspge.zig");
usingnamespace @import("Zig-PSP/src/psp/include/psputils.zig");
usingnamespace @import("Zig-PSP/src/psp/utils/psp.zig");
usingnamespace @import("Zig-PSP/src/psp/include/pspdisplay.zig");
var draw_buffer: ?[*]u32 = null;
var disp_buffer: ?[*]u32 = null;
pub ... | src/gfx.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XpExtension", .global_id = 0 };
pub const STRING8 = u8;
/// @brief PRINTER
pub const PRINTER = struct {
@"nameLen": u32,
@"name": []xcb.xprint.STRING8,
@"descLen": u32,
@"description": []xcb.xprint.STRING8,
};
pub const PCONT... | src/auto/xprint.zig |
const std = @import("std");
const audiometa = @import("audiometa");
const Allocator = std.mem.Allocator;
const build_options = @import("build_options");
pub const log_level: std.log.Level = .warn;
pub export fn main() void {
zigMain() catch unreachable;
}
pub fn zigMain() !void {
var gpa = std.heap.GeneralPu... | test/fuzz-oom.zig |
const std = @import("std");
const utils = @import("utils.zig");
const vector = @import("vector.zig");
const Vec4 = vector.Vec4;
const Mat4 = @import("matrix.zig").Mat4;
const Material = @import("material.zig").Material;
const Ray = @import("ray.zig").Ray;
const Intersections = @import("ray.zig").Intersections;
con... | shape.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const glfw = @import("glfw");
const gpu = @import("gpu");
const App = @import("app");
const structs = @import("structs.zig");
const enums = @import("enums.zig");
const Engine = @This();
/// Window, events, inputs etc.
core: Core,
/// WebGPU driver - st... | src/Engine.zig |
const std = @import("std");
const vk = @import("vulkan");
const c = @import("c.zig");
const err = @import("err.zig");
const glfw = @import("glfz.zig");
pub const Window = opaque {
pub const InitError = error{
OutOfMemory,
ApiUnavailable,
VersionUnavailable,
FormatUnavailable,
... | types.zig |
const std = @import("../std.zig");
const io = std.io;
const testing = std.testing;
const mem = std.mem;
const assert = std.debug.assert;
/// This turns a byte buffer into an `io.Writer`, `io.Reader`, or `io.SeekableStream`.
/// If the supplied byte buffer is const, then `io.Writer` is not available.
pub fn FixedBuffer... | lib/std/io/fixed_buffer_stream.zig |
const std = @import("std");
const mem = std.mem;
const ascii = @import("../../ascii.zig");
const Context = @import("../../Context.zig");
const Self = @This();
context: *Context,
pub fn new(ctx: *Context) Self {
return Self{ .context = ctx };
}
/// isCased detects cased letters.
pub fn isCased(self: Self, cp: u... | src/components/aggregate/Letter.zig |
const std = @import("std");
const string = []const u8;
const ansi = @import("ansi");
const root = @import("root");
const zigmod = @import("../lib.zig");
const u = @import("./../util/index.zig");
const common = @import("./../common.zig");
const build_options = if (@hasDecl(root, "build_options")) root.build_options el... | src/cmd/fetch.zig |
const std = @import("std");
const string = []const u8;
const builtin = @import("builtin");
const deps = @import("./deps.zig");
pub fn build(b: *std.build.Builder) void {
const target = b.standardTargetOptions(.{});
b.setPreferredReleaseMode(.ReleaseSafe);
const mode = b.standardReleaseOptions();
cons... | build.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const style = @import("style.zig");
const Style = style.Style;
const FontStyle = style.FontStyle;
const Color = style.Color;
const ParseState = enum {
Parse8,
ParseFgNon8,
ParseFg256,
ParseFgRed... | src/parse_style.zig |
const std = @import("std");
pub fn Earcut(comptime Scalar: type) type {
const Scalar_min = switch (Scalar) {
f16 => std.math.f16_min,
f32 => std.math.f32_min,
f64 => std.math.f64_min,
f128 => std.math.f128_min,
else => unreachable,
};
const Scalar_max = switch (Scal... | src/main.zig |
const std = @import("std");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const fmt = std.fmt;
const io = std.io;
const Endian = std.builtin.Endian;
const float_t = f64;
const int_t = u64;
const size_t = usize;
const FixedBufferReader = io.FixedBufferStream([]const u8).Reader;
comptime {
... | src/state.zig |
//--------------------------------------------------------------------------------
// Section: Types (9)
//--------------------------------------------------------------------------------
const CLSID_InkDesktopHost_Value = @import("../../zig.zig").Guid.initString("062584a6-f830-4bdc-a4d2-0a10ab062b1d");
pub const CLSI... | win32/ui/input/ink.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const Target = std.Target;
const Version = std.builtin.Version;
pub const macos = @import("darwin/macos.zig");
/// Check if SDK is installed on Darwin without triggering CLT installation popup window.
/// Note: simply invoking `xcrun` w... | lib/std/zig/system/darwin.zig |
const std = @import("std");
const pokemon = @import("index.zig");
const gba = @import("../gba.zig");
const bits = @import("../bits.zig");
const utils = @import("../utils/index.zig");
const common = @import("common.zig");
const fun = @import("../../lib/fun-with-zig/src/index.zig");
const mem = std.mem;
const debug = st... | src/pokemon/gen3.zig |
const builtin = @import("builtin");
const std = @import("std");
const assert = std.debug.assert;
const print = std.debug.print;
const arch = if (builtin.cpu.arch == .x86_64)
@import("x86_64.zig")
else
@compileError("Unimplemented for this architecture");
pub const VA_Errors = arch.VA_Errors;
pub const VAList... | src/varargs.zig |
const std = @import("std");
const eql = std.mem.eql;
const stdin = std.io.getStdIn().reader();
const stdout = std.io.getStdOut().writer();
const stderr = std.io.getStdErr().writer();
const print = @import("std").debug.print;
const page_allocator = std.heap.page_allocator;
const ArenaAllocator = std.heap.ArenaAllocator... | src/main.zig |
const Self = @This();
const build_options = @import("build_options");
const std = @import("std");
const wlr = @import("wlroots");
const log = std.log.scoped(.input_config);
const c = @import("c.zig");
const server = &@import("main.zig").server;
const util = @import("util.zig");
const InputDevice = @import("InputM... | source/river-0.1.0/river/InputConfig.zig |
const std = @import("std");
const builtin = @import("builtin");
const log = std.log.scoped(.@"brucelib.graphics.d3d11");
const common = @import("common.zig");
const VertexBufferHandle = common.VertexBufferHandle;
const VertexLayoutDesc = common.VertexLayoutDesc;
const VertexLayoutHandle = common.VertexLayoutHandle;
c... | modules/graphics/src/d3d11.zig |
const u = @import("../util.zig");
const std = @import("std");
const Expr = @import("../Expr.zig");
const IR = @import("../IR.zig");
const p = @import("parse.zig");
const Ctx = @import("../Wat.zig");
ctx: *Ctx,
bytes: std.ArrayListUnmanaged(u8) = .{},
relocs: std.ArrayListUnmanaged(IR.Linking.Reloc.Entry) = .{},
types:... | src/Wat/Codegen.zig |
const std = @import("std");
const gk = @import("../gamekit.zig");
const math = gk.math;
const rk = gk.renderkit;
const renderer = rk.renderer;
const fs = gk.utils.fs;
/// default params for the sprite shader. Translates the Mat32 into 2 arrays of f32 for the shader uniform slot.
pub const VertexParams = extern struct ... | gamekit/graphics/shader.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");
const Pkg = std.build.Pkg;
pub fn build(b: *std.build.Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions... | build.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
const Cave = struct {
next: [16]u16,
lower: u16,
max: u16,
alloc: std.mem.Allocator,
const START = 1;
const END = 2;
pub fn init(alloc: std.mem.Allocator, inp: []const u8) !*Cave {
var cave = try alloc.create(Cave);
... | 2021/12/aoc.zig |
const std = @import("std");
const TypeId = @import("builtin").TypeId;
fn is_signed(comptime N: type) bool {
switch (@typeInfo(N)) {
TypeId.Int => |int| {
return int.is_signed;
},
else => {
@compileError("Is_signed is only available on integer types. Found `" ++ @type... | zig/week1/parse.zig |
const std = @import("std");
const math = @import("math.zig");
pub fn merge(a: math.sphereBound, b: math.sphereBound) math.sphereBound {
const dist: f32 = math.Vec3.norm(a.pos - b.pos);
if (dist + a.r <= b.r)
return b;
if (dist + b.r <= a.r)
return a;
const r: f32 = (a.r + b.r + dist) /... | src/math/sphere_bound.zig |
const c = @cImport({
@cInclude("aes.h");
@cInclude("zip.h");
});
const std = @import("std");
const ascii = std.ascii;
const base64 = std.base64;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const log = std.log;
const math = std.math;
const mem = std.mem;
const process = st... | src/main.zig |
// How input is expected to work:
//
// A window implementation maps physical keys through to a bitset of virtual keys that the
// engine can understand. This occurs every frame. Next, these virtual keys are matched against
// the existing movement state of the engine and mapped to specific movement and rotation
// ac... | src/input.zig |
const std = @import("std");
const testing = std.testing;
const input_file = "input05.txt";
const Seat = struct {
row: u32,
column: u32,
fn fromDescription(str: []const u8) !Seat {
if (str.len != 10) return error.WrongLength;
const row_desc = str[0..7];
const column_desc = str[7..1... | src/05_2.zig |
const std = @import("std");
var a: *std.mem.Allocator = undefined;
const stdout = std.io.getStdOut().writer(); //prepare stdout to write in
// Problem-specific
const ROW_BITSIZE: u8 = 7;
const COLUMN_BITSIZE: u8 = 3;
test "aoc input 0" {
// FBFBBFFRLR: row 44, col 5, id 357
const t = "FBFBBFFRLR";
var b ... | day-05/part-1/lelithium.zig |
pub const HealthComp = @import("ComponentData/HealthComp.zig").HealthComp;
pub const InputComp = @import("ComponentData/InputComp.zig").InputComp;
pub const MovementComp = @import("ComponentData/MovementComp.zig").MovementComp;
pub const SceneComp = @import("ComponentData/SceneComp.zig").SceneComp;
pub const TransformC... | src/game/ComponentData.zig |
const std = @import("std");
const Arena = std.heap.ArenaAllocator;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
const yeti = @import("yeti");
const initCodebase = yeti.initCodebase;
const tokenize = yeti.tokenize;
const parse... | src/tests/test_return_type_inference.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const command = @import("./command.zig");
const ppack = @import("./parser.zig");
const Parser = ppack.Parser;
const ParseResult = ppack.ParseResult;
const iterators = @import("./iterators.zig");
const expect = std.testing.expect;
const alloc = std.testi... | src/tests.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn targetTriple(allocator: *Allocator, target: std.Target) ![]u8 {
const llvm_arch = switch (target.cpu.arch) {
.arm => "arm",
.armeb => "armeb",
.aarch64 => "aarch64",
.aarch64_be => "aarch64_be",
.aarch64... | src/codegen/llvm.zig |
const std = @import("std");
const c = @import("c.zig");
const shaderc = @import("shaderc.zig");
const Scene = @import("scene.zig").Scene;
pub const AsyncShaderc = struct {
const Self = @This();
alloc: *std.mem.Allocator,
mutex: std.Thread.Mutex,
thread: std.Thread,
cancelled: bool,
device: ... | src/async_shaderc.zig |
const os = @import("root").os;
const Bitset = os.lib.bitset.Bitset;
const range = os.lib.range.range;
const assert = @import("std").debug.assert;
const paging = os.memory.paging;
const page_size = os.platform.paging.page_sizes[0];
// O(1) worst case alloc() and free() buddy allocator I came up with (idk if anyone h... | src/lib/buddy.zig |
const zgt = @import("zgt");
const std = @import("std");
const defaultcmd = "slock";
const defaulttime = "3m";
const shell = "/bin/sh";
const State = struct {
cmd: zgt.StringDataWrapper = zgt.StringDataWrapper.of(defaultcmd),
time: zgt.StringDataWrapper = zgt.StringDataWrapper.of(defaulttime),
};
var state: Sta... | src/main.zig |
const gpio = @import("gpio.zig");
const rs_pin = 8;
const en_pin = 9;
const data_pins = [4]comptime_int{ 4, 5, 6, 7 };
const cols = 16;
const rows = 2;
const Control = struct {
const clear_display: u8 = 0x01;
const return_home: u8 = 0x02;
const entry_mode_set: u8 = 0x04;
const display_control: u8 = 0... | src/liquid_crystal.zig |
const std = @import("std");
const tcache = @import("texturecache.zig");
const slides = @import("slides.zig");
const upaya = @import("upaya");
const my_fonts = @import("myscalingfonts.zig");
const markdownlineparser = @import("markdownlineparser.zig");
usingnamespace upaya.imgui;
usingnamespace slides;
usingnamespace m... | src/sliderenderer.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const assert = std.debug.assert;
const testing = std.testing;
const leb = std.leb;
const mem = std.mem;
const wasm = std.wasm;
const Module = @import("../Module.zig");
const Decl = Module.Decl;
const ir = @import("../ir.z... | src/codegen/wasm.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
const fmtSliceHexLower = std.fmt.fmtSliceHexLower;
const Game = struct {
d1: []u8,
d2: []u8,
alloc: std.mem.Allocator,
debug: bool,
pub fn init(alloc: std.mem.Allocator, in: [][]const u8) !*Game {
var self = try alloc.create(... | 2020/22/aoc.zig |
const QuerySet = @import("QuerySet.zig");
const RenderPassColorAttachment = @import("structs.zig").RenderPassColorAttachment;
const RenderPassDepthStencilAttachment = @import("structs.zig").RenderPassDepthStencilAttachment;
const RenderPassTimestampWrite = @import("structs.zig").RenderPassTimestampWrite;
const RenderPi... | gpu/src/RenderPassEncoder.zig |
const std = @import("std");
//--------------------------------------------------------------------------------------------------
pub fn part1() anyerror!void
{
const file = std.fs.cwd().openFile("data/day01_input.txt", .{}) catch |err| label:
{
std.debug.print("unable to open file: {e}\n", .{err});
... | src/day01.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const assert = std.debug.assert;
pub const main = tools.defaultMain("2021/day23.txt", run);
// positions:
//#############
//... | 2021/day23.zig |
const std = @import("std");
const imgui = @import("imgui");
const gk = @import("../gamekit.zig");
const gfx = gk.gfx;
const rk = @import("renderkit");
pub const Renderer = struct {
font_texture: gfx.Texture,
vert_buffer_size: c_long,
index_buffer_size: c_long,
bindings: rk.BufferBindings,
const fo... | gamekit/imgui/renderer.zig |
const std = @import("std");
const math = std.math;
const sin = @import("sin.zig");
const cos = @import("cos.zig");
const trig = @import("trig.zig");
const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
pub fn __sincosh(x: f16, r_sin: *f16, r_cos: *f16) callconv(.C) v... | lib/compiler_rt/sincos.zig |
const std = @import("std");
const time = std.os.time;
const mem = std.mem;
const AtomicInt = std.atomic.Int;
const Xoroshiro128 = std.rand.Xoroshiro128;
pub const OidError = error {
InvalidOid,
};
pub const Oid = packed struct {
const Size = @sizeOf(u32) * 3;
// data race!
var prng: ?Xoroshiro128 =... | src/oids.zig |
const std = @import("std");
const link = @import("link.zig");
const Module = @import("Module.zig");
const Allocator = std.mem.Allocator;
const zir = @import("zir.zig");
const Package = @import("Package.zig");
test "self-hosted" {
var ctx: TestContext = undefined;
try ctx.init();
defer ctx.deinit();
tr... | src-self-hosted/test.zig |
const std = @import("std");
const expect = std.testing.expect;
// TODO: validate this matches the schema
pub const Smithy = struct {
version: []const u8,
metadata: ModelMetadata,
shapes: []ShapeInfo,
allocator: std.mem.Allocator,
const Self = @This();
pub fn init(allocator: std.mem.Allocator, ... | smithy/src/smithy.zig |
const std = @import("std");
const Arena = std.heap.ArenaAllocator;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
const yeti = @import("yeti");
const initCodebase = yeti.initCodebase;
const tokenize = yeti.tokenize;
const parse = yeti.parse;
const analyzeSemanti... | src/tests/test_foreign_export.zig |
pub const WM_DEVICECHANGE = @as(u32, 537);
pub const BSM_VXDS = @as(u32, 1);
pub const BSM_NETDRIVER = @as(u32, 2);
pub const BSM_INSTALLABLEDRIVERS = @as(u32, 4);
pub const OFN_SHAREFALLTHROUGH = @as(u32, 2);
pub const OFN_SHARENOWARN = @as(u32, 1);
pub const OFN_SHAREWARN = @as(u32, 0);
pub const CDM_FIRST = @as(u32,... | deps/zigwin32/win32/ui/windows_and_messaging.zig |
const __fixtfsi = @import("fixtfsi.zig").__fixtfsi;
const std = @import("std");
const math = std.math;
const testing = std.testing;
const warn = std.debug.warn;
fn test__fixtfsi(a: f128, expected: i32) !void {
const x = __fixtfsi(a);
//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u12... | lib/std/special/compiler_rt/fixtfsi_test.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
test "direction" {
const TC = struct { c: u8, dx: i64, dy: i64 };
const tests = [_]TC{
TC{ .c = 'N', .dx = 0, .dy = -1 },
TC{ .c = 'S', .dx = 0, .dy = 1 },
TC{ .c = 'E', .dx = 1, .dy = 0 },
TC{ .c = 'W', .dx = -1, .... | 2020/12/aoc.zig |
const std = @import("std");
fn tagKind(tree: *std.zig.ast.Tree, node: *std.zig.ast.Node) u8 {
const NTag = std.zig.ast.Node.Tag;
return switch (node.tag) {
NTag.FnProto => 'f',
NTag.VarDecl => {
const var_decl_node = node.cast(std.zig.ast.Node.VarDecl).?;
if (var_decl_no... | src/main.zig |
const std = @import("std");
const testing = std.testing;
const bufwriter = @import("bufwriter.zig");
// Takes 0-indexed idx into buffer, and returns the corresponding 1-indexed line and col of said character
// Intended to be used in error-situations
// Returns line and col=0 in in case of invalid input
pub fn idxToLi... | libdaya/src/utils.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const assert = std.debug.assert;
pub const main = tools.defaultMain("2021/day25.txt", run);
pub fn run(input: []const u8, gp... | 2021/day25.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const builtin = @import("builtin");
const zfetch = @import("zfetch");
pub fn requestGet(allocator: Allocator, url: []const u8) ![]const u8 {
var headers = zfetch.Headers.init(allocator);
defer headers.deinit();
try headers.appendValue("Accep... | src/utils.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 PriorityQueue = std.PriorityQueue;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
// cons... | src/day15.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const ModelData = @import("../ModelFiles/ModelFiles.zig").ModelData;
const VertexAttributeType = ModelData.VertexAttributeType;
const Buffer = @import("../WindowGraphicsInput/WindowGraphicsInput.zig").Buffer;
const VertexMeta = @i... | src/RTRenderEngine/MeshRenderer.zig |
const std = @import("std");
pub const simd = @import("utils/simd.zig");
pub fn readStruct(comptime T: type, instance: *T, reader: anytype, comptime expected_size: usize) !void {
const fields = std.meta.fields(T);
var buf: [expected_size]u8 = undefined;
const read = try reader.readAll(&buf);
if (read ... | src/utils.zig |
const std = @import("std");
const mem = @import("../std.zig").mem;
const testing = std.testing;
const debug = std.debug;
pub fn ArrayList(comptime T: type) type {
return ArrayListCustomAllocator(mem.Allocator, T);
}
pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
return AlignedArrayListCust... | src/array_list.zig |
const std = @import("std");
const Camera = @import("Camera.zig");
const Material = @import("Material.zig");
const Mesh = @import("Mesh.zig");
const zp = @import("../../zplay.zig");
const drawcall = zp.graphics.common.drawcall;
const VertexArray = zp.graphics.common.VertexArray;
const alg = zp.deps.alg;
const Vec3 = alg... | src/graphics/3d/Renderer.zig |
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const exe = b.addExecutable("zua", "src/zua.zig");
exe.setBuildMode(mode);
exe.install();
const run_cmd = exe.run();
run_cmd.step.dependOn(b.getInstallStep(... | build.zig |
usingnamespace @import("root").preamble;
const heap = os.memory.pmm.phys_heap;
const platform = os.platform;
const PagingContext = platform.paging.PagingContext;
const address_space = os.kernel.process.address_space;
const MemoryObjectRegionVtab: address_space.MemoryRegionVtable = .{
.pageFault = MemoryObjectReg... | subprojects/flork/src/kernel/process/memory_object.zig |
const std = @import("std");
const c = std.c;
const json = std.json;
const ldns = @import("zdns");
const testing = std.testing;
pub fn rrFieldNames(type_: ldns.rr_type, ctx: anytype) ![]const []const u8 {
const str = []const u8;
return switch (type_) {
.A, .AAAA => &[_]str{"ip"},
.AFSDB => &[_]s... | src/zone2json.zig |
const global =
\\ let gamma: f32 = 2.2;
\\ let pi: f32 = 3.1415926;
\\
\\ fn saturate(x: f32) -> f32 {
\\ return clamp(x, 0.0, 1.0);
\\ }
\\
\\ fn radicalInverseVdc(in_bits: u32) -> f32 {
\\ var bits = (in_bits << 16u) | (in_bits >> 16u);
\\ bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu... | samples/physically_based_rendering_wgpu/src/physically_based_rendering_wgsl.zig |
const std = @import("std");
const os = @import("os");
const ArrayList = std.ArrayList;
const utils = @import("utils.zig");
const c = @import("c.zig");
const Vec3 = @import("vec.zig").Vec3;
const Ray = @import("ray.zig").Ray;
const Sphere = @import("sphere.zig").Sphere;
const HitRecord = @import("sphere.zig").HitReco... | src/main.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(allocator: std.mem.Allocator, stdout: anytype) anyerror!void {
{
var input_ = try input.readFile("inputs/day3");
defer input_.deinit();
const result = try part1(&input_);
try stdout.print("3a: {}\n", .{ res... | src/day3.zig |
const expect = @import("std").testing.expect;
pub const GLFWmonitor = opaque {};
pub const GLFWwindow = opaque {};
pub const GLFWcursor = opaque {};
pub const GLFWvidmode = extern struct {
width: c_int,
height: c_int,
redBits: c_int,
greenBits: c_int,
blueBits: c_int,
refreshRate: c_in... | pkgs/glfw/src/main.zig |
const std = @import( "std" );
const min = std.math.min;
const pow = std.math.pow;
const inf = std.math.inf;
const isNan = std.math.isNan;
usingnamespace @import( "util.zig" );
usingnamespace @import( "core.zig" );
usingnamespace @import( "glz.zig" );
usingnamespace @import( "gtkz.zig" );
pub fn AxisUpdatingHandler( co... | src/core/support.zig |
const std = @import("std");
pub fn main() anyerror!void {
std.log.info("All your codebase are belong to us.", .{});
}
const expect = @import("std").testing.expect;
const assert = @import("std").debug.assert;
const mem = @import("std").mem;
// array literal
const message = [_]u8{ 'h', 'e', 'l', 'l', 'o' };
// get... | arrays/src/main.zig |
const utils = @import("utils.zig");
const x86 = @import("x86.zig");
const platform = @import("platform.zig");
const pmem = @import("pmem.zig");
const layout = @import("layout.zig");
const assert = @import("std").debug.assert;
const serial = @import("../../debug/serial.zig");
const PageEntry = usize;
const PageMapLeve... | src/kernel/arch/x86/vmem.zig |
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day05.txt");
const Point2 = struct {
x: i16,
y: i16,
};
const VentMap = struct {
map: std.AutoHashMap(Point2, u32) = undefined,
pub fn init(allocator: std.mem.Allocator) @This() {
var map = std.Auto... | src/day05.zig |
const std = @import("std");
const Builder = @import("std").build.Builder;
pub fn build(b: *Builder) !void {
const target = try std.zig.CrossTarget.parse(.{
.arch_os_abi = "native-native-msvc",
});
const mode = b.standardReleaseOptions();
const bindings = b.addStaticLibrary("wwiseBindings", nu... | build.zig |
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const Allocator = mem.Allocator;
const Yaml = @import("yaml").Yaml;
const gpa = testing.allocator;
fn loadFromFile(file_path: []const u8) !Yaml {
const file = try std.fs.cwd().openFile(file_path, .{});
defer file.close();
cons... | test/test.zig |
const std = @import("std");
const errors = @import("errors.zig");
const mem = std.mem;
const math = std.math;
const testing = std.testing;
const unicode = std.unicode;
const LexerErrors = error{TokenizerError};
pub fn isIdentifier(c: u32) bool {
return switch (c) {
'a'...'z',
'A'...'Z',
'_',... | src/lexer.zig |
const std = @import("std");
const use_test_input = false;
const filename = if (use_test_input) "day-8_test-input" else "day-8_real-input";
const line_count = if (use_test_input) 10 else 200;
pub fn main() !void {
std.debug.print("--- Day 8 ---\n", .{});
var file = try std.fs.cwd().openFile(filename, .{});
... | day-8.zig |
const std = @import("std");
const testing = std.testing;
const case_fold_map = @import("../ziglyph.zig").case_fold_map;
const props = @import("../ziglyph.zig").derived_core_properties;
const cats = @import("../ziglyph.zig").derived_general_category;
const lower_map = @import("../ziglyph.zig").lower_map;
const title_ma... | .gyro/ziglyph-jecolon-github.com-c37d93b6/pkg/src/category/letter.zig |
const Vec2 = @import("vec2.zig").Vec2;
const Rect = @import("rect.zig").Rect;
const RectI = @import("rect.zig").RectI;
pub const Quad = struct {
img_w: f32,
img_h: f32,
positions: [4]Vec2 = undefined,
uvs: [4]Vec2 = undefined,
pub fn init(x: f32, y: f32, width: f32, height: f32, img_w: f32, img_h:... | gamekit/math/quad.zig |
// TODO: Updated recently.
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
/// Returns e raised to the power of x, minus 1 (e^x - 1). This is more accurate than exp(e, x) - 1
/// when x is near 0.
///
/// Special Cases:
/// - expm1(+in... | lib/std/math/expm1.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const math = std.math;
const testing = std.testing;
const AuthenticationError = std.crypto.errors.AuthenticationError;
/// ISAPv2 is an authenticated encryption system hardened against side channels and fault attacks.
/// https://csrc.nist.gov/C... | lib/std/crypto/isap.zig |
const Mir = @This();
const std = @import("std");
/// A struct of array that represents each individual wasm
instructions: std.MultiArrayList(Inst).Slice,
/// A slice of indexes where the meaning of the data is determined by the
/// `Inst.Tag` value.
extra: []const u32,
pub const Inst = struct {
/// The opcode t... | src/arch/wasm/Mir.zig |
const std = @import("std");
const assert = std.debug.assert;
const glfw = @import("glfw");
const c = @import("c.zig").c;
// #include "SampleUtils.h"
// #include "common/Assert.h"
// #include "common/Log.h"
// #include "common/Platform.h"
// #include "common/SystemUtils.h"
// #include "utils/BackendBinding.h"
// #incl... | gpu/src/dawn/sample_utils.zig |
const std = @import("std");
const mem = std.mem;
const ascii = std.ascii;
const fmt = std.fmt;
const warn = std.debug.warn;
const svd = @import("svd.zig");
var line_buffer: [1024 * 1024]u8 = undefined;
const register_def =
\\pub fn Register(comptime R: type) type {
\\ return RegisterRW(R, R);
\\}
... | src/main.zig |
const builtin = @import("builtin");
const fmath = @import("index.zig");
pub fn floor(x: var) -> @typeOf(x) {
const T = @typeOf(x);
switch (T) {
f32 => @inlineCall(floor32, x),
f64 => @inlineCall(floor64, x),
else => @compileError("floor not implemented for " ++ @typeName(T)),
}
}
f... | src/floor.zig |
const fmath = @import("index.zig");
pub fn atan2(comptime T: type, x: T, y: T) -> T {
switch (T) {
f32 => @inlineCall(atan2f, x, y),
f64 => @inlineCall(atan2d, x, y),
else => @compileError("atan2 not implemented for " ++ @typeName(T)),
}
}
fn atan2f(y: f32, x: f32) -> f32 {
const p... | src/atan2.zig |
const std = @import("std");
const cast = std.meta.cast;
const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.
// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xfffff... | fiat-zig/src/p224_32.zig |
const std = @import("std");
const assert = std.debug.assert;
const allocator = std.testing.allocator;
pub const Board = struct {
dist: Distance,
map: std.AutoHashMap(i32, u32),
md: u32,
mx: i32,
my: i32,
pub const Distance = enum {
Manhattan,
Travelled,
};
pub fn init... | 2019/p03/board.zig |
const builtin = @import("builtin");
const std = @import("std");
const Mode = builtin.Mode;
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const randomizer = b.addExecutable("randomizer", "src/main.zig");
randomizer.setBuildMode(mode);
rand... | build.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const mem = std.mem;
const testing = std.testing;
const warn = std.debug.warn;
const StdInStream = io.InStream(fs.File.ReadError);
const StdOutStream = io.OutStream(fs.File.WriteError);
const StdErrStream = io.OutStream(fs.File.WriteError);
/// Defin... | src/flags/flags.zig |
const std = @import("std");
const mem = std.mem;
const FLIR = @import("./FLIR.zig");
const print = std.debug.print;
const CFO = @import("./CFO.zig");
const IPReg = CFO.IPReg;
const VMathOp = CFO.VMathOp;
const Inst = FLIR.Inst;
const uv = FLIR.uv;
fn regmovmc(cfo: *CFO, dst: IPReg, src: Inst) !void {
switch (src.m... | src/codegen.zig |
const std = @import("std");
const build_options = @import("build_options");
const debugDisp = build_options.debugDisp;
const debugLoop = build_options.debugLoop;
const debugStages = build_options.debugStages;
const debugCmd = build_options.debugCmd;
const debugStart = build_options.debugStart;
//const debugStart = tru... | filters.zig |
const std = @import("std");
const Builder = std.build.Builder;
pub fn createPackage(comptime root: []const u8) std.build.Pkg {
return std.build.Pkg{
.name = "lola",
.path = root ++ "/src/library/main.zig",
.dependencies = &[_]std.build.Pkg{
std.build.Pkg{
.name =... | build.zig |
pub const DMO_E_INVALIDSTREAMINDEX = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147220991));
pub const DMO_E_INVALIDTYPE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147220990));
pub const DMO_E_TYPE_NOT_SET = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147220989));
pub const DMO_E_NOTACCEP... | win32/media/dx_media_objects.zig |
const std = @import("std");
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = &arena.allocator;
var args = std.process.args();
_ = args.skip();
while (args.next(allocator)) |arg| {
const path = arg catch "in... | day-17-zig/day_17.zig |
pub fn build(b: *std.build.Builder) !void {
const display_option = b.option(bool, "display", "graphics display for qemu") orelse false;
const build_exe = b.addExecutable("main", "main.zig");
_ = buildExeDetails: {
build_exe.emit_asm = true;
build_exe.install();
build_exe.setBuildMode... | build.zig |
const std = @import("std");
const x86 = @import("x86");
const Token = union(enum) {
op: u8,
int: i64,
};
const TokenIterator = struct {
toks: std.mem.TokenIterator,
pub fn init(expr: []const u8) TokenIterator {
return .{ .toks = std.mem.tokenize(expr, " \t\n") };
}
pub fn next(self: ... | src/main.zig |
const std = @import("std");
const platform = @import("platform.zig");
const Allocator = std.mem.Allocator;
const ComptimeBitmap = @import("lib/bitmap.zig").ComptimeBitmap;
pub const PidBitmap = ComptimeBitmap(u128);
pub const Entrypoint = usize;
pub const STACK_SIZE: u64 = (4096 * 1024) / @sizeOf(u64); // 4KB pages.
v... | src/kernel/task.zig |
const std = @import("std");
const Entity = @import("./Entity.zig");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Bitset = std.bit_set.StaticBitSet(MAX_ENTITIES);
// testing
const Entities = @import("./Entities.zig");
const benchmark = @import("benchmark");
const MAX_ENTITIES = @import("... | src/components.zig |