code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const stdx = @import("stdx");
const build_options = @import("build_options");
const Backend = build_options.GraphicsBackend;
const window_sdl = @import("window_sdl.zig");
const WindowSdl = window_sdl.Window;
const canvas = @import("window_canvas.zig");
const log = stdx.log.scoped(.window);
... | platform/window.zig |
usingnamespace @import("../engine/engine.zig");
const Literal = @import("../parser/literal.zig").Literal;
const LiteralValue = @import("../parser/literal.zig").LiteralValue;
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
pub fn MapToContext(comptime Payload: type, comptime Value: type, ... | src/combn/combinator/mapto.zig |
const std = @import("std");
const fs = std.fs;
const Allocator = std.mem.Allocator;
const Builder = std.build.Builder;
var root: []const u8 = undefined;
var allocator: *Allocator = undefined;
// set to true if we want tracy to record frame/function times, false if we just want stubbed
var enable_tracy = true;
pub f... | nativemap/build.zig |
const builtin = @import("builtin");
const clap = @import("clap");
const std = @import("std");
const util = @import("util");
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const mem = std.mem;
const process = std.process;
const Executables = @This();
arena: heap.ArenaAllocator,
load: util.Path = util.... | src/gui/Executables.zig |
pub const TPMVSC_DEFAULT_ADMIN_ALGORITHM_ID = @as(u32, 130);
//--------------------------------------------------------------------------------
// Section: Types (9)
//--------------------------------------------------------------------------------
const CLSID_TpmVirtualSmartCardManager_Value = @import("../zig.zig").G... | win32/security/tpm.zig |
pub const CGD_DEFAULT = @as(u32, 0);
pub const CGD_UNKNOWN_PROPERTY = @as(u32, 0);
pub const CGD_STRING_PROPERTY = @as(u32, 1);
pub const CGD_DATE_PROPERTY = @as(u32, 2);
pub const CGD_BINARY_PROPERTY = @as(u32, 4);
pub const CGD_ARRAY_NODE = @as(u32, 8);
pub const CLSID_ContactAggregationManager = Guid.initString("96c... | win32/system/contacts.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const file = @embedFile("../input.txt");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const output = part1(&gpa.allocator, file);
print("total: {}\n", ... | 2020/day18/zig/day18.zig |
const builtin = @import("builtin");
const std = @import("std");
const json = std.json;
const mem = std.mem;
const meta = std.meta;
const warn = std.debug.warn;
/// encode takes a value and returns json.Value that can be marshalled to json
/// object. This limits on which objects can be marshalled and also supports
//... | src/lsp/protocol/encoding.zig |
const std = @import("std");
const IR = @import("../IR.zig");
pub const External = std.wasm.ExternalKind;
inline fn nextExternal(e: External) External {
if (e == .global) return e;
return @intToEnum(External, @enumToInt(e) + 1);
}
pub const Import = struct {
m: *const IR.Module,
state: External = .func... | src/IR/iters.zig |
const std = @import("std");
const windows = @import("windows.zig");
const dxgi = @import("dxgi.zig");
const d3d = @import("d3dcommon.zig");
const UINT = windows.UINT;
const IUnknown = windows.IUnknown;
const HRESULT = windows.HRESULT;
const GUID = windows.GUID;
const LUID = windows.LUID;
const WINAPI = windows.WINAPI;
... | modules/platform/vendored/zwin32/src/d3d12.zig |
const mustache = @import("mustache.zig");
const Delimiters = mustache.Delimiters;
const builtin = @import("builtin");
pub const comptime_tests_enabled = false;
/// General options for processing a mustache template
pub const TemplateOptions = struct {
/// Template source options
source: TemplateSource,
... | src/options.zig |
const std = @import("std");
pub const ArgParseOptions = struct {
allocator: *std.mem.Allocator = std.heap.c_allocator,
};
const ArgParseError = error{
AllocatorRequired,
InvalidArgs,
MissingField,
UnexpectedArgument,
UnexpectedField,
};
pub fn parse(comptime T: type, options: ArgParseOptions)... | src/argparse.zig |
const std = @import("std");
const argsParser = @import("args.zig");
pub fn main() !u8 {
var argsAllocator = std.heap.page_allocator;
const options = argsParser.parseWithVerbForCurrentProcess(
struct {
// this declares long option that can come before or after verb
output: ?[]co... | demo_verb.zig |
const cc = @cImport(@cInclude("GLFW/glfw3.h"));
/// The unknown key
pub const unknown = cc.GLFW_KEY_UNKNOWN;
/// Printable keys
pub const space = cc.GLFW_KEY_SPACE;
pub const apostrophe = cc.GLFW_KEY_APOSTROPHE;
pub const comma = cc.GLFW_KEY_COMMA;
pub const minus = cc.GLFW_KEY_MINUS;
pub const period = cc.GLFW_KEY_... | glfw/src/key.zig |
const std = @import("std");
const Rational = std.math.big.Rational;
const Allocator = std.mem.Allocator;
const Real = @import("Real.zig").Real;
const IntermediateRepresentation = @import("ir.zig");
// TODO: rhm will have approximate mode, which runs faster at the expense of using floats instead of Reals
// TODO: resol... | src/vm.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/day16");
defer input_.deinit();
const result = try part1(allocator, &input_);
try stdout.print("16a: ... | src/day16.zig |
const std = @import("std");
const math = std.math;
const Allocator = std.mem.Allocator;
const PixelFormat = @import("pixel_format.zig").PixelFormat;
const TypeInfo = std.builtin.TypeInfo;
inline fn toColorInt(comptime T: type, value: f32) T {
return math.max(math.minInt(T), math.min(math.maxInt(T), @floatToInt(T, ... | src/color.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/day10.txt", run);
pub fn run(input: []const u8, gp... | 2021/day10.zig |
const std = @import("std");
const nvg = @import("nvg.zig");
const gfx = @import("gfx.zig");
const Game = @This();
const GameState = enum(u1) {
title,
play,
};
const BuildingColor = enum(u2) {
grey,
teal,
red,
};
const Building = struct {
const Hole = struct {
x: f32,
y: f32,
... | src/game.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
cons... | cpp/build.zig |
const Driver = struct {
transport: virtio.Driver,
inflight: u32 = 0,
pitch: u32 = 0,
width: u32 = 0,
height: u32 = 0,
// Initialize the virtio transport, but don't change modes
pub fn init(pciaddr: pci.Addr) !Driver {
var v = try virtio.Driver.init(pciaddr, 0, 0);
var d: Driver = .{ .transport = ... | src/drivers/virtio/virtio-gpu.zig |
const std = @import("std");
const zp = @import("zplay");
const VertexArray = zp.graphics.common.VertexArray;
const Texture2D = zp.graphics.texture.Texture2D;
const Camera = zp.graphics.@"3d".Camera;
const Material = zp.graphics.@"3d".Material;
const Renderer = zp.graphics.@"3d".Renderer;
const SimpleRenderer = zp.graph... | examples/single_triangle.zig |
const assert = @import("std").debug.assert;
/// C11 Standard Annex D
pub fn isC11IdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
// 1
0x00A8,
0x00AA,
0x00AD,
0x00AF,
0x00B2...0x00B5,
0x00B7...0x00BA,
0x00BC...0... | src/CharInfo.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const TypeInfo = std.builtin.TypeInfo;
const TypeId = std.builtin.TypeId;
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
test "type info: integer, floating point type info" {
try te... | test/behavior/type_info.zig |
const builtin = @import("builtin");
const std = @import("std.zig");
const mem = std.mem;
const os = std.os;
const assert = std.debug.assert;
const testing = std.testing;
const elf = std.elf;
const windows = std.os.windows;
const maxInt = std.math.maxInt;
pub const DynLib = switch (builtin.os) {
.linux => LinuxDyn... | lib/std/dynamic_library.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Risks = std.AutoHashMap(aoc.Coord, u8);
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var risks1 = Risks.init(problem.allocator);
defer risks1.deinit();
var end_coord1 = aoc.Coord.init(.{0, 0});
while (problem.line()) |line| {
... | src/main/zig/2021/day15.zig |
const std = @import("../std.zig");
const __rem_pio2_large = @import("__rem_pio2_large.zig").__rem_pio2_large;
const math = std.math;
const toint = 1.5 / math.floatEps(f64);
// pi/4
const pio4 = 0x1.921fb6p-1;
// invpio2: 53 bits of 2/pi
const invpio2 = 6.36619772367581382433e-01; // 0x3FE45F30, 0x6DC9C883
// pio2_1:... | lib/std/math/__rem_pio2f.zig |
const std = @import("std");
const c = @import("c.zig").c;
const Window = @import("Window.zig");
const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
const Action = @import("action.zig").Action;
const GamepadAxis = @import("gamepad_axis.zig").GamepadAxis;
const GamepadButton = @i... | glfw/src/Joystick.zig |
const SDL = @import("sdl.zig");
const c = @import("../binding/sdl.zig");
const std = @import("std");
pub const Context = struct {
ptr: c.SDL_GLContext,
};
pub fn createContext(window: SDL.Window) !Context {
return Context{
.ptr = c.SDL_GL_CreateContext(window.ptr) orelse return SDL.makeError(),
};... | src/wrapper/gl.zig |
const std = @import("std");
const vk = @import("vulkan");
const GraphicsContext = @import("graphics_context.zig").GraphicsContext;
const Allocator = std.mem.Allocator;
pub const Swapchain = struct {
pub const PresentState = enum {
optimal,
suboptimal,
};
gc: *const GraphicsContext,
all... | examples/swapchain.zig |
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
pub fn Pkg(pkgdir: []const u8) type {
return struct {
var ran_git = false;
pub fn link(exe: *LibExeObjStep, system_lib: bool) void {
if (system_lib) {
exe.linkSy... | lib.zig |
pub const WINML_TENSOR_DIMENSION_COUNT_MAX = @as(u32, 4);
//--------------------------------------------------------------------------------
// Section: Types (47)
//--------------------------------------------------------------------------------
pub const WINML_TENSOR_DATA_TYPE = enum(i32) {
UNDEFINED = 0,
FL... | win32/ai/machine_learning/win_ml.zig |
pub const CM_PROB_NOT_CONFIGURED = @as(u32, 1);
pub const CM_PROB_DEVLOADER_FAILED = @as(u32, 2);
pub const CM_PROB_OUT_OF_MEMORY = @as(u32, 3);
pub const CM_PROB_ENTRY_IS_WRONG_TYPE = @as(u32, 4);
pub const CM_PROB_LACKED_ARBITRATOR = @as(u32, 5);
pub const CM_PROB_BOOT_CONFIG_CONFLICT = @as(u32, 6);
pub const CM_PROB... | win32/devices/device_and_driver_installation.zig |
pub const APPEND = @import("./strings/append.zig").APPEND;
pub const BITCOUNT = @import("./strings/bitcount.zig").BITCOUNT;
// pub const BITFIELD = @import("./strings/bitfield.zig").BITFIELD;
pub const BITOP = @import("./strings/bitop.zig").BITOP;
pub const BITPOS = @import("./strings/bitpos.zig").BITPOS;
pub const DEC... | src/commands/strings.zig |
const std = @import("std");
const mem = std.mem;
const art = @import("art.zig");
const Art = art.Art;
const tal = &std.testing.allocator;
const warn = std.log.warn;
// set to test against many value types (increases test run time)
const test_all_ValueTypes = false;
const ValueTypes = if (test_all_ValueTypes) [_]type{... | src/test_art.zig |
const std = @import("std");
// dross-zig
// ------------------------------------------------
// -----------------------------------------
// - Math -
// -----------------------------------------
pub const Math = struct {
/// Returns the value that is the `percentage` of the distance
/// betwe... | src/math/math.zig |
//--------------------------------------------------------------------------------
// Section: Types (13)
//--------------------------------------------------------------------------------
const CLSID_WSCProductList_Value = @import("../zig.zig").Guid.initString("17072f7b-9abe-4a74-a261-1eb76b55107a");
pub const CLSID_... | win32/system/security_center.zig |
pub const Key = enum {
Key_a,
Key_b,
Key_c,
Key_d,
Key_e,
Key_f,
Key_g,
Key_h,
Key_i,
Key_j,
Key_k,
Key_l,
Key_m,
Key_n,
Key_o,
Key_p,
Key_q,
Key_r,
Key_s,
Key_t,
Key_u,
Key_v,
Key_w,
Key_x,
Key_y,
Key_z,
Key_A,... | libs/georgios/keys.zig |
pub const EPERM = 1; // Operation not permitted
pub const ENOENT = 2; // No such file or directory
pub const ESRCH = 3; // No such process
pub const EINTR = 4; // Interrupted system call
pub const EIO = 5; // Input/output error
pub const ENXIO = 6; // Device not configured
pub const E2BIG = 7; // Argument list too long... | std/os/freebsd/errno.zig |
const std = @import("std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
pub const Error = error{
InvalidCharacter,
InvalidPadding,
NoSpaceLeft,
};
/// Base64 codecs
pub const Codecs = struct {
alphabet_chars: [64]u8,
pad_char: ?u8,
decoderWithIgnore: ... | lib/std/base64.zig |
const std = @import("std");
const c = @import("c.zig");
const main = @import("main.zig");
const cfg = @import("config.zig");
const Bitset = @import("util.zig").Bitset;
pub inline fn divceil(n: anytype, d: @TypeOf(n)) @TypeOf(n) {
return @divTrunc(n + (d - 1), d);
}
pub inline fn ATTRCMP(a: Glyph, b: Glyph) bool ... | src/st.zig |
const wlr = @import("../wlroots.zig");
const wayland = @import("wayland");
const wl = wayland.server.wl;
pub const Cursor = extern struct {
pub const State = opaque {};
state: *State,
x: f64,
y: f64,
events: extern struct {
motion: wl.Signal(*wlr.Pointer.event.Motion),
motion_abs... | src/types/cursor.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const zua = @import("zua.zig");
const Instruction = zua.opcodes.Instruction;
const Node = zua.ast.Node;
const Function = zua.object.Function;
const Constant = zua.object.Constant;
const Lexer = zua.lex.Lexer;
const Parser = zua.parse.Parser;
const max_sta... | src/compiler.zig |
const builtin = @import("builtin");
pub const IndexType: type = blk: {
if (!builtin.is_test) {
const options = @import("zmesh_options");
if (@hasDecl(options, "shape_use_32bit_indices")) {
if (options.shape_use_32bit_indices)
break :blk u32;
break :blk u16;
... | libs/zmesh/src/Shape.zig |
const std = @import("std");
const windows = @import("windows.zig");
const IUnknown = windows.IUnknown;
const BYTE = windows.BYTE;
const UINT = windows.UINT;
const UINT32 = windows.UINT32;
const UINT64 = windows.UINT64;
const WINAPI = windows.WINAPI;
const LPCWSTR = windows.LPCWSTR;
const BOOL = windows.BOOL;
const DWOR... | modules/platform/vendored/zwin32/src/xaudio2.zig |
const std = @import("std");
const builtin = @import("builtin");
const stdx = @import("stdx");
const Vec2 = stdx.math.Vec2;
const vec2 = Vec2.init;
const WasmJsBuffer = stdx.wasm.WasmJsBuffer;
const graphics = @import("../../graphics.zig");
const Image = graphics.Image;
const ImageId = graphics.ImageId;
const svg = gra... | graphics/src/backend/canvas/graphics.zig |
const std = @import("std");
const lola = @import("lola");
////
// Minimal API example:
// This example shows how to get started with the LoLa library.
// Compiles and runs the Hello-World program.
//
const example_source =
\\Print("Hello, World!");
\\
;
// This is required for the runtime library to be able ... | examples/host/minimal-host/main.zig |
const std = @import("std");
const ast = std.zig.ast;
const Token = std.zig.Token;
use @import("clang.zig");
pub const Mode = enum {
import,
translate,
};
pub const ClangErrMsg = Stage2ErrorMsg;
pub const Error = error {
OutOfMemory,
};
const Context = struct {
tree: *ast.Tree,
source_buffer: *s... | src-self-hosted/translate_c.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const nitori = @import("nitori");
const interface = nitori.interface;
//;
// start is used for initializing load routines
// init data and allocate
// TODO should statemachine retur... | src/states.zig |
pub const LBER_ERROR = @as(i32, -1);
pub const LBER_DEFAULT = @as(i32, -1);
pub const LDAP_UNICODE = @as(u32, 1);
pub const LDAP_PORT = @as(u32, 389);
pub const LDAP_SSL_PORT = @as(u32, 636);
pub const LDAP_GC_PORT = @as(u32, 3268);
pub const LDAP_SSL_GC_PORT = @as(u32, 3269);
pub const LDAP_VERSION1 = @as(u32, 1);
pub... | win32/networking/ldap.zig |
pub const SYS = enum(usize) {
restart_syscall = 0x00,
exit = 0x01,
fork = 0x02,
read = 0x03,
write = 0x04,
open = 0x05,
close = 0x06,
waitpid = 0x07,
creat = 0x08,
link = 0x09,
unlink = 0x0a,
execve = 0x0b,
chdir = 0x0c,
time = 0x0d,
mknod = 0x0e,
chmod = ... | src/linux/i386/consts.zig |
const std = @import("std");
pub const Relocation = struct {
/// Represents the type of the `Relocation`
relocation_type: RelocationType,
/// Offset of the value to rewrite relative to the relevant section's contents.
/// When `offset` is zero, its position is immediately after the id and size of the s... | src/link/Wasm/types.zig |
pub const heap = @import("./heap.zig");
pub const vm = @import("./interpreter/vm.zig");
pub const Frame = @import("./interpreter/Frame.zig");
pub const schedule = scheduler.schedule;
pub const notify = notification.notify;
const std = @import("std");
const notification = @import("./interpreter/notification.zig");
con... | src/interpreter.zig |
const c = @cImport({
@cDefine("_GNU_SOURCE",{});
@cInclude("sys/mman.h");
@cInclude("sys/stat.h");
@cInclude("fcntl.h");
@cInclude("sys/types.h");
@cInclude("unistd.h");
@cInclude("errno.h");
@cInclude("sched.h");
});
const std = @import("std");
pub fn spinUntilChange( spinPtr:*cons... | zig/src/common.zig |
const CPU = @This();
const pkg = @import("zig80.zig");
const Flags = pkg.Flags;
const Interface = pkg.Interface;
const InterruptMode = pkg.InterruptMode;
/// The extra cycle counts for the main instructions
const CYCLE_COUNTS = [256]u8 {
0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 2, 0, 0, 0, 0,... | src/CPU.zig |
const dcommon = @import("common/dcommon.zig");
pub fn halt() noreturn {
asm volatile ("msr daifset, #15");
while (true) {
asm volatile ("wfi");
}
}
pub fn transfer(entry_data: *dcommon.EntryData, uart_base: u64, adjusted_entry: u64) callconv(.Inline) noreturn {
// Check for EL2: we get
// ... | dainboot/src/arm64.zig |
const std = @import("std");
const time = std.time;
const Timer = time.Timer;
const xorfilter = @import("main.zig");
const MeasuredAllocator = @import("MeasuredAllocator.zig");
fn formatTime(writer: anytype, comptime spec: []const u8, start: u64, end: u64, division: usize) !void {
const ns = @intToFloat(f64, (end ... | src/benchmark.zig |
const macro = @import("pspmacros.zig");
comptime {
asm (macro.import_module_start("sceMpegbase", "0x00090000", "9"));
asm (macro.import_function("sceMpegbase", "0xBE45C284", "sceMpegBaseYCrCbCopyVme"));
asm (macro.import_function("sceMpegbase", "0x492B5E4B", "sceMpegBaseCscInit"));
asm (macro.import_fu... | src/psp/nids/pspmpeg.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const vsr = @import("vsr.zig");
const Header = vsr.Header;
comptime {
// message_size_max must be a multiple of sector_size for Direct I/O
assert(config.message_size_max % config.sector_siz... | src/message_pool.zig |
const std = @import("std");
const allocators = @import("limp/allocators.zig");
pub fn build(b: *std.build.Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const exe = b.addExecutable("limp", "limp/main.zig");
exe.setTarget(target);
exe.setBuildM... | build.zig |
pub use @import("wasi/core.zig");
// Based on https://github.com/CraneStation/wasi-sysroot/blob/wasi/libc-bottom-half/headers/public/wasi/core.h
// and https://github.com/CraneStation/wasmtime/blob/master/docs/WASI-api.md
pub const STDIN_FILENO = 0;
pub const STDOUT_FILENO = 1;
pub const STDERR_FILENO = 2;
pub const... | std/os/wasi.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
test "examples" {
const test0 = try aoc.Ints(aoc.talloc, i64, aoc.test0file);
defer aoc.talloc.free(test0);
const test1 = try aoc.Ints(aoc.talloc, i64, aoc.test1file);
defer aoc.talloc.free(test1);
const test2 = try aoc.Ints(aoc.talloc... | 2020/10/aoc.zig |
const std = @import("std");
pub fn initializeKernelExe(b: *std.build.Builder, target: std.zig.CrossTarget, mode: std.builtin.Mode) *std.build.LibExeObjStep {
const exe = b.addExecutable("kernel", "kernel/main.zig");
exe.setLinkerScriptPath("kernel/linker_script.ld");
exe.addAssemblyFile("kernel/initialize... | build.zig |
const std = @import("std");
const print = std.debug.print;
const getopt = @import("getopt.zig");
const zero = std.crypto.utils.secureZero;
const impl = @import("signify-format.zig");
const getpass = @import("getpass.zig");
const ExitError = error.ExitError;
var argv: [][:0]const u8 = undefined;
pub fn main() !void {... | zignify.zig |
const RuleSet = @import("./rules.zig").RuleSet;
const Rule = @import("./rules.zig").Rule;
const Attr = @import("./rules.zig").Attr;
pub const rules = RuleSet{
.rules = &[_]Rule{
Rule{
.kind = 0, // light red
.attrs = &[_]Attr{
Attr{ .kind = 1, .n = 1 }, // bright whi... | day7/src/sample_rules.zig |
pub fn CompTrie(comptime V: type) type {
const TrieNode = struct {
const Self = @This();
value: ?V = null,
children: [256]?*Self = [_]?*Self{null} ** 256,
};
return struct {
const Self = @This();
root: ?*TrieNode = null,
pub fn put(self: *Self, key: []cons... | comptrie.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Bezier Curve",
.data_size = @sizeOf(Data),
.function_definition = function_definition,
.enter_command_fn = util.surfaceEnterCommand(Data),
.exit_command_fn = util.surfaceExitCommand(Data, exitCommand),
.append_... | src/sdf/surfaces/bezier_curve.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/day06.txt");
p... | src/day06.zig |
pub const D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES = @as(u32, 4096);
pub const D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING = @as(u32, 5768);
pub const D3D12_16BIT_INDEX_STRIP_CUT_VALUE = @as(u32, 65535);
pub const D3D12_32BIT_INDEX_STRIP_CUT_VALUE = @as(u32, 4294967295);
pub const D3D12_8BIT... | win32/graphics/direct3d12.zig |
const std = @import("std");
const assert = std.debug.assert;
const fs = std.fs;
const linux = std.os.linux;
const log = std.log.scoped(.journal);
const mem = std.mem;
const Allocator = mem.Allocator;
const os = std.os;
usingnamespace @import("tigerbeetle.zig");
usingnamespace @import("state.zig");
pub const Journal =... | src/journal.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Tile = struct {
dist: u16,
tag: u8,
fn tile2char(t: @This()) u8 {
if (t.tag == 0) {
return '.';
} else if (t.tag == 1) {
return '#';
} else if (t.dist == 0) {
... | 2018/day06.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const c = @cImport({
@cInclude("stdio.h");
@cInclude("string.h");
@cInclude("unistd.h");
@cInclude("time.h");
@cInclude("errno.h");
@cInclude("stdintfix.h"); // NB: Required as zig is unable to pro... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const common = @import("common.zig");
const toml = @import("toml.zig");
const string = []const u8;
const Allocator = std.mem.Allocator;
const Kilo = 1024;
const Mega = Kilo * 1024;
const Giga = Mega * 1024;
const RST = "\x1B[0m";
const BLK = "\x1B[0;30m"... | src/main.zig |
const std = @import("std");
const io = std.io;
const map = std.HashMap;
const os = std.os;
const Tokenizer = @import("tokenizer.zig");
const warn = std.debug.warn;
const Buffer = std.Buffer;
const allocator = std.heap.c_allocator;
const Vec = std.ArrayList;
const util = @import("stringUtil.zig");
const c_str = std.cstr... | src/parser.zig |
const std = @import("std");
const testing = std.testing;
const builtin = std.builtin;
pub inline fn hasBehaviour(comptime Type: type, comptime Behaviour: type) bool {
return doHasBehaviour(Type, Behaviour);
}
fn doHasBehaviour(comptime Type: type, comptime Behaviour: type) bool {
const type_info = @typeInfo(T... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const log_ = @import("Log.zig");
const fatalErrorLog_ = log_.fatalErrorLog;
const errLog_ = log_.errLog;
const dbgLog_ = log_.dbgLog;
const ArrayList = std.ArrayList;
const c_allocator = std.heap.c_allocator;
const page_all... | src/TCPServer.zig |
const std = @import("std");
const v = @import("vector_types.zig");
extern fn @"llvm.x86.pclmulqdq"(v.i64x2, v.i64x2, i8) v.i64x2;
pub inline fn carrylessMul(a: v.u64x2, b: v.u64x2) v.u64x2 {
return @bitCast(
v.u64x2,
@"llvm.x86.pclmulqdq"(@bitCast(v.i64x2, a), @bitCast(v.i64x2, b), 0),
);
}
tes... | src/llvm_intrinsics.zig |
const builtin = @import("builtin");
const std = @import("std");
const Builder = std.build.Builder;
const Step = std.build.Step;
const Crc32WithPoly = std.hash.crc.Crc32WithPoly;
const Polynomial = std.hash.crc.Polynomial;
const ElfHeader = std.elf.Header;
const uf2 = @import("build/uf2.zig");
const UF2 = uf2.UF2;
con... | build.zig |
const bake = @import("src/bake.zig");
const cfg = @import("src/cfg.zig");
const minify = @import("src/minify.zig");
const std = @import("std");
// package for "baking" resources into runtime-ready format
pub fn getBakePkg(
builder: *std.build.Builder,
options: Options,
name: []const u8,
dest_dir: []con... | build.zig |
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
@"32bit",
@"8msecext",
a76,
aclass,
acquire_release,
aes,
avoid_movs_shop,
avoid_partial_cpsr,
bf16,
cde,
cdecp0,
cdecp1,
c... | lib/std/target/arm.zig |
const std = @import("std");
const log = std.log.scoped(.gpa);
const math = std.math;
const assert = std.debug.assert;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const page_size = std.mem.page_size;
const StackTrace = std.builtin.StackTrace;
/// Integer type for pointing to slots in a small allocation
c... | lib/std/heap/general_purpose_allocator.zig |
const Coff = @This();
const std = @import("std");
const log = std.log.scoped(.link);
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const fs = std.fs;
const allocPrint = std.fmt.allocPrint;
const mem = std.mem;
const trace = @import("../tracy.zig").trace;
const Module = @import("../Module.zig")... | src/link/Coff.zig |
const std = @import("../../index.zig");
const builtin = @import("builtin");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const TypeId = builtin.TypeId;
pub const Limb = usize;
pub const DoubleLimb = @IntType(false, 2 * Limb.bit_... | std/math/big/int.zig |
const std = @import("std");
const crypto = std.crypto;
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Poly1305 = crypto.onetimeauth.Poly1305;
const Blake2b = crypto.hash.blake2.Blake2b;
const X25519 = crypto.dh.X25519;
const Salsa20NonVecImpl = struct {
const BlockVec = [16]u32;
... | lib/std/crypto/salsa20.zig |
const std = @import("../../std.zig");
const mem = std.mem;
const debug = std.debug;
const Vector = std.meta.Vector;
const BlockVec = Vector(2, u64);
/// A single AES block.
pub const Block = struct {
pub const block_size: usize = 16;
/// Internal representation of a block.
repr: BlockVec,
/// Conve... | lib/std/crypto/aes/aesni.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Octopus = union(enum) {
Normal: u8, // power level
Flashing: usize, // step number
};
const Octopuses = std.AutoHashMap(aoc.Coord, Octopus);
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var octopuses = Octopuses.init(problem.a... | src/main/zig/2021/day11.zig |
//--------------------------------------------------------------------------------
// Section: Types (8)
//--------------------------------------------------------------------------------
pub const POINTER_FLAGS = enum(u32) {
NONE = 0,
NEW = 1,
INRANGE = 2,
INCONTACT = 4,
FIRSTBUTTON = 16,
SECO... | win32/ui/input/pointer.zig |
const std = @import("std");
const print = std.debug.print;
const aro = @import("aro");
const Codegen = aro.Codegen;
const Tree = aro.Tree;
const Token = Tree.Token;
const NodeIndex = Tree.NodeIndex;
const AllocatorError = std.mem.Allocator.Error;
const predefined_macros =
\\#define EXPECT(x) _Static_assert(x, "une... | test/runner.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = true;
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 Map = tools.Map(u8, 5, 5, false);
const Vec2 = tools.... | 2019/day24a.zig |
const std = @import("std");
const with_trace = true;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Opcode = enum {
hlf,
tpl,
inc,
jmp,
jie,
jio,
};
const Instruction = struct {
op: Opcode,
... | 2015/day23.zig |
const std = @import("std");
const builtin = @import("builtin");
pub fn Serializer(comptime Writer: type, endian: std.builtin.Endian) type {
return struct {
writer: std.io.CountingWriter(Writer),
const Self = @This();
pub fn serialize(self: *Self, value: anytype) !void {
const ... | src/serializer.zig |
const std = @import("std");
const mem = std.mem;
const field_size = [32]u8{
0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, // 2^252+27742317777372353535851937790883648493... | lib/std/crypto/25519/scalar.zig |
const std = @import("std");
const ziglet = @import("../ziglet.zig");
const util = @import("util.zig");
const mem = std.mem;
pub const Event = union(enum) {
KeyDown: Key,
KeyUp: Key,
Char: u8,
MouseDown: MouseButton,
MouseUp: MouseButton,
MouseScroll: [2]f32,
MouseMove: [2]f32,
MouseEn... | src/app/event.zig |
const gpio = @import("gpio.zig");
const cpu = @import("cpu.zig");
const rs_pin = 12;
const en_pin = 11;
const data_pins = [4]comptime_int{ 5, 4, 3, 2 };
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;... | src/lcd.zig |
const clap = @import("clap");
const std = @import("std");
const util = @import("util");
const rom = @import("rom.zig");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const os = std.os;
const path = fs.path;
const nds = rom.nds;
const... | src/core/tm35-nds-extract.zig |
const escape = @import("details/escape.zig");
const fmt = @import("details/fmt.zig");
const std = @import("std");
const Formatter = @import("../../../lib.zig").ser.Formatter;
pub fn PrettyFormatter(comptime Writer: type) type {
return struct {
current: usize,
has_value: bool,
indent: []con... | src/ser/impl/formatter/pretty.zig |
const std = @import("std");
const IR = @import("../IR.zig");
pub const Opt = struct {};
pub fn emit(m: IR.Module, writer: anytype, comptime opt: Opt) !void {
const e = Emitter(@TypeOf(writer)){ .writer = writer, .m = &m, .opt = opt };
try writer.writeAll(&std.wasm.magic);
try writer.writeAll(&std.wasm.ver... | src/Wasm/Emit.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const mustache = @import("mustache");
pub fn main() anyerror!void {
std.debug.print("Benchmark\n{s}\n", .{"https://github.com/batiati/mustache_benchmark"});
std.debug.print("=============================\n\n", .{});
try runTemplate("Template ... | benchmark/src/main.zig |
const clap = @import("clap");
const std = @import("std");
const ascii = std.ascii;
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const process = std.process;
const time = std.time;
const Param = clap.Param(clap.Help);
const params = [_]Param{
clap.pars... | src/main.zig |
const std = @import("std");
const log = std.log;
const csl = @import("csl_json.zig");
const ast = @import("ast.zig");
const Parser = @import("parser.zig").Parser;
pub const BuiltinCall = enum {
cite = 0,
textcite,
cites,
bibliography,
sc,
label,
ref,
};
pub const BuiltinCallInfo = struct ... | src/builtin.zig |