code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
// Aggregate structs
pub const Letter = @import("components/aggregate/Letter.zig");
pub const Mark = @import("components/aggregate/Mark.zig");
pub const Number = @import("components/aggregate/Number.zig");
pub const Punct = @import("components/aggregate/Punct.zig");
pub const Symbol = @import("components/aggregate/Sym... | src/components.zig |
const std = @import("std");
const c = @import("internal/c.zig");
const internal = @import("internal/internal.zig");
const log = std.log.scoped(.git);
pub const PATH_LIST_SEPARATOR = c.GIT_PATH_LIST_SEPARATOR;
pub const GIT_PASSTHROUGH = c.GIT_PASSTHROUGH;
pub usingnamespace @import("alloc.zig");
pub usingnamespace @i... | src/git.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XEVIE", .global_id = 0 };
/// @brief QueryVersioncookie
pub const QueryVersioncookie = struct {
sequence: c_uint,
};
/// @brief QueryVersionRequest
pub const QueryVersionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 ... | src/auto/xevie.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for rest... | build.zig |
// pub fn ScratchAllocator(comptime T: type) type {
// return struct {
// const Self = @This();
// backup_allocator: T,
// end_index: usize,
// buffer: []u8,
// pub fn init (backup_allocator: T) @This() {
// const scratch_buffer = backup_allocator.allocator()... | src/mem/scratch_allocator.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const ChildProcess = std.ChildProcess;
const LsColors = @import("lscolors").LsColors;
const Entry = @import("walkdir").Entry;
pub const ActionType = enum {
Print,
Execute,
ExecuteBatch,
};
pub const Action ... | src/actions.zig |
const Self = @This();
const build_options = @import("build_options");
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const os = std.os;
const wlr = @import("wlroots");
const wl = @import("wayland").server.wl;
const server = &@import("main.zig").server;
const util = @import("util.... | source/river-0.1.0/river/View.zig |
const translate = @import("translate.zig");
const std = @import("std");
const c = @import("c.zig");
pub const register_function = translate.register_function;
pub const throw = translate.throw;
pub const slice_from_value = translate.slice_from_value;
pub const create_buffer = translate.create_buffer;
pub fn create_st... | src/helpers.zig |
const std = @import("std");
const expect = std.testing.expect;
const minInt = std.math.minInt;
test "@bitReverse" {
comptime testBitReverse();
testBitReverse();
}
fn testBitReverse() void {
// using comptime_ints, unsigned
expect(@bitReverse(u0, 0) == 0);
expect(@bitReverse(u5, 0x12) == 0x9);
... | test/stage1/behavior/bitreverse.zig |
const errs = @import("./error.zig");
const OlinError = errs.OlinError;
extern fn resource_open(data: [*]const u8, len: usize) i32;
extern fn resource_read(fd: i32, data: [*]const u8, len: usize) i32;
extern fn resource_write(fd: i32, data: [*]const u8, len: usize) i32;
extern fn resource_close(fd: i32) void;
extern fn... | god/olin/resource.zig |
const std = @import("std");
const Self = @This();
step: std.build.Step,
builder: *std.build.Builder,
source: []std.build.FileSource,
defines: [][]const u8,
output_file: std.build.GeneratedFile,
/// Allocates a ZingleHeaderStep, caller owns memory
pub fn create(builder: *std.build.Builder, files: [][]const u8, defines:... | zingle_header.zig |
const std = @import("std");
const stdx = @import("stdx");
const graphics = @import("graphics");
const Color = graphics.Color;
const ui = @import("../ui.zig");
const ZStack = ui.widgets.ZStack;
const log = stdx.log.scoped(.root);
const OverlayId = u32;
const RootOverlayHandle = struct {
root: *Root,
overlay_i... | ui/src/widgets/root.zig |
const std = @import("std");
const debug = std.log.debug;
const warn = std.log.warn;
const assert = std.debug.assert;
const times = @import("times.zig");
const SCREEN_WIDTH = 64;
const SCREEN_HEIGHT = 32;
pub const MEM_SIZE = 4096;
const MachineError = error{
InvalidRegister,
UnknownInstruction,
};
pub const ... | src/machine.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const OpType = enum {
nop,
acc,
jmp,
};
const Op = struct {
t: OpType,
value: i32,
};
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_a... | src/day08.zig |
const assert = @import("std").debug.assert;
const testing = @import("std").testing;
const color = @import("zigimg").color;
const helpers = @import("helpers.zig");
test "Convert color to premultipled alpha" {
const originalColor = color.Color.initRGBA(100 / 255, 128 / 255, 210 / 255, 100 / 255);
const premultip... | tests/color_test.zig |
const std = @import("std");
const helper = @import("helper.zig");
const Allocator = std.mem.Allocator;
const input = @embedFile("../inputs/day11.txt");
const grid_size = 10;
pub fn run(alloc: Allocator, stdout_: anytype) !void {
_ = alloc;
var grid = OctoGrid.init(input);
var grid2 = grid;
const re... | src/day11.zig |
const std = @import("std");
const assert = std.debug.assert;
const cpu = @import("cpu.zig");
const config = @import("config.zig");
const memory = @import("memory.zig");
usingnamespace @import("instruction.zig");
pub fn load_program(state: *cpu.CPUState, program: []u8) void {
assert((program.len & 0x0001) == 0); /... | src/chip8/execution.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const assert = std.debug.assert;
const print = std.debug.print;
const input = @embedFile("../input/day02.txt");
fn readPolicies(allocator: *Allocator) !ArrayList(Policy) {
var policies = ArrayList(Policy).init(allocat... | src/day02.zig |
const std = @import("std");
const Answer = struct { @"0": u32, @"1": u32 };
const NumberTag = enum {
regular_num,
pair_num,
};
const Number = union(NumberTag) {
regular_num: *ValueNode,
pair_num: Pair,
};
const Pair = struct { left: *Number, right: *Number };
const ValueNode = struct {
value: u3... | src/day18.zig |
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/03.txt", .{});
defer input_file.close();
var buffered_reader = std.io.bufferedReade... | src/03_2.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
pub const StringTime = struct {
commands: CommandList,
const CommandKind = union(enum) {
literal: []const u8,
substitution: struct {
variable_name: []const u8,
},
for_range: struct {
times:... | src/main.zig |
const std = @import("std");
usingnamespace (@import("../machine.zig"));
usingnamespace (@import("../util.zig"));
test "AVX512 - mask register" {
const m32 = Machine.init(.x86_32);
const m64 = Machine.init(.x64);
const reg = Operand.register;
const imm = Operand.immediate;
const mem8 = Operand.mem... | src/x86/tests/mask_register.zig |
const zt = @import("deps/ZT/src/zt.zig");
const std = @import("std");
const sling = @import("sling.zig");
const ig = @import("deps/ZT/src/pkg/imgui.zig");
const gl = @import("deps/ZT/src/pkg/gl.zig");
const Self = @This();
pub const Space = enum { screen, world };
pub const Patch = struct {
subRect: sling.math.Re... | src/renderer.zig |
const std = @import("std");
const zap = @import("zap");
const hyperia = @import("hyperia.zig");
const mem = std.mem;
const math = std.math;
const time = std.time;
const mpsc = hyperia.mpsc;
const testing = std.testing;
const assert = std.debug.assert;
const SpinLock = hyperia.sync.SpinLock;
const Timer = @This();
... | Timer.zig |
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
// Configuration
// TODO: pass this option from the build system.
pub const JANET_NO_NANBOX = false;
pub const c = @cImport({
if (JANET_NO_NANBOX) {
@cDefine("JANET_NO_NANBOX", {});
}
@cInclude("janet.h")... | src/janet.zig |
const std = @import("std");
const backend = @import("backend.zig");
const data = @import("data.zig");
const Allocator = std.mem.Allocator;
pub const Class = struct {
typeName: []const u8,
showFn: fn (widget: *Widget) anyerror!void,
deinitFn: fn (widget: *Widget) void,
preferredSizeFn: fn (widget: *co... | src/widget.zig |
const std = @import("std");
const builtin = std.builtin;
const io = std.io;
const fs = std.fs;
const process = std.process;
const ChildProcess = std.ChildProcess;
const warn = std.debug.warn;
const mem = std.mem;
const testing = std.testing;
const max_doc_file_size = 10 * 1024 * 1024;
const exe_ext = @as(std.zig.Cros... | doc/docgen.zig |
const std = @import("std");
const ArrayListAligned = std.ArrayListAligned;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const os = std.os;
const process = std.process;
const Target = std.Target;
const unicode = std.unicode;
const clap = @... | src/main.zig |
const std = @import("std");
const zua = @import("zua");
const parse = zua.parse;
// Tests for comparing the output of Zua's parser with Lua's.
// Expects @import("build_options").fuzzed_parse_inputs_dir to be a path to
// a directory containing a corpus of inputs to test and
// @import("build_options").fuzzed_parse_ou... | test/fuzzed_parse.zig |
const std = @import("std");
const testing = std.testing;
const c = @import("c.zig").c;
const key = @import("key.zig");
/// Possible value for various window hints, etc.
pub const dont_care = c.GLFW_DONT_CARE;
pub const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
pub const ... | glfw/src/main.zig |
const std = @import("std");
const Sdk = @import("Sdk.zig");
const Builder = std.build.Builder;
pub fn build(b: *Builder) !void {
const sdk = Sdk.init(b);
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const sdl_linkage = b.option(std.build.LibExeObjStep.Linkag... | build.zig |
const std = @import("std");
const Client = @import("../Client.zig");
const util = @import("../util.zig");
const log = std.log.scoped(.zCord);
const Heartbeat = @This();
mailbox: util.Mailbox(enum { start, ack, stop, terminate }),
handler: *std.Thread,
pub fn init(client: *Client) !Heartbeat {
return Heartbeat{
... | src/Client/Heartbeat.zig |
const std = @import("std");
const os = std.os;
const linux = os.linux;
const errno = linux.getErrno;
const pid_t = linux.pid_t;
const fd_t = linux.fd_t;
const off_t = linux.off_t;
const rusage = linux.rusage;
const itimerspec = linux.itimerspec;
const UnexpectedError = os.UnexpectedError;
const unexpectedErrno = os.un... | src/sys.zig |
const wlr = @import("../wlroots.zig");
const wayland = @import("wayland");
const wl = wayland.server.wl;
const wlr_proto = wayland.server.wlr;
pub const LayerShellV1 = extern struct {
global: *wl.Global,
server_destroy: wl.Listener(*wl.Server),
events: extern struct {
new_surface: wl.Signal(*Lay... | src/types/layer_shell_v1.zig |
const std = @import("std");
const fs = std.fs;
fn instToCode(inst: []const u8) i32 {
std.debug.assert(inst.len == 3);
return @as(i32, inst[0]) | @as(i32, inst[1]) << 8 | @as(i32, inst[2]) << 16;
}
const NOP = comptime instToCode("nop");
const ACC = comptime instToCode("acc");
const JMP = comptime instToCode("... | 2020/src/day_08.zig |
const std = @import("std");
const renderkit = @import("renderkit");
const gk = @import("../gamekit.zig");
const math = gk.math;
const IndexBuffer = renderkit.IndexBuffer;
const VertexBuffer = renderkit.VertexBuffer;
const Vertex = gk.gfx.Vertex;
const Texture = gk.gfx.Texture;
pub const Batcher = struct {
mesh: g... | gamekit/graphics/batcher.zig |
const std = @import("../std.zig");
const builtin = @import("builtin");
const ResetEvent = @This();
const os = std.os;
const assert = std.debug.assert;
const testing = std.testing;
const Atomic = std.atomic.Atomic;
const Futex = std.Thread.Futex;
impl: Impl = .{},
/// Returns if the ResetEvent was set().
/// Once re... | lib/std/Thread/ResetEvent.zig |
const std = @import("std");
const debug = std.debug;
const testing = std.testing;
const expect = testing.expect;
const expectError = testing.expectError;
const warn = debug.warn;
const mem = std.mem;
const math = std.math;
const Allocator = mem.Allocator;
const builtin = @import("builtin");
const TypeId = builtin.TypeI... | parse_number.zig |
const std = @import("std");
const io = std.io;
const mem = std.mem;
const fs = std.fs;
const process = std.process;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const Buffer = std.Buffer;
const Target = std.Target;
const self_hosted_main = @import("main.zig");
const errmsg = @import("errmsg.zig");... | src-self-hosted/stage1.zig |
const assert = @import("std").debug.assert;
pub const CString = [*:0]const u8;
pub const MutCString = [*:0]u8;
pub const Bool32 = i32;
pub const FileType = extern enum {
invalid,
gltf,
glb,
};
pub const Result = extern enum {
success,
data_too_short,
unknown_format,
invalid_json,
inv... | include/cgltf.zig |
const std = @import("std");
const Tokenizer = @import("tokenize.zig").Tokenizer;
const Token = @import("tokenize.zig").Token;
const mem = std.mem;
const fs = std.fs;
const process = std.process;
const math = std.math;
const data = @import("data.zig");
const parseStringLiteral = std.zig.parseStringLiteral;
const elf = s... | src/main.zig |
const std = @import("std");
const util = @import("util");
const common = @import("../common.zig");
const gen3 = @import("../gen3.zig");
const rom = @import("../rom.zig");
const debug = std.debug;
const mem = std.mem;
const lu16 = rom.int.lu16;
const lu32 = rom.int.lu32;
const lu64 = rom.int.lu64;
pub fn Offset(comp... | src/core/gen3/offsets.zig |
const std = @import("std");
const subcommands = @import("../subcommands.zig");
const shared = @import("../shared.zig");
const zsw = @import("zsw");
const log = std.log.scoped(.groups);
pub const name = "groups";
pub const usage =
\\Usage: {0s} [user]
\\ or: {0s} OPTION
\\
\\Display the current grou... | src/subcommands/groups.zig |
const std = @import("std");
const generate = @import("generator.zig").generate;
const path = std.fs.path;
const Builder = std.build.Builder;
const Step = std.build.Step;
/// build.zig integration for Vulkan binding generation. This step can be used to generate
/// Vulkan bindings at compiletime from vk.xml, by providi... | render/lib/vulkan-zig/generator/vulkan/build-integration.zig |
const std = @import("std");
const assert = std.debug.assert;
const fmt = std.fmt;
const io = std.io;
const math = std.math;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const deflate_const = @import("deflate_const.zig");
const fast = @import("deflate_fast.zig");
const hm_bw = @import("huffman_bit_writer.... | lib/std/compress/deflate/compressor.zig |
pub const PAGE_SIZE: usize = 4096;
////
// Return address as either usize or a pointer of type T.
//
// Arguments:
// T: The desired output type.
// address: Address to be returned.
//
// Returns:
// The given address as type T (usize or a pointer).
//
fn intOrPtr(comptime T: type, address: usize) T {
... | kernel/x86.zig |
const Object = @This();
const std = @import("std");
const assert = std.debug.assert;
const fs = std.fs;
const io = std.io;
const log = std.log.scoped(.object);
const macho = std.macho;
const mem = std.mem;
const Allocator = mem.Allocator;
const parseName = @import("Zld.zig").parseName;
usingnamespace @import("comman... | src/link/MachO/Object.zig |
const std = @import("std");
const build = std.build;
pub const cache = ".zigmod/deps";
pub fn addAllTo(exe: *build.LibExeObjStep) void {
@setEvalBranchQuota(1_000_000);
for (packages) |pkg| {
exe.addPackage(pkg);
}
if (c_include_dirs.len > 0 or c_source_files.len > 0) {
exe.linkLibC();... | deps.zig |
const std = @import("std");
const assert = std.debug.assert;
pub const Checksum = struct {
// TODO: how can I create a collection of strings in zig?
words: [250][26]u8,
count: usize,
maxlen: usize,
count2: usize,
count3: usize,
pub fn init() Checksum {
const allocator = std.heap.di... | 2018/p02/checksum.zig |
const std = @import("std");
pub const Command = struct {
long_name: []const u8,
commands: ?[]Command = null,
pub fn deinit(self: Command, allocator: std.mem.Allocator) void {
if (self.commands) |cmds| {
for (cmds) |cmd| {
cmd.deinit(allocator);
}
... | experiments/src/main.zig |
const std = @import("std");
const stdout = std.io.getStdOut().writer();
var gpallocator = std.heap.GeneralPurposeAllocator(.{}){};
var allocator = &gpallocator.allocator;
// This code was written AFTER the Go iterations.
const asc_u64 = std.sort.asc(u64);
pub fn main() !void {
const f = try std.fs.cwd().openFile... | 09/part2.zig |
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const slimy = @import("slimy.zig");
fn isSlime(world_seed: i64, x: i32, z: i32) bool {
@setRuntimeSafety(false);
// Init slime seed
var seed = world_seed +%
@as(i64, x * x *% 4987142) +
@a... | src/cpu.zig |
const std = @import("std");
const rk = @import("renderkit");
const gfx = @import("../gamekit.zig").gfx;
pub const OffscreenPass = struct {
pass: rk.Pass,
color_texture: gfx.Texture,
color_texture2: ?gfx.Texture = null,
color_texture3: ?gfx.Texture = null,
color_texture4: ?gfx.Texture = null,
de... | gamekit/graphics/offscreen_pass.zig |
const std = @import("std");
const builtin = @import("builtin");
const http = @import("apple_pie");
const redis = @import("okredis");
const tar = @import("tar");
const version = @import("version");
const zzz = @import("zzz");
usingnamespace @import("common.zig");
const FV = redis.commands.hashes.utils.FV;
const FixBu... | src/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const fmtUtf8SliceEscapeUpper = @import("util.zig").fmtUtf8SliceEscapeUpper;
/// Like MetadataMap, but uses description/language as the keys
/// so it works for ID3v2 comments/unsynchronized lyrics
pub const FullTextMap = struct {
allocator: Allocato... | src/id3v2_data.zig |
const std = @import("std");
fn defaultTransformer(field_name: []const u8, _: EncodingOptions) anyerror![]const u8 {
return field_name;
}
pub const FieldNameTransformer = fn ([]const u8, EncodingOptions) anyerror![]const u8;
pub const EncodingOptions = struct {
allocator: ?std.mem.Allocator = null,
field_... | src/url.zig |
// Physical Memory Map (from n64.readthedocs.io)
// Address Range | Name | Description
// 00000000h-003FFFFFh | RDRAM | Built-in
// 00400000h-007FFFFFh | RDRAM | Expansion Pak
// 03F00000h-03FFFFFFh | RDRAM IO | RDRAM MMIO
// 04000000h-04000FFFh | SP DMEM | RSP Data Memory
// 04001000h-04001FFF... | src/core/bus.zig |
const Data = @import("../events/events.zig").Data;
const Event = @import("../events/events.zig").Event;
const std = @import("std");
pub const ChunkedReader = struct {
const Self = @This();
chunk_size: usize = 0,
bytes_read: usize = 0,
state: State = .ReadChunkSize,
// An 8 bytes chunk size allows ... | src/readers/chunked_reader.zig |
const std = @import("std");
const assert = std.debug.assert;
const is_darwin = std.Target.current.isDarwin();
const config = @import("./config.zig");
pub const Time = struct {
const Self = @This();
/// Hardware and/or software bugs can mean that the monotonic clock may regress.
/// One example (of many): ... | src/time.zig |
const freebsd = @import("index.zig");
const socklen_t = freebsd.socklen_t;
const iovec = freebsd.iovec;
pub const SYS_sbrk = 69;
pub fn syscall0(number: usize) usize {
return asm volatile ("syscall"
: [ret] "={rax}" (-> usize)
: [number] "{rax}" (number)
: "rcx", "r11"
);
}
pub fn sys... | std/os/freebsd/x86_64.zig |
const std = @import("std");
const utils = @import("utils");
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const print = utils.print;
const Map = struct {
risk: []u32,
width: usize,
height: usize,
};
fn readInput(arena: *ArenaAllocator, lines_it: *utils.FileLineItera... | day15/src/main.zig |
const testing = @import("std").testing;
const math = @import("std").math;
pub const v2 = struct {
x: f32,
y: f32,
/// initializes a v2 with x and y
pub fn init(x: f32, y: f32) v2 {
return v2 {
.x = x,
.y = y,
};
}
/// returns the component from an index... | src/vector2.zig |
usingnamespace @import("../core.zig");
const Device = @import("../vulkan/device.zig").Device;
const Mesh = @import("mesh.zig").Mesh;
const TransferQueue = @import("../transfer_queue.zig").TransferQueue;
const obj = @import("../utils/obj_loader.zig");
//TODO: Replace
const ColorVertex = struct {
pos: Vector3,
c... | src/renderer/mesh_manager.zig |
const std = @import("std");
const win32 = @import("./win32.zig");
const GeneralPurposeAllocator = std.heap.GeneralPurposeAllocator(.{});
const StringHashMap = std.StringHashMap(void);
const Allocator = std.mem.Allocator;
pub fn main() u8 {
const FOUND = 0;
const NOT_FOUND = 1;
var gpa = GeneralPurposeAll... | src/main.zig |
const std = @import("std");
const bigint = std.math.big.int;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
var global_allocator = &gpa.allocator;
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
const n = try get_n();
const one = (try bigint.Managed.initSet(global_allocator, 1)).toCo... | bench/algorithm/pidigits/1.zig |
const std = @import("std");
// Use zig translate-c to generate raylib.zig and swap imports to get better completion in IDEs
// const c = @import("raylib.zig");
const c = @cImport(
@cInclude("raylib.h"),
);
// Wrappers / Convenience Functions --------------------------------------------
fn rect(x: f32, y: f32,... | src/main.zig |
const std = @import("std");
const c = @import("c.zig");
const util = @import("util.zig");
const log = std.log.scoped(.messages);
pub const WriteCallback = fn (handle: ?*c.uv_write_t, status: i32, buffer: ?*c.uv_buf_t) callconv(.C) void;
pub const AllocCallback = fn (handle: ?*c.uv_handle_t, size: usize, buf: ?*c.uv_... | src/messages.zig |
pub const NCBNAMSZ = @as(u32, 16);
pub const MAX_LANA = @as(u32, 254);
pub const NAME_FLAGS_MASK = @as(u32, 135);
pub const GROUP_NAME = @as(u32, 128);
pub const UNIQUE_NAME = @as(u32, 0);
pub const REGISTERING = @as(u32, 0);
pub const REGISTERED = @as(u32, 4);
pub const DEREGISTERED = @as(u32, 5);
pub const DUPLICATE ... | win32/network_management/net_bios.zig |
const std = @import("std");
const serde_usize = u64;
const SerdeError = error{
OutOfMemory,
AllocatorRequired,
};
pub fn serialize(allocator: std.mem.Allocator, value: anytype) ![]u8 {
const Type = @TypeOf(value);
if (@hasDecl(Type, "serialize")) {
return try Type.serialize(allocator, value);... | src/serde.zig |
const std = @import("../std.zig");
const elf = std.elf;
const mem = std.mem;
const fs = std.fs;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const assert = std.debug.assert;
const process = std.process;
const Target = std.Target;
const CrossTarget = std.zig.CrossTarget;
const macos = @import("s... | lib/std/zig/system.zig |
const std = @import("../index.zig");
const builtin = @import("builtin");
const Os = builtin.Os;
const debug = std.debug;
const windows = std.os.windows;
const linux = std.os.linux;
const darwin = std.os.darwin;
const posix = std.os.posix;
pub const epoch = @import("epoch.zig");
/// Sleep for the specified duration
p... | std/os/time.zig |
const std = @import("../../std.zig");
const testing = std.testing;
const math = std.math;
const cmath = math.complex;
const Complex = cmath.Complex;
/// Returns the square root of z. The real and imaginary parts of the result have the same sign
/// as the imaginary part of z.
pub fn sqrt(z: var) @typeOf(z) {
cons... | lib/std/math/complex/sqrt.zig |
const std = @import("../std.zig");
const testing = std.testing;
const builtin = std.builtin;
const has_aesni = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);
const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
const has_armaes = comptime std.Tar... | lib/std/crypto/aes.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const mem = std.mem;
const meta = std.meta;
const macho = std.macho;
const testing = std.testing;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const MachO = @import("../MachO.zig");
const makeStaticString = MachO.makeStaticStrin... | src/link/MachO/commands.zig |
const std = @import("../std.zig");
const io = std.io;
const assert = std.debug.assert;
const testing = std.testing;
pub fn BufferedReader(comptime buffer_size: usize, comptime ReaderType: type) type {
return struct {
unbuffered_reader: ReaderType,
fifo: FifoType = FifoType.init(),
pub cons... | lib/std/io/buffered_reader.zig |
const std = @import("std");
const backend = @import("backend.zig");
const Size = @import("data.zig").Size;
const Colorspace = @import("color.zig").Colorspace;
/// As of now, zgt only supports RGBA images
pub const ImageData = struct {
width: usize,
stride: usize,
height: usize,
/// Value pointing to t... | src/image.zig |
const std = @import("std");
const warn = std.debug.warn;
// D: Die, S: Stay the same, G: Grow a new cell
const Rule = enum {
D, // Die
S, // Stay the same
G, // Grow a new cell
};
const Life = struct {
generation: i32,
rules: []const Rule,
width: usize,
height: usize,
grid: [][]bool... | life.zig |
const std = @import("std");
const c = @import("c.zig");
const AllShaders = @import("all_shaders.zig").AllShaders;
const Mat4x4 = @import("math3d.zig").Mat4x4;
const PngImage = @import("png.zig").PngImage;
pub const Spritesheet = struct {
img: PngImage,
count: usize,
texture_id: c.GLuint,
vertex_buffer:... | src/spritesheet.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const c = @import("../c.zig");
const content = @import("../content.zig");
const gfx = @import("../gfx.zig");
const Texture = gfx.Texture;
const Image = gfx.Image;
const BoundInstancer = gfx.BoundInstancer;
const CoordinateStack = @import("../coordinate... | src/defaults/flat.zig |
const std = @import("std");
const math = std.math;
const testing = std.testing;
const assert = std.debug.assert;
const root = @import("main.zig");
usingnamespace @import("vec3.zig");
usingnamespace @import("vec4.zig");
usingnamespace @import("mat4.zig");
pub const Quat = Quaternion(f32);
pub const Quat_f64 = Quaternio... | src/quaternion.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Vec2 = tools.Vec2;
pub fn run(input_text: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const param: struct {
... | 2018/day22.zig |
//--------------------------------------------------------------------------------
// Section: Types (2)
//--------------------------------------------------------------------------------
const IID_IDisplayDeviceInterop_Value = @import("../../zig.zig").Guid.initString("64338358-366a-471b-bd56-dd8ef48e439b");
pub const... | win32/system/win_rt/display.zig |
const std = @import("std");
const builtin = @import("builtin");
const math = std.math;
const isNan = std.math.isNan;
const maxInt = std.math.maxInt;
const native_os = builtin.os.tag;
const native_arch = builtin.cpu.arch;
const native_abi = builtin.abi;
const is_wasm = switch (native_arch) {
.wasm32, .wasm64 => tr... | lib/c.zig |
const std = @import("std");
const assert = std.debug.assert;
const fixedBufferStream = std.io.fixedBufferStream;
const ExecError = error{
InvalidOpcode,
InvalidParamMode,
};
fn opcode(ins: i32) i32 {
return @rem(ins, 100);
}
test "opcode extraction" {
assert(opcode(1002) == 2);
}
fn paramMode(ins: i... | zig/05_2.zig |
pub const c = @import("sfml_import.zig").c;
pub const Error = @import("sfml_errors.zig").Error;
pub const system = struct {
const vector = @import("system/vector.zig");
pub const Vector2 = vector.Vector2;
pub const Vector3 = vector.Vector3;
pub const Vector4 = vector.Vector4;
pub const Vector2i =... | src/sfml/sfml.zig |
/// NTSTATUS codes from https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/596a1078-e883-4972-9bbc-49e60bebca55?
pub const NTSTATUS = enum(u32) {
/// The caller specified WaitAny for WaitType and one of the dispatcher
/// objects in the Object array has been set to the signaled state.
pu... | lib/std/os/windows/ntstatus.zig |
const spirv = @import("spirv.zig");
pub const File = []const Decl;
pub const Decl = union(enum) {
fn_def: FnDef,
type_def: TypeDef,
var_def: VarDef,
};
pub const FnDef = struct {
entry: bool,
name: Ident,
args: []const Arg,
ret: Type,
body: Block,
pub const Arg = struct {
... | src/ast.zig |
const Symbol = @This();
const std = @import("std");
const macho = std.macho;
const mem = std.mem;
const Allocator = mem.Allocator;
const Object = @import("Object.zig");
pub const Type = enum {
regular,
proxy,
unresolved,
};
/// Symbol type.
@"type": Type,
/// Symbol name. Owned slice.
name: []u8,
/// ... | src/link/MachO/Symbol.zig |
const builtin = @import("builtin");
const assert = @import("std").debug.assert;
/// Call a Non-Secure function.
pub fn nonSecureCall(func: var, r0: usize, r1: usize, r2: usize, r3: usize) usize {
@setAlignStack(8);
const target = if (@TypeOf(func) == usize) func else @ptrToInt(func);
// Specifying Armv8-... | src/drivers/arm_cmse.zig |
const std = @import("std");
const zlm = @import("zlm");
const gl = @import("gl.zig");
const Renderer = @import("renderer.zig").Renderer;
const util = @import("../util.zig");
const glut = @cImport(@cInclude("GL/freeglut.h"));
const glfw = @cImport(@cInclude("GLFW/glfw3.h"));
pub const MouseButton = enum(u3) {
lef... | src/render/window.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const BufMap = std.BufMap;
const testing = std.testing;
const input_file = "input04.txt";
const fields = [_][]const u8{
"byr",
"iyr",
"eyr",
"hgt",
"hcl",
"ecl",
"pid",
"cid",
};
const eye_colors = [_][]const u8{
"am... | src/04_2.zig |
const std = @import("std");
const io = std.io;
const mem = std.mem;
const debug = std.debug;
const types = @import("types.zig");
const serial = @import("json_serialize.zig");
pub const LspError = error{
InvalidHeader,
HeaderFieldTooLong,
MessageTooLong,
PrematureEndOfStream,
};
pub fn readMessageAllo... | src/protocol.zig |
const std = @import("std");
const expect = std.testing.expect;
test "optional type" {
const x: ?bool = true;
if (x) |y| {
if (y) {
// OK
} else {
unreachable;
}
} else {
unreachable;
}
const next_x: ?i32 = null;
const z = next_x orelse ... | test/behavior/null.zig |
const std = @import("std");
const assert = std.debug.assert;
const io = std.io;
/// buf must be at least as long as in
pub fn decode(in: []const u8, buf: []u8) []u8 {
assert(buf.len >= in.len);
if (in.len == 0) {
return buf[0..0];
}
var i: usize = 0;
var buf_i: usize = 0;
while (i < in.... | src/unsynch.zig |
const std = @import("std");
usingnamespace (@import("../machine.zig"));
usingnamespace (@import("../util.zig"));
const imm = Operand.immediate;
const imm8 = Operand.immediate8;
const imm16 = Operand.immediate16;
const imm32 = Operand.immediate32;
const imm64 = Operand.immediate64;
const immSign = Operand.immediateSig... | src/x86/tests/jmp.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day04.txt");
const Board = struct {
numbers : [25]u8,
row_hits : [5]std.StaticBitSet(5),
col_hits : [5]std.StaticBitSet(5),
pub fn init() @This() {
return B... | src/day04.zig |
pub fn _lb(arg_addr: u32) callconv(.C) u8 {
var addr = arg_addr;
return @intToPtr([*c]volatile vu8, addr).?.*;
}
pub fn _lh(arg_addr: u32) callconv(.C) u16 {
var addr = arg_addr;
return @intToPtr([*c]volatile vu16, addr).?.*;
}
pub fn _lw(arg_addr: u32) callconv(.C) u32 {
var addr = arg_addr;
re... | src/psp/sdk/psptypes.zig |
const std = @import("std");
const process = std.process;
const allocator = std.heap.c_allocator;
pub fn main() !void {
var npassed: usize = 0;
var nfailed: usize = 0;
{
const args = try process.argsAlloc(allocator);
defer process.argsFree(allocator, args);
const lox_path = args[1... | util/test.zig |
const std = @import("std");
const alka = @import("alka");
const gui = alka.gui;
const ecs = @import("ecs.zig");
usingnamespace alka.math;
usingnamespace alka.log;
const mlog = std.log.scoped(.app);
pub const State = enum {
reset,
menu,
play,
};
pub var state = State.menu;
pub var score: f32 = 0;
pub va... | examples/example_shooter_game/src/game.zig |
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const lib = b.addStaticLibrary("bog", "src/lib.zig");
lib.setBuildMode(mode);
lib.linkLibC();
const lib_options = b.addOptions();
lib.addOptions("build_opti... | build.zig |