code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
pub const HTTP_DEMAND_CBT = @as(u32, 4);
pub const HTTP_MAX_SERVER_QUEUE_LENGTH = @as(u32, 2147483647);
pub const HTTP_MIN_SERVER_QUEUE_LENGTH = @as(u32, 1);
pub const HTTP_AUTH_ENABLE_BASIC = @as(u32, 1);
pub const HTTP_AUTH_ENABLE_DIGEST = @as(u32, 2);
pub const HTTP_AUTH_ENABLE_NTLM = @as(u32, 4);
pub const HTTP_AUT... | win32/networking/http_server.zig |
const std = @import("std");
const file = std.os.File;
const assert = std.debug.assert;
pub fn main() anyerror!void {
var doubles_count: u64 = 0;
var triples_count: u64 = 0;
var direct_allocator = std.heap.DirectAllocator.init();
defer direct_allocator.deinit();
const allocator = &direct_allocator.allocator;... | src/day2.zig |
const std = @import("std");
const assert = std.debug.assert;
const heap = @import("../heap.zig");
const virt = @import("./vm.zig");
const notification = @import("./notification.zig");
pub const List = std.SinglyLinkedList(@This());
/// The VM's accumulator register
acc: u8 = 0,
/// The VM's instruction pointer
ip: ... | src/interpreter/Frame.zig |
const std = @import("std");
const c = @cImport({
@cInclude("SDL2/SDL.h");
@cInclude("SDL_FontCache.h");
});
const zs = @import("zstack.zig");
const Piece = zs.Piece;
const BitSet = zs.BitSet;
const VirtualKey = zs.input.VirtualKey;
const Key = zs.input.Key;
const Measure = enum {
BlockSide,
WellX,
... | src/window_sdl.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XInputExtension", .global_id = 0 };
pub const EventClass = u32;
pub const KeyCode = u8;
pub const DeviceId = u16;
pub const FP1616 = i32;
/// @brief FP3232
pub const FP3232 = struct {
@"integral": i32,
@"frac": u32,
};
/// @brief ... | src/auto/xinput.zig |
const std = @import("std");
const Lexer = @import("lexer.zig");
const Arguments = @import("args.zig");
const Task = @import("task.zig");
const Date = @import("date.zig");
const testing = std.testing;
const ParseError = Lexer.TokenError || error {
ExpectedDay,
ExpectedMonth,
ExpectedYear,
ExpectedNext... | src/task_parser.zig |
const std = @import("std");
const builtin = @import("builtin");
//extern "c" fn system([*:0]const u8) c_int;
pub fn putInClipboard(allocator: *std.mem.Allocator, utf8: []const u8) anyerror!void {
switch (builtin.os.tag) {
.windows => try win.putInClipboard(allocator, utf8),
else => return error.Cl... | src/clipboard.zig |
const math = @import("std").math;
const gmath = @import("gmath.zig").gmath(f64);
const sdf2 = @import("sdf2.zig");
const brdf = @import("brdf.zig");
const Jazbz = @import("jabz.zig").Jazbz(f64);
const Circle = @import("geom.zig").Circle;
const Line = @import("geom.zig").Line;
const Quad = @import("geom.zig").Quad;
co... | lib/surfacenormal.zig |
const std = @import("std");
const wren = @import("./wren.zig");
const Vm = @import("./vm.zig").Vm;
const Configuration = @import("./vm.zig").Configuration;
pub fn Handle(comptime T: type) type {
return struct {
const Self = @This();
vm: *Vm,
handle: *wren.Handle,
pub fn init(vm: ... | src/zapata/handle.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectError = std.testing.expectError;
const mem = std.mem;
const builtin = @import("builtin");
pub fn foo() anyerror!i32 {
const x = try bar();
return x + 1;
}
pub fn bar() anyerror!i32 {
return 13;
}
pub fn baz() anyerror!i32 {
co... | test/stage1/behavior/error.zig |
const builtin = @import("builtin");
comptime {
_ = @import("cases/align.zig");
_ = @import("cases/alignof.zig");
_ = @import("cases/array.zig");
_ = @import("cases/asm.zig");
_ = @import("cases/atomics.zig");
_ = @import("cases/bitcast.zig");
_ = @import("cases/bool.zig");
_ = @import("... | test/behavior.zig |
const std = @import("../std.zig");
const assert = std.debug.assert;
const Target = std.Target;
const mem = std.mem;
/// Contains all the same data as `Target`, additionally introducing the concept of "the native target".
/// The purpose of this abstraction is to provide meaningful and unsurprising defaults.
/// This s... | lib/std/zig/cross_target.zig |
const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
const native_endian = builtin.target.cpu.arch.endian();
test "reinterpret bytes as integer with nonzero offset" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend ... | test/behavior/ptrcast.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const math = std.math;
const print = std.debug.print;
pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
/// This should only be used in temporary test programs.
pub const allocator = allocator_instance.allocator... | lib/std/testing.zig |
const std = @import("std");
const liu = @import("src/liu/lib.zig");
const assets = @import("src/assets.zig");
const bld = std.build;
const Arch = std.Target.Cpu.Arch;
const Builder = bld.Builder;
const Mode = std.builtin.Mode;
var mode: Mode = undefined;
const ProgData = struct {
name: []const u8,
output: []... | build.zig |
const std = @import("std");
const assertOrPanic = std.debug.assertOrPanic;
const builtin = @import("builtin");
const AtomicRmwOp = builtin.AtomicRmwOp;
const AtomicOrder = builtin.AtomicOrder;
test "cmpxchg" {
var x: i32 = 1234;
if (@cmpxchgWeak(i32, &x, 99, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| ... | test/stage1/behavior/atomics.zig |
usingnamespace @import("../linux.zig");
/// Routing/device hook
pub const NETLINK_ROUTE = 0;
/// Unused number
pub const NETLINK_UNUSED = 1;
/// Reserved for user mode socket protocols
pub const NETLINK_USERSOCK = 2;
/// Unused number, formerly ip_queue
pub const NETLINK_FIREWALL = 3;
/// socket monitoring
pub con... | lib/std/os/bits/linux/netlink.zig |
const std = @import("std");
const builtin = @import("builtin");
const liu = @import("liu");
const wasm = liu.wasm;
pub const WasmCommand = void;
pub usingnamespace wasm;
var wordles: []const u8 = undefined;
var wordle_words: []const u8 = undefined;
const ArrayList = std.ArrayList;
const ext = struct {
extern fn... | src/kilordle.zig |
const std = @import("std");
const io = @import("io.zig");
const Serial = io.Serial;
pub const idt = @import("interrupts/idt.zig");
pub const InterruptFrame = packed struct {
eip: u32,
cs: u32,
eflags: u32,
pub fn print(self: *const @This(), writer: anytype) !void {
const msg =
\\... | src/interrupts.zig |
pub const WLX_VERSION_1_0 = @as(u32, 65536);
pub const WLX_VERSION_1_1 = @as(u32, 65537);
pub const WLX_VERSION_1_2 = @as(u32, 65538);
pub const WLX_VERSION_1_3 = @as(u32, 65539);
pub const WLX_VERSION_1_4 = @as(u32, 65540);
pub const WLX_CURRENT_VERSION = @as(u32, 65540);
pub const WLX_SAS_TYPE_TIMEOUT = @as(u32, 0);
... | win32/security/win_wlx.zig |
pub const _IID_IXmlReader = Guid.initString("7279fc81-709d-4095-b63d-69fe4b0d9030");
pub const _IID_IXmlWriter = Guid.initString("7279fc88-709d-4095-b63d-69fe4b0d9030");
pub const _IID_IXmlResolver = Guid.initString("7279fc82-709d-4095-b63d-69fe4b0d9030");
//------------------------------------------------------------... | win32/data/xml/xml_lite.zig |
const std = @import("std");
const c = @import("internal/c.zig");
const internal = @import("internal/internal.zig");
const log = std.log.scoped(.git);
const git = @import("git.zig");
pub const DescribeOptions = struct {
max_candidate_tags: c_uint = 10,
describe_strategy: DescribeStrategy = .default,
patte... | src/describe.zig |
const std = @import("std");
const Answer = struct { @"0": u32 };
const Point = struct { x: usize, y: usize };
const Variable = enum { X, Y };
const Equality = struct { variable: Variable, value: usize };
const Grid = struct {
const Self = @This();
items: []u8,
height: usize,
width: usize,
buffe... | src/day13.zig |
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
abs2008,
cnmips,
cnmipsp,
crc,
dsp,
dspr2,
dspr3,
eva,
fp64,
fpxx,
ginv,
gp64,
long_calls,
micromips,
mips1,
mi... | lib/std/target/mips.zig |
const std = @import("std");
const warn = std.debug.warn;
const File = std.fs.File;
const files = @import("../Files.zig");
const loadFile = files.loadFile;
pub const c = @cImport({
@cInclude("zstd.h");
});
fn writeCompressed(path: []const u8, data: []const u8, original_size: u32) !void {
var file = try std.fs.... | src/Compress/Compress.zig |
usingnamespace @import("root").preamble;
const Order = std.math.Order;
const rb = lib.containers.rbtree;
const AddrNode = rb.Node(rb_features);
const SizeNode = rb.Node(rb_features);
const AddrTree = rb.Tree(Range, "addr_node", addr_config);
const SizeTree = rb.Tree(Range, "size_node", size_config);
const Placement... | lib/memory/range_alloc.zig |
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const Status = uefi.Status;
const hii = uefi.protocols.hii;
/// Database manager for HII-related data structures.
pub const HIIDatabaseProtocol = extern struct {
_new_package_list: Status, // TODO
_remove_package_list: fn (*const HIIDatabaseProtocol,... | lib/std/os/uefi/protocols/hii_database_protocol.zig |
const std = @import("std");
const builtin = @import("builtin");
const tvg = @import("tinyvg.zig");
const parsing = tvg.parsing;
/// Renders a TinyVG graphic and returns the rendered image.
/// - `temporary_allocator` is used for temporary allocations.
/// - `image_allocator` is used to allocate the final image.
/// -... | src/lib/rendering.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 res... | codegen/build.zig |
usingnamespace @import("psptypes.zig");
pub const clock_t = u32;
pub const suseconds_t = u32;
pub const timeval = extern struct {
tv_sec: time_t,
tv_usec: suseconds_t,
};
pub const timezone = extern struct {
tz_minuteswest: c_int,
tz_dsttime: c_int,
};
pub const SceKernelUtilsMt19937Context = extern s... | src/psp/sdk/psputils.zig |
const std = @import("std");
pub const c = @cImport({
@cInclude("libpq-fe.h");
});
const build_options = @import("build_options");
pub const Builder = @import("./sql_builder.zig").Builder;
pub const Parser = @import("./parser.zig");
const helpers = @import("./helpers.zig");
const Definitions = @import("./definiti... | src/postgres.zig |
pub const E_XML_NOTWF = @as(i32, -1072897501);
pub const E_XML_NODTD = @as(i32, -1072897500);
pub const E_XML_INVALID = @as(i32, -1072897499);
pub const E_XML_BUFFERTOOSMALL = @as(i32, -1072897498);
pub const XHR_PROP_ONDATA_ALWAYS = @as(u32, 0);
pub const XHR_PROP_ONDATA_NEVER = @as(u64, 18446744073709551615);
//----... | deps/zigwin32/win32/data/xml/ms_xml.zig |
const std = @import("std");
/// Returns a struct consisting of an array `index` and a semi-unique `cycle`,
/// which exists to distinguish handles with the same array `index`.
///
/// The `cycle` value is only unique within the incremental period of an
/// unsigned integer with `cycle_bits`, so a larger number of `cyc... | libs/zpool/src/handle.zig |
const testing = @import("std").testing;
const mem = @import("std").mem;
const c = @import("c.zig").c;
/// Errors that GLFW can produce.
pub const Error = error{
/// GLFW has not been initialized.
///
/// This occurs if a GLFW function was called that must not be called unless the library is
/// initia... | libs/mach-glfw/src/errors.zig |
const std = @import("std");
const stdx = @import("stdx");
const platform = @import("platform");
const graphics = @import("graphics");
const Color = graphics.Color;
const ui = @import("../ui.zig");
const Node = ui.Node;
const FrameListPtr = ui.FrameListPtr;
const log = stdx.log.scoped(.scroll_view);
/// By default, sc... | ui/src/widgets/scroll_view.zig |
const std = @import("std");
const string = []const u8;
const input = @embedFile("../input/day09.txt");
pub fn main() !void {
// part 1
{
var iter = std.mem.split(u8, input, "\n");
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const a... | src/day09.zig |
const std = @import("std");
const Builder = std.build.Builder;
const BuildMode = std.builtin.Mode;
const TRACY_PATH = "./tracy/";
fn tryAddTracy(enabled: bool, target: anytype) void {
target.addBuildOption(bool, "enable_tracy", enabled);
if (!enabled) return;
target.addIncludeDir(TRACY_PATH);
target.... | build.zig |
const std = @import("std");
const builtin = @import("builtin");
const zwl = @import("zwl.zig");
const Allocator = std.mem.Allocator;
pub fn Platform(comptime Parent: anytype) type {
return struct {
const Self = @This();
parent: Parent,
file: std.fs.File,
pub fn init(allocator: Allo... | didot-zwl/zwl/src/wayland.zig |
const std = @import("std");
const debug = std.debug;
const assert = std.debug.assert;
const testing = std.testing;
fn interleaveT(comptime T: type) type {
return struct {
const Self = @This();
list1: []const T,
list2: []const T,
const Iterator = struct {
list1: []const... | src/interleave.zig |
const std = @import("std");
const assert = std.debug.assert;
const fmt = std.fmt;
const mem = std.mem;
const net = std.net;
const os = std.os;
const config = @import("config.zig");
const vr = @import("vr.zig");
const usage = fmt.comptimePrint(
\\Usage: tigerbeetle [options]
\\
\\ -h, --help
\\ ... | src/cli.zig |
const std = @import("std");
const warn = std.debug.warn;
const mem = std.mem;
const c = @import("c.zig");
const msg = @import("message.zig");
const api = @import("api.zig");
const Config = @import("config.zig").Config;
const mhs = @import("message_handlers.zig");
pub const Client = struct {
sock: c_int,
config... | src/client.zig |
const std = @import("std");
const uefi = std.os.uefi;
const uefiAllocator = @import("uefi/allocator.zig");
const uefiMemory = @import("uefi/memory.zig");
const uefiConsole = @import("uefi/console.zig");
const uefiSystemInfo = @import("uefi/systeminfo.zig");
const graphics = @import("graphics.zig");
const Color = @imp... | src/kernel/main.zig |
const vcf = @import("vcf.zig");
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const VCF = vcf.VCF;
const Field = vcf.Field;
const fname = "tests/exac.bcf";
const allocator = std.testing.allocator;
const Ai32 = std.ArrayList(i32);
const Af32 = std.ArrayList(f32);
test "that vcf open works" {... | src/vcf_test.zig |
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day18.txt");
const TreeNodeLeaf = struct {
value: i64,
};
const TreeNodeBranch = struct {
left: *TreeNode,
right: *TreeNode,
};
const TreeNodeType = enum {
leaf,
branch,
};
const TreeNodePayload = union(T... | src/day18.zig |
const std = @import("std");
const main = @import("main.zig");
const fs = std.fs;
const testing = std.testing;
const mem = std.mem;
fn printErrorSet(comptime fun: anytype) void {
const info = @typeInfo(@TypeOf(fun));
const ret_type = info.Fn.return_type.?;
inline for (@typeInfo(@typeInfo(ret_type).ErrorUnion... | src/helper.zig |
const std = @import("std");
/// Stolen from https://github.com/ziglang/zig/pull/6272
pub const va_list = switch (std.builtin.target.cpu.arch) {
.aarch64 => switch (std.builtin.target.os.tag) {
.windows => [*c]u8,
.ios, .macosx, .tvos, .watchos => [*c]u8,
else => [1]extern struct {
... | src/types.zig |
const std = @import("std");
const mem = std.mem;
const leb = std.leb;
const math = std.math;
const unicode = std.unicode;
const common = @import("common.zig");
const instruction = @import("instruction.zig");
const Instruction = @import("instruction.zig").Instruction;
const Instance = @import("instance.zig").Instance;
c... | src/module.zig |
const std = @import("std");
const ds = @import("ds/ds.zig");
const stdx = @import("stdx");
const t = stdx.testing;
const log = stdx.log.scoped(.mem);
/// Dupe with new target alignment.
pub fn dupeAlign(alloc: std.mem.Allocator, comptime T: type, comptime A: u8, src: []const T) ![] align (A) T {
var aligned = try ... | stdx/mem.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/day07.txt");
c... | src/day07.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(.{}){};
pub fn flipInstruction(inst: *Instruction) void {
switch (inst.typ) {
Ins... | day_08/src/main.zig |
const std = @import("std");
const data = @embedFile("input.txt");
const STEPS = 40;
const BYTE_MASK: u16 = std.math.maxInt(u8);
fn convertPair(k_str: []const u8) u16 {
return k_str[0] | (@intCast(u16, k_str[1]) << 8);
}
fn combinePair(k1: u16, k2: u16) u16 {
return (k1 & BYTE_MASK) | ((k2 & BYTE_MASK) << 8);... | day14/main.zig |
const std = @import("std");
const mem = std.mem;
const fs = std.fs;
const fileExists = @import("util.zig").fileExists;
const OS = struct {
name: []const u8,
id: []const u8,
};
pub fn osname(allocator: *mem.Allocator) !OS {
var file: fs.File = undefined;
var os_id_prefix: []const u8 = undefined;
va... | src/layers.zig |
const rom = @import("../rom.zig");
const script = @import("../script.zig");
const std = @import("std");
const mem = std.mem;
const li32 = rom.int.li32;
const lu16 = rom.int.lu16;
const lu32 = rom.int.lu32;
pub fn getScriptOffsets(data: []const u8) []const li32 {
var len: usize = 0;
while (true) : (len += 1) ... | src/core/gen4/script.zig |
pub const raw = @cImport({
@cInclude("tinyfx.h");
});
const std = @import("std");
pub const Debug = struct {
pub const print = raw.tfx_debug_print;
pub const blit_rgba = raw.tfx_debug_blit_rgba;
pub const blit_pal = raw.tfx_debug_blit_pal;
pub const set_palette = raw.tfx_debug_set_palette;
};
pub c... | tfx.zig |
const std = @import("std");
const mem = std.mem;
const math = std.math;
const ArrayList = std.ArrayList;
pub const MAX_PAGES = 64 * 1024;
pub const PAGE_SIZE = 64 * 1024;
pub const Memory = struct {
alloc: *mem.Allocator,
min: u32,
max: ?u32 = null,
data: ArrayList([PAGE_SIZE]u8),
pub fn init(all... | src/memory.zig |
const RESOURCE_STATES = @import("d3d12.zig").RESOURCE_STATES;
const windows = @import("windows.zig");
const d3d = @import("d3dcommon.zig");
const d3d11 = @import("d3d11.zig");
const IUnknown = windows.IUnknown;
const UINT = windows.UINT;
const WINAPI = windows.WINAPI;
const GUID = windows.GUID;
const HRESULT = windows.... | modules/platform/vendored/zwin32/src/d3d11on12.zig |
const std = @import("std");
const stdx = @import("stdx.zig");
const t = stdx.testing;
const log = stdx.log.scoped(.closure);
pub fn Closure(comptime Capture: type, comptime Fn: type) type {
stdx.meta.assertFunctionType(Fn);
// The compiler crashes when a created @Type is not used. Declaring a dummy var someh... | stdx/closure.zig |
const std = @import("std");
const mem = std.mem;
const ascii = std.ascii;
const fs = std.fs;
const files = @import("files.zig");
const template = @import("template.zig");
const print = std.debug.print;
const assert = std.debug.assert;
const expect = std.testing.expect;
const Allocator = *std.mem.Allocator;
const File =... | libs/config.zig |
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
/// Returns the logarithm of x for the provided base.
pub fn log(comptime T: type, base: T, x: T) T {
if (base == 2) {
return math.log2(x);
} else if (base == 10) {
return math.log10(x);
} else if ... | lib/std/math/log.zig |
const std = @import("std");
/// Makes all vector and matrix types generic against Real
fn specializeOn(comptime Real: type) type {
return struct {
/// Helper for the swizzle operator.
/// Returns the type fitting the number of swizzle elements
fn SwizzleTypeByElements(comptime i: usize) typ... | src/pkg/zlm.zig |
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
const ir = @import("ir.zig");
const Type = @import("type.zig").Type;
const Value = @import("value.zig").Value;
const TypedValue = @import("TypedValue.zig");
const link = @import("link.zig");
const Module = @import("Module.zig");
const Err... | src-self-hosted/codegen.zig |
const std = @import("std");
const aoc = @import("aoc-lib.zig");
fn syntax(in: []const u8) ![2]usize {
var r = [2]usize{ 0, 0 };
var p2 = try std.BoundedArray(usize, 100).init(0);
var stack = try std.BoundedArray(u8, 100).init(0);
var i: usize = 0;
while (i < in.len) : (i += 1) {
var ch = in... | 2021/10/aoc.zig |
const std = @import("std");
const builtin = @import("builtin");
const debug = std.debug;
const os = std.os;
const io = std.io;
const print_zir = @import("print_zir.zig");
const Module = @import("Module.zig");
const Sema = @import("Sema.zig");
const Zir = @import("Zir.zig");
const Decl = Module.Decl;
pub const is_enab... | src/crash_report.zig |
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
const c = @import("c.zig").c;
const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
const Image = @import("Image.zig");
const Monitor = @import("Monitor.zig");
const Window = @This();
handle: *c.GLFWw... | glfw/src/Window.zig |
const expect = std.testing.expect;
const expectEqualSlices = std.testing.expectEqualSlices;
const expectError = std.testing.expectError;
const std = @import("std");
const mqtt_string = @import("../../mqtt_string.zig");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const FixedHeader = @import("..... | src/mqtt4/packet/subscribe.zig |
const std = @import("std");
const string = []const u8;
const gpa = std.heap.c_allocator;
const knownfolders = @import("known-folders");
const zigmod = @import("../../lib.zig");
const u = @import("./../../util/index.zig");
const common = @import("./../../common.zig");
pub fn execute(args: [][]u8) !void {
const hom... | src/cmd/aquila/install.zig |
pub const VIRTUAL_STORAGE_TYPE_VENDOR_UNKNOWN = Guid.initString("00000000-0000-0000-0000-000000000000");
pub const VIRTUAL_STORAGE_TYPE_VENDOR_MICROSOFT = Guid.initString("ec984aec-a0f9-47e9-901f-71415a66345b");
pub const VIRTUAL_STORAGE_TYPE_DEVICE_UNKNOWN = @as(u32, 0);
pub const VIRTUAL_STORAGE_TYPE_DEVICE_ISO = @as... | win32/storage/vhd.zig |
pub const MIN_EVENT = @as(u32, 100);
pub const BEGIN_NESTED_SYSTEM_CHANGE_NORP = @as(u32, 104);
pub const MAX_EVENT = @as(u32, 104);
pub const MIN_RPT = @as(u32, 0);
pub const DESKTOP_SETTING = @as(u32, 2);
pub const ACCESSIBILITY_SETTING = @as(u32, 3);
pub const OE_SETTING = @as(u32, 4);
pub const APPLICATION_RUN = @a... | win32/system/restore.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 SpellEffect = struct {
damage: i32 = 0,
armor: i32 = 0,
heal: i32 = 0,
manabonus: i32 = 0,
};
const S... | 2015/day22.zig |
const std = @import("std");
fn score_bad(x: u8) usize {
if (x == ')') {
return 3;
} else if (x == ']') {
return 57;
} else if (x == '}') {
return 1197;
} else if (x == '>') {
return 25137;
} else {
return 100000000;
}
}
fn score_good(x: u8) usize {
i... | 10/syntax_scoring.zig |
const std = @import("std");
const c = @import("../c_global.zig").c_imp;
// dross-zig
const Application = @import("application.zig").Application;
const Vector2 = @import("vector2.zig").Vector2;
// ---------------------------------------------------------
// -----------------------------------------
// - Input -
//... | src/core/input.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const math = std.math;
const approxEq = math.approxEq;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const Buffer = std.Buffer;
const fixedBufferStream = std.io.fixedBufferStream;
pub con... | zig/10_2.zig |
const std = @import("std");
const mem = std.mem;
const maxInt = std.math.maxInt;
// RFC 2898 Section 5.2
//
// FromSpec:
//
// PBKDF2 applies a pseudorandom function (see Appendix B.1 for an
// example) to derive keys. The length of the derived key is essentially
// unbounded. (However, the maximum effective search s... | lib/std/crypto/pbkdf2.zig |
const std = @import("std");
const path = std.fs.path;
const mem = std.mem;
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const out_dir = "out";
try std.fs.cwd().makePath(out_dir);
{
c... | ci/srht/update-download-page.zig |
const std = @import("std");
const warn = std.debug.warn;
const span = @import("./span.zig");
const filepath = @import("../filepath/filepath.zig");
const url = @import("../url/url.zig");
const testing = std.testing;
test "fileURI" {
const sample = [][]const u8{
"C:/Windows/System32",
"C:/Go/src/bob.... | src/lsp/span/span_test.zig |
const std = @import("std");
const log = std.log.scoped(.Cuda);
pub const cu = @import("cuda_cimports.zig").cu;
pub const Error = error{
OutOfMemory,
LaunchOutOfResources,
UnexpectedByCudaz,
NotSupported,
NotReady,
// TODO: add more generic errors to allow forward compatibilities with more
... | cudaz/src/cuda_errors.zig |
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
// Returns an error if the end of the string is reached
pub fn skipWhitespace(s: *([]const u8)) !void {
var i: u32 = 0;
while (i < s.*.len and (s.*[i] == ' ' or s.*[i] == '\t' or s.*[i] == '\n' or s.*[i] == '\r')) {
... | src/Parse.zig |
const std = @import("std");
const Postgres = @import("postgres");
const build_options = @import("build_options");
const Pg = Postgres.Pg;
const Result = Postgres.Result;
const Builder = Postgres.Builder;
const FieldInfo = Postgres.FieldInfo;
const Parser = Postgres.Parser;
const testing = std.testing;
const Allocator... | tests/database.zig |
const std = @import("std");
const expectEqual = std.testing.expectEqual;
pub const alloc = std.testing.allocator;
pub fn expect(pred: bool) !void {
try std.testing.expect(pred);
}
pub fn expectError(act_err_union: anytype, exp: anyerror) !void {
return std.testing.expectError(exp, act_err_union);
}
pub fn e... | stdx/testing.zig |
const std = @import("std");
const mach = @import("mach");
const gpu = @import("gpu");
const glfw = @import("glfw");
const App = mach.App(*FrameParams, .{});
const Vertex = struct {
pos: @Vector(4, f32),
uv: @Vector(2, f32),
};
const vertices = [_]Vertex{
.{ .pos = .{ -1, -1, 0, 1 }, .uv = .{ 0, 0 } },
... | shaderexp/main.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Intersector = struct {
coords_encountered: std.AutoHashMap(aoc.Coord2D, void),
coords_crossed: std.AutoHashMap(aoc.Coord2D, void),
fn init(allocator: std.mem.Allocator) Intersector {
return .{
.coords_encountered = st... | src/main/zig/2021/day05.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: tag type, void info" {
try testBasic();
... | test/behavior/type_info.zig |
const std = @import("std");
const utils = @import("utils");
const c = @import("c.zig");
const Direction = @import("common.zig").Direction;
const Script = @import("common.zig").Script;
const Language = @import("common.zig").Language;
const Font = @import("font.zig").Font;
pub const ContentType = enum(u2) {
invalid ... | freetype/src/harfbuzz/buffer.zig |
const std = @import("std");
const root = @import("root");
pub const Cpu = @import("Cpu.zig");
pub const video = @import("video.zig");
pub const Video = video.Video;
const joypad = @import("joypad.zig");
pub const Mmu = @import("Mmu.zig");
const timer = @import("timer.zig");
pub const Timer = timer.Timer;
pub const Sav... | src/main.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Radar = struct {
count: usize,
increases: usize,
window_size: usize,
window_data: std.ArrayList(usize),
window_pos: usize,
window_sum: usize,
pub fn init(window_size: usize) Radar {... | 2021/p01/radar.zig |
const std = @import("std");
const vk = @import("vulkan");
const c = @import("c.zig");
const Allocator = std.mem.Allocator;
const required_device_extensions = [_][]const u8{vk.extension_info.khr_swapchain.name};
const BaseDispatch = vk.BaseWrapper(.{
.CreateInstance,
});
const InstanceDispatch = vk.InstanceWrappe... | examples/graphics_context.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const FixBuf = @import("./fixbuf.zig").FixBuf;
const DynamicReply = @import("./reply.zig").DynamicReply;
const testing = std.testing;
/// A generic type that can capture attributes from a Redis reply.
pub fn WithAttribs(comptime T: type) type {
retur... | src/types/attributes.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const AutoHashMap = std.AutoHashMap;
const PriorityQueue = std.PriorityQueue;
const StringHashMap = std.StringHashMap;
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const trim ... | src/day23.zig |
const GBA = @import("core.zig").GBA;
pub const OAM = struct {
pub const ObjMode = enum(u2) {
Normal,
SemiTransparent,
ObjWindow,
};
pub const FlipSettings = packed struct {
dummy: u3 = 0,
horizontalFlip: u1 = 0,
verticalFlip: u1 = 0,
};
pub const Ob... | GBA/oam.zig |
const x86_64 = @import("../index.zig");
const bitjuggle = @import("bitjuggle");
const std = @import("std");
const formatWithoutFields = @import("../common.zig").formatWithoutFields;
/// The Extended Feature Enable Register.
pub const Efer = packed struct {
/// Enables the `syscall` and `sysret` instructions.
... | src/registers/model_specific.zig |
usingnamespace @import("root").preamble;
const log = lib.output.log.scoped(.{
.prefix = "kernel/debug",
.filter = .info,
});
pub const debug_allocator = &debug_allocator_state.allocator;
extern var __kernel_begin: u8;
extern var __kernel_end: u8;
var debug_info = std.dwarf.DwarfInfo{
.endian = os.platfo... | subprojects/flork/src/kernel/debug.zig |
const std = @import("std");
const os = std.os;
const mem = std.mem;
const kisa = @import("kisa");
const assert = std.debug.assert;
const testing = std.testing;
const Zigstr = @import("zigstr");
pub const Contents = Zigstr;
fn utf8IsTrailing(ch: u8) bool {
// Byte 2,3,4 are all of the form 10xxxxxx. Only the 1st b... | src/text_buffer_array.zig |
test "redeclaration" {
try expectError(
\\let i = 0
\\let i = 1
,
\\redeclaration of 'i'
);
}
test "unexpected token" {
try expectError(
\\if (a b
,
\\expected ')', found 'Identifier'
);
}
test "unexpected arg count" {
try expectError(
\\cons... | tests/error.zig |
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const glfw = @import("glfw");
const gpu = @import("gpu");
const zgpu = @import("zgpu");
const c = zgpu.cimgui;
const zm = @import("zmath");
const zmesh = @import("zmesh");
const zbt = @import("zbullet");
const wgsl = @import("bullet_phy... | samples/bullet_physics_test_wgpu/src/bullet_physics_test_wgpu.zig |
const std = @import("std");
const builtin = @import("builtin");
const IsWasm = builtin.target.isWasm();
const stdx = @import("stdx");
const graphics = @import("graphics");
const Color = graphics.Color;
const ui = @import("ui");
const Row = ui.widgets.Row;
const Text = ui.widgets.Text;
const Padding = ui.widgets.Padding... | ui/examples/converter.zig |
const std = @import("std");
const json = std.json;
const person_module = @import("person.zig");
const date_module = @import("date.zig");
const notes_module = @import("notes.zig");
const util = @import("util.zig");
const logger = std.log.scoped(.ft);
const ArrayListUnmanaged = std.ArrayListUnmanaged;
const Allocator = ... | src/family.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Arena = std.heap.ArenaAllocator;
const Defab = std.StringHashMap([]const u8);
const DefabOrder = std.ArrayList([]const u8);
const Fab = aoc.StringMultimap([]const u8);
const MoleculeSet = std.StringHashMap(void);
pub fn run(problem: *aoc.Problem) !ao... | src/main/zig/2015/day19.zig |
const c = @import("c.zig");
pub const Error = error{
CannotOpenResource,
UnknownFileFormat,
InvalidFileFormat,
InvalidVersion,
LowerModuleVersion,
InvalidArgument,
UnimplementedFeature,
InvalidTable,
InvalidOffset,
ArrayTooLarge,
MissingModule,
MissingProperty,
Inval... | freetype/src/error.zig |
const std = @import("std");
const image_info = @import("image_info.zig");
const dbg = std.log.debug;
pub const magic = 0x2badb002;
/// Multiboot specification: https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
pub const MultibootInfo = packed struct {
pub const MemoryMapEntry = packed struct { ... | kernel/multiboot.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(stdout: anytype) anyerror!void {
var input_ = try input.readFile("inputs/day17");
defer input_.deinit();
var part1_result: i64 = undefined;
var part2_result: usize = undefined;
try solve(&input_, &part1_result, &part2_resu... | src/day17.zig |