code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const fun = @import("fun");
const nds = @import("index.zig");
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const fs = nds.fs;
const heap = std.heap;
const mem = std.mem;
const os = std.os;
const rand = std.rand;
const lu16 = fun.platform.lu16;
const lu32 = fun.platform.lu32;
const lu64 = ... | src/test.zig |
const x86 = @import("machine.zig");
const std = @import("std");
const assert = std.debug.assert;
usingnamespace @import("types.zig");
const AvxOpcode = x86.avx.AvxOpcode;
const Mnemonic = x86.Mnemonic;
const Instruction = x86.Instruction;
const Machine = x86.Machine;
const Operand = x86.operand.Operand;
const Immed... | src/x86/database.zig |
const std = @import("std");
const time = std.time;
const Timer = time.Timer;
const hash_map = std.hash_map;
var timer: Timer = undefined;
pub fn main() !void {
const stdout = std.io.getStdOut().outStream();
timer = try Timer.start();
var allocator = std.heap.c_allocator;
var result: u64 = 0;
cons... | insert-strings.zig |
const std = @import("std");
const clap = @import("clap");
const fs = std.fs;
const Elf = @import("Elf.zig");
var global_alloc = std.heap.GeneralPurposeAllocator(.{}){};
const gpa = &global_alloc.allocator;
pub fn main() anyerror!void {
const stderr = std.io.getStdErr().writer();
const stdout = std.io.getStdO... | src/main.zig |
const builtin = @import("builtin");
const clap = @import("clap");
const folders = @import("folders");
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const log = std.log;
const math = std.math;
const mem = std.mem;
const os = std.os;
pub const bit = ... | src/common/util.zig |
const std = @import("std");
const Type = @import("Type.zig");
const Tokenizer = @import("Tokenizer.zig");
const Compilation = @import("Compilation.zig");
const Source = @import("Source.zig");
const Tree = @This();
pub const Token = struct {
id: Id,
/// This location contains the actual token slice which might... | src/Tree.zig |
const std = @import("std");
const WavContents = @import("read_wav.zig").WavContents;
const Span = @import("basics.zig").Span;
// FIXME - no effort at all has been made to optimize the sampler module
// FIXME - use a better resampling filter
// TODO - more complex looping schemes
// TODO - allow sample_rate to be contr... | src/zang/mod_sampler.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const expect = std.testing.expect;
const test_allocator = std.testing.allocator;
pub fn beatToSecs(bpm: f64) callconv(.Inline) f64 {
return 60.0 / bpm;
}
pub fn tickInSecs(bpm: f64, resolution: i64) callconv(.Inline) f64 {
return beatToSecs(bpm) ... | src/muzig-time.zig |
pub const FSCTL_DFS_BASE = @as(u32, 6);
pub const DFS_VOLUME_STATES = @as(u32, 15);
pub const DFS_VOLUME_STATE_OK = @as(u32, 1);
pub const DFS_VOLUME_STATE_INCONSISTENT = @as(u32, 2);
pub const DFS_VOLUME_STATE_OFFLINE = @as(u32, 3);
pub const DFS_VOLUME_STATE_ONLINE = @as(u32, 4);
pub const DFS_VOLUME_STATE_RESYNCHRON... | win32/storage/distributed_file_system.zig |
pub const WSMAN_FLAG_REQUESTED_API_VERSION_1_0 = @as(u32, 0);
pub const WSMAN_FLAG_REQUESTED_API_VERSION_1_1 = @as(u32, 1);
pub const WSMAN_OPERATION_INFOV1 = @as(u32, 0);
pub const WSMAN_OPERATION_INFOV2 = @as(u32, 2864434397);
pub const WSMAN_DEFAULT_TIMEOUT_MS = @as(u32, 60000);
pub const WSMAN_FLAG_RECEIVE_RESULT_N... | win32/system/remote_management.zig |
const std = @import("std");
const sort = std.sort;
const Allocator = std.mem.Allocator;
const PriorityQueue = std.PriorityQueue;
const testing = std.testing;
const DefaultPrng = std.rand.DefaultPrng;
const ArrayList = std.ArrayList;
fn less_than(a: i32, b: i32) std.math.Order {
return std.math.order(a, b);
}
fn gr... | streaming-median/src/main.zig |
const std = @import("std");
const gk = @import("gamekit");
const math = gk.math;
const gfx = gk.gfx;
const draw = gfx.draw;
var rng = std.rand.DefaultPrng.init(0x12345678);
pub fn range(comptime T: type, at_least: T, less_than: T) T {
if (@typeInfo(T) == .Int) {
return rng.random().intRangeLessThanBiased(... | examples/offscreen.zig |
const std = @import("std");
const math = @import("kira/math/common.zig");
const UniqueFixedList = @import("kira/utils.zig").UniqueFixedList;
usingnamespace @import("sharedtypes.zig");
pub fn ObjectGeneric(comptime maxtag: u64, comptime complist: type) type {
return struct {
const Self = @This();
... | src/kiragine/ecs.zig |
pub fn portio_cpux(offset: usize) *volatile u32 {
return @intToPtr(*volatile u32, @as(usize, 0x01C2_0800) + offset);
}
pub fn portio_cpus(offset: usize) *volatile u32 {
return @intToPtr(*volatile u32, @as(usize, 0x01F0_2C00) + offset);
}
fn verify_port_pin(comptime port: u8, comptime pin: u5) void {
switc... | src/platform/pine_aarch64/regs.zig |
const std = @import("std");
const assert = std.debug.assert;
const Camera = @import("Camera.zig");
const Material = @import("Material.zig");
const zp = @import("../../zplay.zig");
const drawcall = zp.graphics.common.drawcall;
const Context = zp.graphics.common.Context;
const ShaderProgram = zp.graphics.common.ShaderPro... | src/graphics/3d/Skybox.zig |
const std = @import("std");
const builtin = @import("builtin");
const build_options = @import("build_options");
const data = @import("../common/data.zig");
const assert = std.debug.assert;
const print = std.debug.print;
const trace = build_options.trace;
const Player = data.Player;
const ID = data.ID;
pub const Ar... | src/lib/common/protocol.zig |
const std = @import("std");
const dast = @import("main.zig");
const testing = std.testing;
test "slice()" {
const arr = "hello";
try testing.expectEqualStrings("hell", try dast.slice(u8, arr, 0, 4));
try testing.expectEqualStrings("hello", try dast.slice(u8, arr, 0, null));
try testing.expectEqualStri... | src/test.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const testing = std.testing;
const ColorBitmap = @import("ColorBitmap.zig");
width: u32,
height: u32,
indices: []u8,
const IndexedBitmap = @This();
pub fn init(allocator: Allocator, width: u32, height: u32) !IndexedBitmap {
var self = IndexedBitma... | src/IndexedBitmap.zig |
const std = @import("std");
const api = @import("buzz_api.zig");
export fn print(vm: *api.VM) c_int {
_ = std.io.getStdOut().write(std.mem.sliceTo(vm.bz_peek(0).bz_valueToString().?, 0)) catch {
// TODO: throw something?
return -1;
};
_ = std.io.getStdOut().write("\n") catch {
// TO... | lib/buzz_std.zig |
const std = @import("../std.zig");
const crypto = std.crypto;
const debug = std.debug;
const mem = std.mem;
pub const HmacMd5 = Hmac(crypto.hash.Md5);
pub const HmacSha1 = Hmac(crypto.hash.Sha1);
pub const sha2 = struct {
pub const HmacSha224 = Hmac(crypto.hash.sha2.Sha224);
pub const HmacSha256 = Hmac(crypto... | lib/std/crypto/hmac.zig |
const std = @import("../../std.zig");
const os = std.os;
const mem = std.mem;
const net = std.net;
const time = std.time;
const builtin = std.builtin;
const testing = std.testing;
const Socket = @This();
/// A socket-address pair.
pub const Connection = struct {
socket: Socket,
address: net.Address,
};
/// ... | lib/std/x/os/Socket.zig |
const std = @import("std");
const bld = std.build;
const Builder = bld.Builder;
const Step = bld.Step;
const common_flags = [_][]const u8 {
"-fstrict-aliasing",
};
const common_c_flags = common_flags;
const common_cpp_flags = common_flags ++ [_][]const u8{
"-fno-rtti",
"-fno-exceptions",
};
const spvcross... | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const log = std.log.scoped(.vr);
pub const log_level: std.log.Level = .debug;
const config = @import("config.zig");
const MessageBus = @import("message_bus.zig").MessageBusReplica;
const Message = @import("message_bus.zi... | src/vr.zig |
const utils = @import("utils");
const georgios = @import("georgios");
const Info = georgios.ProcessInfo;
const platform = @import("platform.zig");
const pthreading = platform.impl.threading;
const kernel = @import("kernel.zig");
const memory = @import("memory.zig");
const print = @import("print.zig");
const MappedList... | kernel/threading.zig |
const std = @import("std");
const test_input = @embedFile("day-19_test-input");
pub fn main() !void {
std.debug.print("--- Day 19 ---\n", .{});
}
test "test-input" {
const input = test_input;
var alloc = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer alloc.deinit();
const scanners ... | day-19.zig |
const std = @import("std");
const real_input = "target area: x=60..94, y=-171..-136";
pub fn main() !void {
std.debug.print("--- Day 17 ---\n", .{});
const target = try parseRect(removePrefix(real_input));
const result = findHighestAndCount(target);
std.debug.print("highest achievable Y is {}\n", .{ r... | day-17.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_assignment.zig |
const std = @import("std");
pub fn Matrix(comptime T: type, widt: usize, heigh: usize) type {
return packed struct {
const Self = @This();
pub const width = widt;
pub const height = heigh;
data: [height * width]T align(@alignOf(T)),
comptime width: usize = width,
c... | src/util.zig |
const std = @import("std");
const print = std.debug.print;
const _chunk = @import("./chunk.zig");
const _value = @import("./value.zig");
const _obj = @import("./obj.zig");
const _vm = @import("./vm.zig");
const VM = _vm.VM;
const Chunk = _chunk.Chunk;
const OpCode = _chunk.OpCode;
const ObjFunction = _obj.ObjFunction;... | src/disassembler.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const root = @import("root");
const c = std.c;
const math = std.math;
const assert = std.debug.assert;
const os = std.os;
const fs = std.fs;
const mem = std.mem;
const meta = std.meta;
const trait = meta.trait;
const File = std.fs.File;
pub const Mod... | lib/std/io.zig |
const builtin = @import("builtin");
const std = @import("../../std.zig");
const maxInt = std.math.maxInt;
usingnamespace @import("../bits.zig");
pub usingnamespace switch (builtin.arch) {
.mips, .mipsel => @import("linux/errno-mips.zig"),
else => @import("linux/errno-generic.zig"),
};
pub usingnamespace switc... | lib/std/os/bits/linux.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const info = std.log.info;
const print = std.debug.print;
const fmt = std.fmt;
const utils = @import("utils.zig");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const Node = struct {
allo: *std.mem.Allocator = undefined,
is_root: bool = f... | day_07/src/main.zig |
const std = @import("../index.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const AtomicRmwOp = builtin.AtomicRmwOp;
const AtomicOrder = builtin.AtomicOrder;
const Loop = std.event.Loop;
/// many producer, many consumer, thread-safe, runtime configurable buffer size
/// when buffer is emp... | std/event/channel.zig |
const std = @import("std");
const assert = std.debug.assert;
const Atomic = std.atomic.Atomic;
const Sync = packed struct {
/// Tracks the number of threads not searching for Tasks
idle: u14 = 0,
/// Tracks the number of threads spawned
spawned: u14 = 0,
/// What you see is what you get
unused:... | src/thread_pool.zig |
pub fn isNeutral(cp: u21) bool {
if (cp < 0x0 or cp > 0xe007f) return false;
return switch (cp) {
0x0...0x1f => true,
0x7f...0x9f => true,
0xa0 => true,
0xa9 => true,
0xab => true,
0xb5 => true,
0xbb => true,
0xc0...0xc5 => true,
0xc7...0x... | src/components/autogen/DerivedEastAsianWidth.zig |
pub const e_ident = struct {
pub const EI_OSABI = enum(u8) {
SystemV = 0x00,
HP_UX = 0x01,
NetBSD = 0x02,
Linux = 0x03,
GNU_Hurd = 0x04,
Solaris = 0x06,
AIX = 0x07,
IRIX = 0x08,
FreeBSD = 0x09,
Tru64 = 0x0A,
Novell_Modesto = 0x0... | src/FileHeader.zig |
pub const ARRAY_SEP_CHAR = @as(u32, 9);
pub const WPCCHANNEL = @as(u32, 16);
pub const WPC_SETTINGS_LOCATE = @as(u32, 20);
pub const WPC_SETTINGS_MODIFY = @as(u32, 21);
pub const WPC_APP_LAUNCH = @as(u32, 22);
pub const WPC_SYSTEM = @as(u32, 23);
pub const WPC_WEB = @as(u32, 24);
pub const WPCPROV_TASK_SettingChange = ... | win32/system/parental_controls.zig |
pub const OPTION_PAD = @as(u32, 0);
pub const OPTION_SUBNET_MASK = @as(u32, 1);
pub const OPTION_TIME_OFFSET = @as(u32, 2);
pub const OPTION_ROUTER_ADDRESS = @as(u32, 3);
pub const OPTION_TIME_SERVERS = @as(u32, 4);
pub const OPTION_IEN116_NAME_SERVERS = @as(u32, 5);
pub const OPTION_DOMAIN_NAME_SERVERS = @as(u32, 6);
... | win32/network_management/dhcp.zig |
const std = @import("../std.zig");
const maxInt = std.math.maxInt;
const builtin = @import("builtin");
const iovec = std.os.iovec;
const iovec_const = std.os.iovec_const;
extern "c" fn __errno() *c_int;
pub const _errno = __errno;
pub const dl_iterate_phdr_callback = fn (info: *dl_phdr_info, size: usize, data: ?*anyo... | lib/std/c/openbsd.zig |
const std = @import("std");
const common = @import("../_common_utils.zig");
const FV = common.FV;
pub const HSET = struct {
key: []const u8,
fvs: []const FV,
/// Instantiates a new HSET command.
pub fn init(key: []const u8, fvs: []const FV) HSET {
return .{ .key = key, .fvs = fvs };
}
... | src/commands/hashes/hset.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/day02.txt");
c... | src/day02.zig |
const std = @import("std");
const utf8 = @import("../unicode/utf8/index.zig");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const mem = std.mem;
const warn = std.debug.warn;
pub fn lastIndexFunc(input: []const u8, f: fn (rune: i32) bool) anyerror!?usize {
return lastIndexFuncInternal(inpu... | src/strings/strings.zig |
const std = @import("std");
const builtin = std.builtin;
const common = @import("../common.zig");
const crypto = std.crypto;
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Field = common.Field;
const NonCanonicalError = std.crypto.errors.NonCanonicalError;
const NotSquareError = std.crypt... | lib/std/crypto/pcurves/p256/scalar.zig |
const Plan9 = @This();
const link = @import("../link.zig");
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const aout = @import("Plan9/aout.zig");
const codegen = @import("../codegen.zig");
const trace = @import("../tracy.zig").trace;
const File = link.File;
const build_opt... | src/link/Plan9.zig |
const std = @import("std");
const stdin = std.io.getStdIn().reader();
const stdout = std.io.getStdOut().writer();
const eql = std.mem.eql;
const interpreter = @import("./interpreter.zig");
const Forth = interpreter.ForthInterpreter;
const ForthError = interpreter.InterpreterError;
const Word = @import("./word.zig").Wor... | src/main.zig |
const std = @import("std");
const mem = std.mem;
const ascii = std.ascii;
const assert = std.debug.assert;
const zunicode = @import("zunicode");
const nodes = @import("nodes.zig");
const strings = @import("strings.zig");
const Options = @import("options.zig").Options;
const scanners = @import("scanners.zig");
const Re... | src/inlines.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const bog = @import("bog.zig");
const Node = bog.Node;
const Tree = bog.Tree;
const TokenIndex = bog.Token.Index;
const RegRef = bog.RegRef;
const Errors = bog.Errors;
const util = @import("util.zig");
pu... | src/compiler.zig |
const std = @import("std");
const builtin = @import("builtin");
const ThreadPool = @import("thread_pool");
/// Global thread pool which mimics other async runtimes
var thread_pool: ThreadPool = undefined;
/// Global allocator which mimics other async runtimes
pub var allocator: *std.mem.Allocator = undefined;
/// Zi... | benchmarks/zig/async.zig |
const std = @import("std");
const mem = std.mem;
const ModifierLetter = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 688,
hi: u21 = 125259,
pub fn init(allocator: *mem.Allocator) !ModifierLetter {
var instance = ModifierLetter{
.allocator = allocator,
.array = try allocator.alloc... | src/components/autogen/DerivedGeneralCategory/ModifierLetter.zig |
const std = @import("std");
const expect = std.testing.expect;
const test_allocator = std.testing.allocator;
const Allocator = std.mem.Allocator;
const School = struct {
const Self = @This();
allocator: Allocator,
fish: [9]u64,
pub fn load(allocator: Allocator, str: []const u8) !Self {
var fis... | day06/src/main.zig |
const std = @import("std");
const m = @import("../math/math.zig");
pub const SdfInfo = @import("sdf_info.zig").SdfInfo;
pub const appendNoMatCheck = @import("sdf_info.zig").appendNoMatCheck;
pub const IterationContext = @import("iteration_context.zig").IterationContext;
pub const Templates = @import("shader_templates.z... | src/sdf/sdf.zig |
const std = @import("std");
const builtin = @import("builtin");
const optz = @import("optz");
const slimy = @import("slimy.zig");
const version = @import("version.zig");
pub fn main() u8 {
const stdout = std.io.getStdOut();
const stderr = std.io.getStdErr();
var arena = std.heap.ArenaAllocator.init(std.he... | src/main.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 Action = enum {
toggle,
on,
off,
};
const Vec2 = struct {
x: u32,
y: u32,
};
const Rect = struct {... | 2015/day6.zig |
const std = @import("std");
const version = @import("version");
const zzz = @import("zzz");
const uri = @import("uri");
const api = @import("api.zig");
const utils = @import("utils.zig");
const ThreadSafeArenaAllocator = @import("ThreadSafeArenaAllocator.zig");
const Self = @This();
const Allocator = std.mem.Allocator... | src/Dependency.zig |
const std = @import("std");
const stb = @import("stb_image");
const ImGuiImplementation = @import("imguiImplementation.zig");
const TimeManager = @import("timeManager.zig");
const zt = @import("../zt.zig");
const gl = @import("gl");
usingnamespace @import("glfw");
usingnamespace @import("gl");
usingnamespace @import("... | src/zt/app.zig |
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
/// Can be one of "ptx" or "fatbin". "cubin" don't work, because it implies a main.
/// Fatbin contains device specialized assembly for all GPU arch supported
/// by this compiler. This provides faster startu... | cudaz/sdk.zig |
const std = @import("std");
const zap = @import("zap");
const Socket = @import("socket.zig").Socket;
const os = std.os;
const net = std.net;
const mem = std.mem;
const testing = std.testing;
const print = std.debug.print;
const assert = std.debug.assert;
pub const Reactor = struct {
pub const Handle = struct {
... | reactor.zig |
const std = @import("std");
pub const BuildStep = struct {
pub const Child = union(enum) {
MacOSBundle: *MacOSBundleStep,
DefaultStep: *std.build.LibExeObjStep,
};
builder: *std.build.Builder,
options: Options,
child: Child,
step: *std.build.Step,
source_path: []const u8,
... | src/build_util.zig |
const std = @import("std");
pub const platform = @import("modules/platform/build.zig");
pub const graphics = @import("modules/graphics/build.zig");
pub const audio = @import("modules/audio/build.zig");
pub const algo = @import("modules/algo/build.zig");
const all_modules = .{
platform,
graphics,
audio,
... | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const Obj = @import("./object.zig").Obj;
const Value = @import("./value.zig").Value;
const Entry = struct {
key: ?*Obj.String,
value: Value,
pub fn isTombstone(self: *Entry) bool {
if (self.key != null) {
return false;
... | src/table.zig |
const std = @import("std");
const arm_m = @import("arm_m");
const warn = @import("nonsecure-common/debug.zig").warn;
const port = @import("ports/" ++ @import("build_options").BOARD ++ "/nonsecure.zig");
const port_timer = @import("ports/" ++ @import("build_options").BOARD ++ "/timer.zig");
const nonsecure_init = @impor... | examples/nonsecure-bench-latency.zig |
const std = @import("std");
const utils = @import("utils.zig");
const expect = std.testing.expect;
const log = std.log;
pub const BibParser = struct {
bib: Bibliography,
idx: u32,
bytes: []const u8,
allocator: *std.mem.Allocator,
pub const Error = error {
SyntaxError,
OutOfMemory,
... | src/bibtex.zig |
// DO NOT MODIFY. This is not actually a source file; it is a textual representation of generated code.
// Use only for debugging purposes.
// Auto-generated constructor
// Access: public
Method <init> : V
(
// (no arguments)
) {
ALOAD 0
// Method descriptor: ()V
INVOKESPECIAL io/quarkus/runtime/Appl... | target/generated-sources/gizmo/io/quarkus/runner/ApplicationImpl1.zig |
const std = @import("std");
const builtin = @import("builtin");
const c = @cImport({
@cInclude("zlib.h");
@cInclude("stddef.h");
});
const alignment = @alignOf(c.max_align_t);
const Allocator = std.mem.Allocator;
pub const Error = error{
StreamEnd,
NeedDict,
Errno,
StreamError,
DataError,
... | .gyro/zig-zlib-mattnite-github.com-eca7a5ba/pkg/src/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
/// max str len of 512
pub fn L(str: []const u8) [512]u16 {
var result = []u16{0} ** 512;
const last = std.unicode.utf8ToUtf16Le(result[0..], str) catch unreachable;
result[last] = 0;
return result;
}
pub fn clamp(comptime T: type, x: T... | src/app/util.zig |
const std = @import("std");
const testing = std.testing;
const parser = @import("parser.zig");
const traverser = @import("traverser.zig");
pub const Traverser = traverser.Traverser;
pub const totalSize = traverser.totalSize;
pub const Node = struct {
name: []const u8,
props: []Prop,
root: *Node,
parent... | src/dtb.zig |
const std = @import("std");
const serializer = @import("serializer.zig");
pub const JsonLexicon: serializer.Lexicon = .{ .convert = _jsonLexConv, .parse = _jsonLexParse };
fn _jsonLexConv(alloc: *std.mem.Allocator, tree: *serializer.Tree) []const u8 {
var bytes = std.ArrayList(u8).init(alloc);
_jsonLexInner(t... | src/serializer_json.zig |
const std = @import("std");
const util = @import("util");
const input = @embedFile("12.txt");
const actions = comptime blk: {
@setEvalBranchQuota(input.len * 20);
var buf: []const Action = &[_]Action{};
var lines = std.mem.tokenize(input, "\n");
while (lines.next()) |line| {
const param: compti... | 2020/12.zig |
usingnamespace @import("root").preamble;
const ImageRegion = lib.graphics.image_region.ImageRegion;
const ScrollingRegion = lib.graphics.scrolling_region.ScrollingRegion;
const PixelFormat = lib.graphics.pixel_format.PixelFormat;
const Color = lib.graphics.color.Color;
pub fn GlyphPrinter(comptime max_width: usize, c... | lib/graphics/glyph_printer.zig |
const std = @import("std");
const upaya = @import("upaya");
const tilescript = @import("tilescript.zig");
pub fn import(file: []const u8) !tilescript.Map {
var bytes = try std.fs.cwd().readFileAlloc(upaya.mem.allocator, file, std.math.maxInt(usize));
var tokens = std.json.TokenStream.init(bytes);
// TODO:... | tilescript/tilekit_importer.zig |
const std = @import("index.zig");
const debug = std.debug;
const assert = debug.assert;
const math = std.math;
const builtin = @import("builtin");
const mem = @This();
const meta = std.meta;
const trait = meta.trait;
pub const Allocator = struct {
pub const Error = error{OutOfMemory};
/// Allocate byte_count ... | std/mem.zig |
const std = @import("std");
const mach = @import("mach");
const gpu = @import("gpu");
const glfw = @import("glfw");
const zm = @import("zmath");
const zigimg = @import("zigimg");
const Vertex = @import("cube_mesh.zig").Vertex;
const vertices = @import("cube_mesh.zig").vertices;
const UniformBufferObject = struct {
... | examples/textured-cube/main.zig |
const std = @import("std");
const mem = std.mem;
/// Print the string as a Zig identifier escaping it with @"" syntax if needed.
pub fn formatId(
bytes: []const u8,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
if (isValidId(bytes)) {
return writer.wri... | lib/std/zig/fmt.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Ticket = std.ArrayList(u16);
const Field = struct {
name: []const u8,
from1: u16,
to1: u16,
from2: u16,
to2: u16,
fn contains(self: *const Field, what: u16) bool {
return (what >= self.from1 and what <= self.to1)
... | src/main/zig/2020/day16.zig |
const std = @import("std");
const print = std.debug.print;
usingnamespace @import("value.zig");
usingnamespace @import("chunk.zig");
usingnamespace @import("scanner.zig");
usingnamespace @import("parser.zig");
usingnamespace @import("gc.zig");
usingnamespace @import("vm.zig");
pub var heap: Heap = undefined;
pub c... | zvm/src/heap.zig |
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const fs = std.fs;
const codegen = @import("../codegen/c.zig");
const link = @import("../link.zig");
const tr... | src/link/C.zig |
const std = @import("std");
const mem = std.mem;
const Neutral = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 0,
hi: u21 = 917631,
pub fn init(allocator: *mem.Allocator) !Neutral {
var instance = Neutral{
.allocator = allocator,
.array = try allocator.alloc(bool, 917632),
};
... | src/components/autogen/DerivedEastAsianWidth/Neutral.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const odbc = @import("odbc");
const ResultSet = @import("result_set.zig").ResultSet;
const FetchResult = @import("result_set.zig").FetchResult;
const sql_parameter = @import("parameter.zig");
const ParameterBucket = sql_parameter.ParameterBucket;
cons... | src/connection.zig |
const std = @import("std");
const log = std.log.scoped(.dynamic_tree);
const assert = std.debug.assert;
const basic_type = @import("basic_type.zig");
const IndexLinkList = @import("IndexLinkList.zig");
const Rect = basic_type.Rect;
const Vec2 = basic_type.Vec2;
const Index = basic_type.Index;
const node_null = basic_ty... | src/physic/DynamicTree.zig |
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const gc = @cImport({
@cInclude("gc.h");
});
/// Returns the Allocator used for APIs in Zig
pub fn allocator() Allocator {
// Initialize libgc
if (gc.GC_is_in... | src/gc.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 Object = struct {
cost: i32,
damage: i32,
armor: i32,
};
const Carac = struct {
points: i32,
dama... | 2015/day21.zig |
const std = @import("std");
const util = @import("util.zig");
const fs = std.fs;
const io = std.io;
const math = std.math;
const mem = std.mem;
const os = std.os;
const testing = std.testing;
pub const bufsize = mem.page_size * 2;
pub fn Fifo(comptime buffer_type: std.fifo.LinearFifoBufferType) type {
return std... | src/common/io.zig |
const Allocator = std.mem.Allocator;
const FormatInterface = @import("../format_interface.zig").FormatInterface;
const ImageFormat = image.ImageFormat;
const ImageInStream = image.ImageInStream;
const ImageInfo = image.ImageInfo;
const ImageSeekStream = image.ImageSeekStream;
const PixelFormat = @import("../pixel_forma... | src/formats/netpbm.zig |
const std = @import("std");
const version = @import("version");
const zfetch = @import("zfetch");
const tar = @import("tar");
const zzz = @import("zzz");
const uri = @import("uri");
const Dependency = @import("Dependency.zig");
const Package = @import("Package.zig");
const utils = @import("utils.zig");
const Allocator... | src/api.zig |
const std = @import("std");
const testing = std.testing;
const assert = std.debug.assert;
pub fn RingBuffer(comptime T: type) type {
return RingBufferAligned(T, null);
}
pub fn RingBufferAligned(comptime T: type, comptime alignment: ?u29) type {
if (alignment) |a| {
if (a == @alignOf(T)) {
... | src/ring_buffer.zig |
const std = @import("std");
const Components = @import("components.zig").Components;
const Entity = @import("Entity.zig");
const Entities = @import("Entities.zig");
const MAX_ENTITIES = @import("./main.zig").MAX_ENTITIES;
const Bitset = std.bit_set.StaticBitSet(MAX_ENTITIES);
const benchmark = @import("benchmark");
/... | src/join.zig |
const builtin = @import("builtin");
const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const dlist = @import("dlist.zig");
const ListNode = dlist.ListNode;
const params = @import("params.zig");
//===========================================================================... | src/ziegfried/hblock.zig |
const std = @import("std");
const pkg = std.build.Pkg{
.name = "zsw",
.path = .{ .path = "src/main.zig" },
};
pub fn build(b: *std.build.Builder) !void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const examples = try getExamples(b.allocator);
addTe... | build.zig |
const std = @import("std");
const allocator = std.heap.page_allocator;
const assert = std.debug.assert;
const hash = std.hash;
const math = std.math;
const mem = std.mem;
const deflate = @import("./deflate.zig");
const time = @import("./time.zig");
const zip = @import("./zip.zig");
const UINT16_MAX = math.maxInt(u16)... | src/hwzip.zig |
const std = @import("std");
const shared = @import("shared.zig");
const zsw = @import("zsw");
const builtin = @import("builtin");
const log = std.log.scoped(.subcommand);
pub const SUBCOMMANDS = [_]type{
@import("subcommands/basename.zig"),
@import("subcommands/dirname.zig"),
@import("subcommands/false.zi... | src/subcommands.zig |
const std = @import("std");
const Logger = struct {
is_enabled: bool,
show_thread_id: bool,
pub fn print(comptime self: Logger, comptime fmt: []const u8, args: anytype) void {
if (!self.is_enabled) return;
warn(self.show_thread_id, fmt, args);
}
pub fn deepPrint(comptime self: Log... | src/core/debug.zig |
pub const Kind = enum {
L,
T,
V,
LV,
LVT,
};
/// `syllableType` maps the code point to its Hangul Syllable Type.
pub fn syllableType(cp: u21) ?Kind {
return switch (cp) {
0x1100...0x115F => .L,
0xA960...0xA97C => .L,
0x1160...0x11A7 => .V,
0xD7B0...0xD7C6 => .V,... | .gyro/ziglyph-jecolon-github.com-c37d93b6/pkg/src/autogen/hangul_syllable_type.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 internal_debug = @import("internal_debug.zig");
/// Makes the context of the specified window current for the calling threa... | src/opengl.zig |
const std = @import("std");
const Order = std.math.Order;
const Type = @import("type.zig").Type;
const Value = @import("value.zig").Value;
const RangeSet = @This();
const SwitchProngSrc = @import("Module.zig").SwitchProngSrc;
ranges: std.ArrayList(Range),
pub const Range = struct {
first: Value,
last: Value,
... | src/RangeSet.zig |
const std = @import("../std.zig");
const mem = std.mem;
const math = std.math;
const debug = std.debug;
const assert = std.debug.assert;
const testing = std.testing;
const htest = @import("test.zig");
pub const State = struct {
pub const BLOCKBYTES = 48;
pub const RATE = 16;
// TODO: https://github.com/z... | lib/std/crypto/gimli.zig |
const std = @import("std");
const lexer = @import("lexer.zig");
const parser = @import("parser.zig");
const Ast = parser.Ast;
const AstNode = parser.AstNode;
const Token = lexer.Token;
const ArenaAllocator = std.heap.ArenaAllocator;
const alloc = std.testing.allocator;
const expectEqualSlices = std.testing.expectEqualS... | zig/src/_tests.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const c = @import("../../c.zig");
const zupnp = @import("../../lib.zig");
const xml = @import("xml");
const Manager = @This();
const logger = std.log.scoped(.@"zupnp.upnp.device.Manager");
const Registered... | src/upnp/device/manager.zig |
const std = @import("std");
const Point = struct {
x: u32,
y: u32,
fn parse(text: []const u8) !Point {
var it = std.mem.tokenize(u8, text, ",");
const x_str = it.next() orelse return error.NoX;
const y_str = it.next() orelse return error.NoY;
if (it.next() != null)
... | src/05.zig |
const std = @import("std");
const testing = std.testing;
pub const ROM = struct {
preamble_length: usize,
line_count: usize,
numbers: [1500]usize,
seen: std.AutoHashMap(usize, void),
pub fn init(len: usize) ROM {
const allocator = std.heap.page_allocator;
var self = ROM{
... | 2020/p09/rom.zig |
const std = @import("std");
const print = std.debug.print;
pub fn main() anyerror!void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
var allocator = &gpa.allocator;
var file = try std.fs.cwd().openFile(
"./inputs/day16.txt",
.{
.read = true,
... | src/day16.zig |