code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const parser = @import("parser.zig").Parser;
const utils = @import("utils.zig");
const testing = std.testing;
/// Template represents a template
/// It's a list of tokens and the source template
pub const Template = struct {
const Self = @This();
decls: []const parser.Decl = &.{},
... | src/main.zig |
const std = @import("std");
const gpa = std.heap.c_allocator;
const u = @import("./index.zig");
//
//
pub const DepType = enum {
system_lib, // std.build.LibExeObjStep.linkSystemLibrary
git, // https://git-scm.com/
hg, // https://www.mercurial-scm.org/
http, // https://en.wikiped... | src/util/dep_type.zig |
const std = @import("std");
const assert = std.debug.assert;
const allocator = std.testing.allocator;
const DIM = 3;
const Vec = struct {
v: [DIM]i32,
};
const Moon = struct {
pos: Vec,
vel: Vec,
};
pub const Trace = struct {
data: std.AutoHashMap(u128, usize),
done: bool,
pub fn init() Tra... | 2019/p12/map.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = true;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const assert = std.debug.assert;
pub const main = tools.defaultMain("2021/day12.txt", run);
const Room = struct {
links: ... | 2021/day12.zig |
const std = @import("std");
pub fn RaxIterator(comptime RaxT: type, comptime StaticSize: usize) type {
return struct {
tree: *RaxT,
data: ?RaxT.ValueT,
key: []u8,
keyMaxLen: usize,
keyStaticBuf: [StaticSize]u8,
allocator: *std.mem.Allocator,
currentNode: *Rax... | src/simple/iterator.zig |
const std = @import("std");
const mem = std.mem;
const wlr = @import("wlroots");
const xkb = @import("xkbcommon");
const c = @import("../c.zig");
const server = &@import("../main.zig").server;
const util = @import("../util.zig");
const Error = @import("../command.zig").Error;
const Mapping = @import("../Mapping.zig"... | source/river-0.1.0/river/command/map.zig |
const std = @import("std");
const powi = std.math.powi;
const print = std.debug.print;
const split = std.mem.split;
const tokenize = std.mem.tokenize;
const testing = std.testing;
const input = @embedFile("./input.txt");
const pattern_size = 10;
const output_size = 4;
pub fn main() anyerror!void {
print("--- Par... | src/day08/day08.zig |
pub const ENTITIES = [_]@import("main.zig").Entity{
.{ .entity = "Æ", .codepoints = .{ .Single = 198 }, .characters = "\xc3\x86" },
.{ .entity = "Æ", .codepoints = .{ .Single = 198 }, .characters = "\xc3\x86" },
.{ .entity = "&", .codepoints = .{ .Single = 38 }, .characters = "&" },
.{ .en... | src/entities.zig |
const std = @import("std");
fn getRelativePath() []const u8 {
comptime var src: std.builtin.SourceLocation = @src();
return std.fs.path.dirname(src.file).? ++ std.fs.path.sep_str;
}
fn getSrcPath() []const u8 {
comptime var src: std.builtin.SourceLocation = @src();
return std.fs.path.dirname(src.file... | lib.zig |
const std = @import("std");
const net = std.net;
const mem = std.mem;
const fs = std.fs;
const os = std.os;
const builtin = std.builtin;
const proto = @import("protocol.zig");
const callbacks = @import("init.zig");
const WireBuffer = @import("wire.zig").WireBuffer;
const Connector = @import("connector.zig").Connector;
... | src/connection.zig |
const Elf = @This();
const std = @import("std");
const mem = std.mem;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const fs = std.fs;
const elf = std.elf;
const log = std.log.scoped(.link);
const DW = std.dwarf;
const leb128 = std.leb;
const ir = @import("../ir.zig");
const Module = @import("... | src/link/Elf.zig |
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
/// Returns the cube root of x.
///
/// Special Cases:
/// - cbrt(+-0) = +-0
/// - cbrt(+-inf) = +-inf
/// - cbrt(nan) = nan
pub fn cbrt(x: var) @typeOf(x) {
const T = @typeOf(x);
return switch (T) {
f3... | lib/std/math/cbrt.zig |
const std = @import("std");
const builtin = @import("builtin");
const is_test = builtin.is_test;
const fp_t = f32;
const rep_t = u32;
const srep_t = i32;
const typeWidth = rep_t.bit_count;
const significandBits = std.math.floatMantissaBits(fp_t);
const exponentBits = std.math.floatExponentBits(fp_t);
const signBit =... | lib/std/special/compiler_rt/comparesf2.zig |
const std = @import("std");
const mem = std.mem;
const fs = std.fs;
const process = std.process;
const Token = std.zig.Token;
const ast = std.zig.ast;
const TokenIndex = std.zig.ast.TokenIndex;
const Compilation = @import("compilation.zig").Compilation;
const Scope = @import("scope.zig").Scope;
pub const Color = enum ... | src-self-hosted/errmsg.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const Memory = std.AutoHashMap(usize, usize);
pub fn run(problem: *aoc.Problem) !aoc.Solution {
var mem1 = Memory.init(problem.allocator); defer mem1.deinit();
var mem2 = Memory.init(problem.allocator); defer mem2.deinit();
var mask: []const u8... | src/main/zig/2020/day14.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 ArrayList = std.ArrayList;
const assert = std.debug.assert;
const utils = @import("utils.zig");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const Game = struct... | day_22/src/main.zig |
const std = @import("std");
// Based on <https://rosettacode.org/wiki/Combinations#Nim> because I don't
// remember this stuff off the top of my head.
pub fn Combination(comptime T: type, comptime size: usize) type {
comptime {
if (size == 0) {
@compileError("size=0 not permitted for combinatio... | lib/nil/combination.zig |
pub const ERROR = @import("error.zig");
pub extern "advapi32" stdcallcc fn CryptAcquireContextA(phProv: &HCRYPTPROV, pszContainer: ?LPCSTR,
pszProvider: ?LPCSTR, dwProvType: DWORD, dwFlags: DWORD) BOOL;
pub extern "advapi32" stdcallcc fn CryptReleaseContext(hProv: HCRYPTPROV, dwFlags: DWORD) BOOL;
pub extern "ad... | std/os/windows/index.zig |
const mecha = @import("../mecha.zig");
const std = @import("std");
const ascii = std.ascii;
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
/// Constructs a parser that parses a single ascii bytes based on
/// a `predicate`. If the `predicate` returns true, the parser... | src/ascii.zig |
const builtin = @import("builtin");
const std = @import("std");
const pkgs = @import("deps.zig").pkgs;
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... | build.zig |
const std = @import("std");
const expect = std.testing.expect;
const assert = std.debug.assert;
const mem = std.mem;
const fmt = std.fmt;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const GeneralPurposeAllocator = std.heap.GeneralPurposeAllocator;
const Input = @import("input.zig");
pub fn main()... | 2021/zig/src/day2/main.zig |
const std = @import("std");
const c = @import("c.zig");
const EGLContext = @import("egl.zig").EGLContext;
const JNI = @import("jni.zig").JNI;
const android = @import("android-support.zig");
const build_options = @import("build_options");
pub const panic = android.panic;
pub const log = android.log;
const app_log = ... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
const Timer = std.os.time.Timer;
const DefaultPrng = std.rand.DefaultPrng;
/// Compiler Seg faults:
/// #0 0x00007f4479d32bf0 in llvm::Value::getContext() const... | ux-semantics.zig |
const std = @import("std");
const fmt = std.fmt;
const os = std.os;
const c = @import("c_imports.zig").c;
const allocator = std.heap.c_allocator;
const buffer = @import("buffer.zig");
const config = @import("config.zig");
const Config = config.Config;
const EditorSyntax = @import("syntax.zig").EditorSyntax;
const HLD... | kilo.zig |
const is_test = @import("builtin").is_test;
const std = @import("std");
const math = std.math;
const testing = std.testing;
const warn = std.debug.warn;
const fixint = @import("fixint.zig").fixint;
fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void {
const x = fixint(f... | lib/std/special/compiler_rt/fixint_test.zig |
const __ashrdi3 = @import("shift.zig").__ashrdi3;
const testing = @import("std").testing;
fn test__ashrdi3(a: i64, b: i32, expected: u64) void {
const x = __ashrdi3(a, b);
testing.expectEqual(@bitCast(i64, expected), x);
}
test "ashrdi3" {
test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x12... | lib/std/special/compiler_rt/ashrdi3_test.zig |
const std = @import("std");
const mem = std.mem;
const fmt = std.fmt;
const testing = std.testing;
use @import("ip");
test "" {
_ = @import("./ipv4.zig");
_ = @import("./ipv6.zig");
}
test "IpAddress.isIpv4()" {
const ip = IpAddress{
.V4 = IpV4Address.init(192, 168, 0, 1),
};
testing.exp... | test/main.zig |
const std = @import("std");
const ascii = std.ascii;
const testing = std.testing;
const Impl = @import("../impl.zig").Impl;
const CallbackHandler = @import("../callback_handler.zig").CallbackHandler;
const iup = @import("iup.zig");
const interop = @import("interop.zig");
const ChildrenIterator = iup.ChildrenIterator... | src/elements.zig |
pub const E_SURFACE_CONTENTS_LOST = @as(u32, 2150301728);
pub const MAX_ERROR_MESSAGE_CHARS = @as(u32, 512);
pub const CastingSourceInfo_Property_PreferredSourceUriScheme = "PreferredSourceUriScheme";
pub const CastingSourceInfo_Property_CastingTypes = "CastingTypes";
pub const CastingSourceInfo_Property_ProtectedMedia... | deps/zigwin32/win32/system/win_rt.zig |
pub const ISSP_LEVEL = @as(u32, 32);
pub const ISSP_MODE = @as(u32, 1);
pub const SECPKG_FLAG_INTEGRITY = @as(u32, 1);
pub const SECPKG_FLAG_PRIVACY = @as(u32, 2);
pub const SECPKG_FLAG_TOKEN_ONLY = @as(u32, 4);
pub const SECPKG_FLAG_DATAGRAM = @as(u32, 8);
pub const SECPKG_FLAG_CONNECTION = @as(u32, 16);
pub const SEC... | deps/zigwin32/win32/security/authentication/identity/core.zig |
const std = @import("std");
const stdx = @import("stdx");
const t = stdx.testing;
const math = stdx.math;
const Mat4 = math.Mat4;
const Vec2 = math.Vec2;
const Vec3 = math.Vec3;
const Vec4 = math.Vec4;
// TODO: Add transform just for 2D coords.
pub const Transform = struct {
mat: Mat4,
const Self = @This();... | graphics/src/transform.zig |
const std = @import("std");
const TestContext = @import("../../src/test.zig").TestContext;
const build_options = @import("build_options");
// These tests should work with all platforms, but we're using linux_x64 for
// now for consistency. Will be expanded eventually.
const linux_x64 = std.zig.CrossTarget{
.cpu_ar... | test/stage2/llvm.zig |
const std = @import("std");
usingnamespace @import("common.zig");
const response_parser = @import("../main.zig").parser.response;
pub const ResponseParser = response_parser.ResponseParser;
pub const PayloadEvent = response_parser.PayloadEvent;
pub const StatusEvent = response_parser.StatusEvent;
pub const Event = re... | src/base/client.zig |
const std = @import("std");
const utils = @import("utils.zig");
const testing = std.testing;
const debug = std.debug.print;
const any = utils.any;
pub const TokenType = enum {
invalid,
eof,
eos,
value,
keyword_node,
keyword_edge,
keyword_group,
keyword_layer,
identifier,
single_... | libdaya/src/tokenizer.zig |
// This file is generated from the Khronos Vulkan XML API registry
const std = @import("std");
const builtin = @import("builtin");
const root = @import("root");
pub const vulkan_call_conv: std.builtin.CallingConvention = if (builtin.os.tag == .windows and builtin.cpu.arch == .i386)
.Stdcall
else if (builtin.abi =... | src/vk.zig |
const std = @import( "std" );
const sqrt = std.math.sqrt;
const Atomic = std.atomic.Atomic;
const Allocator = std.mem.Allocator;
usingnamespace @import( "core/util.zig" );
usingnamespace @import( "core/core.zig" );
usingnamespace @import( "core/gtkz.zig" );
usingnamespace @import( "core/support.zig" );
usingnamespace @... | src/main.zig |
const std = @import("std");
const fs = std.fs;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = &gpa.allocator;
const input = try fs.cwd().readFileAlloc(allocator, "data/input_18_1.txt", std.math.maxInt(usize));
{ // Solution one
var lines = std.mem.t... | 2020/src/day_18.zig |
const Allocator = std.mem.Allocator;
const File = std.fs.File;
const FormatInterface = @import("../format_interface.zig").FormatInterface;
const ImageFormat = image.ImageFormat;
const ImageReader = image.ImageReader;
const ImageInfo = image.ImageInfo;
const ImageSeekStream = image.ImageSeekStream;
const PixelFormat = @... | src/formats/bmp.zig |
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const io = std.io;
const mem = std.mem;
const os = std.os;
pub fn main() !void {
var allocator = &std.heap.DirectAllocator.init().allocator;
var input01 = try get_file_contents(allocator, "input_01.txt");
defer allocator.free(input01... | 2018/day_01_2.zig |
const std = @import("std");
const testing = std.testing;
const math = @import("std").math;
const Mat2 = @import("mat2.zig").Mat2;
const Mat3 = @import("mat3.zig").Mat3;
const Mat4 = @import("mat4.zig").Mat4;
const Quat = @import("quat.zig").Quat;
const f_eq = @import("utils.zig").f_eq;
const debug = @import("std").debu... | src/vec3.zig |
const std = @import("std");
const gk = @import("gamekit");
const math = gk.math;
const gfx = gk.gfx;
var tex: gfx.Texture = undefined;
var colored_tex: gfx.Texture = undefined;
var mesh: gfx.Mesh = undefined;
var dyn_mesh: gfx.DynamicMesh(u16, gfx.Vertex) = undefined;
pub fn main() !void {
try gk.run(.{
.... | examples/meshes.zig |
const tone = @import("tone.zig");
const tune = @import("tune.zig");
const note = @import("note.zig");
const music = @import("music.zig");
const c5 = note.getFreq("C 5".*);
const c4 = note.getFreq("C 4".*);
const c3 = note.getFreq("C 3".*);
const e4 = note.getFreq("E 4".*);
const e5 = note.getFreq("E 5".*);
const ds5 =... | src/music/party-vibez.zig |
const addv = @import("addo.zig");
const std = @import("std");
const testing = std.testing;
const math = std.math;
fn test__addoti4(a: i128, b: i128) !void {
var result_ov: c_int = undefined;
var expected_ov: c_int = undefined;
var result = addv.__addoti4(a, b, &result_ov);
var expected: i128 = simple_a... | lib/std/special/compiler_rt/addoti4_test.zig |
const std = @import("std");
const print = std.debug.print;
const List = std.ArrayList;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day10.txt");
fn find(char: u8) ?u8 {
const openings = [_]u8{ '(', '[', '{', '<' };
const closings = [_]u8{ ')', ']', '}', '>' };
... | 2021/src/day10.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_if.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const AutoHashMap = std.AutoHashMap;
const Allocator = std.mem.Allocator;
const expect = std.testing.expect;
/// HashMap of ArrayLists
pub fn HashedArrayList(comptime K: type, comptime V: type) type {
return struct {
const Self = @This();
... | src/libs/hashed_array_list.zig |
const std = @import("std");
const testing = std.testing;
// The same as `AutoUnique`, but accepts custom hash and equality functions.
pub fn Unique(
comptime T: type,
comptime Context: type,
comptime hash: fn (
ctx: Context,
key: T,
) u64,
comptime eql: fn (ctx: Context, a: T, b: T)... | src/unique.zig |
pub const FWPM_NET_EVENT_KEYWORD_INBOUND_MCAST = @as(u32, 1);
pub const FWPM_NET_EVENT_KEYWORD_INBOUND_BCAST = @as(u32, 2);
pub const FWPM_NET_EVENT_KEYWORD_CAPABILITY_DROP = @as(u32, 4);
pub const FWPM_NET_EVENT_KEYWORD_CAPABILITY_ALLOW = @as(u32, 8);
pub const FWPM_NET_EVENT_KEYWORD_CLASSIFY_ALLOW = @as(u32, 16);
pub... | deps/zigwin32/win32/network_management/windows_filtering_platform.zig |
const std = @import("std");
const allocator = std.heap.page_allocator;
const debug = std.debug;
const assert = debug.assert;
test "Run End-to-End test with Envoy proxy" {
try requireWasmBinary();
const envoy = try requireRunAndWaitEnvoyStarted();
defer _ = envoy.kill() catch unreachable;
errdefer print... | example/e2e_test.zig |
const std = @import("std");
const expect = std.testing.expect;
const ZigClangSourceLocation = @import("clang.zig").ZigClangSourceLocation;
const Context = @import("translate_c.zig").Context;
const failDecl = @import("translate_c.zig").failDecl;
pub const TokenList = std.SegmentedList(CToken, 32);
pub const CToken = s... | src-self-hosted/c_tokenizer.zig |
const std = @import("std");
const io = std.io;
const RawTerm = @import("term.zig").RawTerm;
const cursor = @import("cursor.zig");
const ComptimeStringMap = std.ComptimeStringMap;
// Reference:
// https://en.wikipedia.org/wiki/ANSI_escape_code#Terminal_input_sequences
// https://gitlab.redox-os.org/redox-os/termion/-... | src/event.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const common = @import("common.zig");
const instruction_ = @import("../instruction.zig");
const Op = instruction_.Op;
const Addressing = instruction_.Addressing;
const Access = instruction_.Access;
const Instruction = instruction_.Instruction;
const opT... | src/cpu/accurate.zig |
const std = @import("std");
const BaseColors = [_]RGB{
// we intentionally don't include the transparent
// just add 4 to the final matching result
.{ .r = 127, .g = 178, .b = 56 },
.{ .r = 247, .g = 233, .b = 163 },
.{ .r = 199, .g = 199, .b = 199 },
.{ .r = 255, .g = 0, .b = 0 },
.{ .r = ... | nativemap/src/color.zig |
const std = @import("std");
const util = @import("util.zig");
const Grid = struct {
energy_levels: [10][10]u8,
flashed: [10][10]u1,
total_flashes: u64,
const Self = @This();
fn init() Self {
return .{
.energy_levels = std.mem.zeroes([10][10]u8),
.flashed = std.mem.... | zig/src/day11.zig |
const std = @import("std");
const list = @import("linked_list.zig");
//TODO: If need by implement Deque
///A queue .ie a FIFO data structure
pub fn Queue(comptime T: type) type {
return struct {
const ListType = list.SinglyList(T);
const Self = @This();
data: ListType,
pub fn init(... | src/queue.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Card = u8;
const Deck = tools.CircularBuffer(Card);
fn playGame(hands: [2][]const Card, variant: enum { classic, recursive }, allocator: std.mem.Allocator) std.mem.Allocator.Error![2]u32 {
var previous = std.AutoHas... | 2020/day22.zig |
const std = @import("std");
const mem = std.mem;
const meta = std.meta;
const net = std.net;
usingnamespace @import("../primitive_types.zig");
usingnamespace @import("../event.zig");
const PrimitiveReader = @import("../primitive/reader.zig").PrimitiveReader;
const checkHeader = @import("../frame.zig").checkHeader;
c... | src/frames/event.zig |
const std = @import("std");
const pike = @import("pike.zig");
const os = std.os;
const fmt = std.fmt;
const log = std.log;
const net = std.net;
const mem = std.mem;
const heap = std.heap;
const process = std.process;
fn exists(args: []const []const u8, flags: anytype) ?usize {
inline for (flags) |flag| {
... | example_tcp_benchmark.zig |
const std = @import("std.zig");
const math = std.math;
const assert = std.debug.assert;
const mem = std.mem;
const builtin = @import("builtin");
const errol = @import("fmt/errol.zig");
const lossyCast = std.math.lossyCast;
pub const default_max_depth = 3;
pub const Alignment = enum {
Left,
Center,
Right,
... | lib/std/fmt.zig |
const std = @import("std");
const liu = @import("liu");
const input = @import("./input.zig");
const rows = input.rows;
const keys = input.keys;
// https://youtu.be/SFKR5rZBu-8?t=2202
// https://stackoverflow.com/questions/22511158/how-to-profile-web-workers-in-chrome
const wasm = liu.wasm;
pub const WasmCommand = vo... | src/routes/erlang/erlang.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectError = std.testing.expectError;
const expectEqual = std.testing.expectEqual;
test "switch with numbers" {
try testSwitchWithNumbers(13);
}
fn testSwitchWithNumbers(x: u32) !void {
const result = switch (x) {
1, 2, 3, 4...8 => ... | test/behavior/switch.zig |
const std = @import("std");
const ArenaAllocator = std.heap.ArenaAllocator;
const c = @import("../c.zig");
const zupnp = @import("../lib.zig");
const logger = std.log.scoped(.@"zupnp.web.request");
pub const Endpoint = struct {
pub const Callbacks = union (enum) {
WithInstance: struct {
insta... | src/web/request.zig |
const std = @import("std");
const testing = std.testing;
const proverb = @import("proverb.zig");
test "zero pieces" {
const array_long = [_][]const u8 {};
const input_slice = &array_long;
const expected = input_slice;
const actual = try proverb.recite(testing.allocator, input_slice);
testing.ex... | exercises/practice/proverb/test_proverb.zig |
const std = @import("std");
const mem = std.mem;
const IDStart = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 65,
hi: u21 = 201546,
pub fn init(allocator: *mem.Allocator) !IDStart {
var instance = IDStart{
.allocator = allocator,
.array = try allocator.alloc(bool, 201482),
};... | src/components/autogen/DerivedCoreProperties/IDStart.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Smooth Union",
.data_size = @sizeOf(Data),
.function_definition = function_definition,
.enter_command_fn = enterCommand,
.exit_command_fn = exitCommand,
.append_mat_check_fn = appendMatCheck,
.sphere_bound_... | src/sdf/combinators/smooth_union.zig |
const std = @import("std");
const print = std.debug.print;
const Ingredient = struct {
capacity: isize,
durability: isize,
flavor: isize,
texture: isize,
calories: isize,
};
pub fn main() anyerror!void {
const global_allocator = std.heap.page_allocator;
var file = try std.fs.cwd().openFil... | src/day15.zig |
const std = @import("std");
const num_aunts: u32 = 500;
fn solve1(aunts: [num_aunts]std.StringHashMap(u32)) ?usize {
var i: usize = 0;
while (i < num_aunts) : (i += 1) {
if (aunts[i].get("children") orelse 3 != 3) continue;
if (aunts[i].get("cats") orelse 7 != 7) continue;
if (aunts[i].... | src/day16.zig |
pub const width: usize = 9;
pub const height: usize = 20;
pub const bitmaps = [95][20][2]u8 {
[20][2]u8{
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[_]u8{0x0, 0x0},
[... | kernel/font.zig |
const assert = @import("std").debug.assert;
const elf = @import("elf.zig");
const mem = @import("mem.zig");
const scheduler = @import("scheduler.zig");
const vmem = @import("vmem.zig");
const Thread = @import("thread.zig").Thread;
const ThreadList = @import("thread.zig").ThreadList;
// Keep track of the used PIDs.
var... | kernel/process.zig |
const rokuhachi = @import("rokuhachi");
const z80 = rokuhachi.cpu.z80;
const std = @import("std");
const Allocator = std.mem.Allocator;
const testing = std.testing;
usingnamespace @import("../helpers.zig");
fn TestIO(comptime ram_size: usize, comptime rom: []const u8) type {
return struct {
bus: z80.Z80Bus... | tests/cpu/z80_tests.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const fmt = std.fmt;
const testing = std.testing;
const heap = std.heap;
const network = @import("network");
const IPv4 = network.Address.IPv4;
const ArrayList = std.ArrayList;
pub const BlockList = struct {
const Self = @This();
bloc... | src/blocklist.zig |
const std = @import("std");
const ImageCopyTexture = @import("structs.zig").ImageCopyTexture;
const Extent3D = @import("data.zig").Extent3D;
const CommandBuffer = @import("CommandBuffer.zig");
const Buffer = @import("Buffer.zig");
const Texture = @import("Texture.zig");
const Queue = @This();
on_submitted_work_done:... | libs/zgpu/src/mach-gpu/Queue.zig |
const std = @import("std");
const core = @import("../index.zig");
const game_server = @import("../server/game_server.zig");
const Coord = core.geometry.Coord;
const makeCoord = core.geometry.makeCoord;
const Socket = core.protocol.Socket;
const Request = core.protocol.Request;
const Action = core.protocol.Action;
const... | src/client/game_engine_client.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const builtin = @import("builtin");
const c = @import("c.zig");
const gui = @import("gui");
const nvg = @import("nanovg");
const geometry = @import("gui/geometry.zig");
const Point = geometry.Point;
const Rect = geometry.Rect;
const info = @import("info.... | src/AboutDialogWidget.zig |
const interrupt = @import("interrupt.zig");
const isr = @import("isr.zig");
const ipc = @import("ipc.zig");
const layout = @import("layout.zig");
const scheduler = @import("scheduler.zig");
const process = @import("process.zig");
const tty = @import("tty.zig");
const vmem = @import("vmem.zig");
const x86 = @import("x86... | kernel/syscall.zig |
const std = @import("std");
const fmt = std.fmt;
const mem = std.mem;
const sort = std.sort.sort;
const unicode = std.unicode;
const isAsciiStr = @import("../ascii.zig").isAsciiStr;
const canonicals = @import("../ziglyph.zig").canonicals;
const case_fold_map = @import("../ziglyph.zig").case_fold_map;
const ccc_map = ... | .gyro/ziglyph-jecolon-github.com-c37d93b6/pkg/src/normalizer/Normalizer.zig |
const std = @import("std");
const c = @import("backend.zig").c;
pub const WBin = extern struct { bin: c.GtkBin };
// Parent class is GtkContainerClass. But it and GtkWidgetClass fail to be translated by translate-c
const GtkBinClass = extern struct {
parent_class: [1024]u8,
_gtk_reserved1: ?fn () callconv(.C)... | src/backends/gtk/windowbin.zig |
const std = @import("std");
const json = std.json;
const Allocator = std.mem.Allocator;
const logger = std.log.scoped(.ft);
const util = @import("util.zig");
pub const Date = struct {
/// comptime interfaces: [ readFromJson, toJson ]
day: ?u8 = null,
month: ?u8 = null,
year: ?i32 = null,
pub const... | src/date.zig |
const std = @import("std");
const wz = @import("../main.zig");
const parser = @import("../main.zig").parser.message;
const hzzp = @import("hzzp");
const base64 = std.base64;
const ascii = std.ascii;
const math = std.math;
const rand = std.rand;
const time = std.time;
const mem = std.mem;
const Sha1 = std.crypto.has... | src/base/client.zig |
const getty = @import("../../lib.zig");
const std = @import("std");
/// Serializer interface.
///
/// Serializers are responsible for the following conversion:
///
/// Getty Data Model
///
/// | <-------
/// ▼ |
/// ... | src/ser/interface/serializer.zig |
const std = @import("std");
const mem = std.mem;
const EmojiModifierBase = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 9757,
hi: u21 = 129501,
pub fn init(allocator: *mem.Allocator) !EmojiModifierBase {
var instance = EmojiModifierBase{
.allocator = allocator,
.array = try alloc... | src/components/autogen/emoji-data/EmojiModifierBase.zig |
const std = @import("std");
const assert = std.debug.assert;
const os = std.os;
const linux = os.linux;
const IO_Uring = linux.IO_Uring;
const io_uring_cqe = linux.io_uring_cqe;
const io_uring_sqe = linux.io_uring_sqe;
pub const IO = struct {
ring: IO_Uring,
/// The number of SQEs queued but not yet submitted... | src/io_async.zig |
const std = @import("std");
pub fn singleInputFuncMain(comptime func: @TypeOf(std.math.exp)) !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var arg_iter = std.process.args();
// Skip this exe name.
_ = arg_iter.skip();
var a = &arena.allocato... | src/util.zig |
const l0 = @import("vez.zig");
// Instance functions.
pub const enumerateInstanceExtensionProperties = l0.vezEnumerateInstanceExtensionProperties;
pub const enumerateInstanceLayerProperties = l0.vezEnumerateInstanceLayerProperties;
pub const createInstance = l0.vezCreateInstance;
pub const destroyInstance = l0.vezDest... | src/lib/vez-l1.zig |
const std = @import("std");
const debug = std.debug;
const io = std.io;
const mem = std.mem;
const testing = std.testing;
pub const args = @import("clap/args.zig");
test "clap" {
_ = args;
_ = ComptimeClap;
_ = StreamingClap;
}
pub const ComptimeClap = @import("clap/comptime.zig").ComptimeClap;
pub cons... | tools/zig-clap/clap.zig |
const std = @import("std");
const token = @import("../token.zig");
const ast = @import("../ast.zig");
const fieldNames = std.meta.fieldNames;
const eq = std.mem.eq;
const TokenError = token.TokenError;
const Token = token.Token;
const Kind = Token.Kind;
const Ast = ast.Ast;
pub const Block = @import("./op.zig");
const ... | src/lang/token/type.zig |
const std = @import("std");
const prot = @import("../protocols.zig");
const Context = @import("../client.zig").Context;
const Object = @import("../client.zig").Object;
const Positioner = @import("../positioner.zig").Positioner;
const Rectangle = @import("../rectangle.zig").Rectangle;
const Window = @import("../window.z... | src/implementations/xdg_surface.zig |
const mulo = @import("mulo.zig");
const testing = @import("std").testing;
// ported from https://github.com/llvm-mirror/compiler-rt/tree/release_80/test/builtins/Unit
fn test__mulosi4(a: i32, b: i32, expected: i32, expected_overflow: c_int) !void {
var overflow: c_int = undefined;
const x = mulo.__mulosi4(a, ... | lib/std/special/compiler_rt/mulosi4_test.zig |
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
// [x] Renderer: Desktop GL only: Support for large meshes (64k+ vertices) with 16-bit indices.
// You can copy and use unmodified imgui_impl_* files in your p... | examples/imgui_impl_opengl3.zig |
const c = @cImport({
@cInclude("gsl/gsl_matrix.h");
@cInclude("gsl/gsl_blas.h");
});
const std = @import("std");
const aoc = @import("../aoc.zig");
pub const SquareMatrix = struct {
var flip_matrix: ?SquareMatrix = null;
matrix: *c.gsl_matrix,
pub fn init(side: usize) SquareMatrix {
retur... | src/main/zig/lib/matrix.zig |
const std = @import("std");
const utils = @import("utils");
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const max = std.math.max;
const min = std.math.min;
const clamp = std.math.clamp;
const absInt = std.math.absInt;
const print = utils.print;
const Line = struct {
x0: i3... | day5/src/main.zig |
const std = @import("std");
const gpa = std.heap.c_allocator;
const fs = std.fs;
const u = @import("./util/index.zig");
//
//
pub fn collect_deps(dir: []const u8, mpath: []const u8) anyerror!u.Module {
const m = try u.ModFile.init(gpa, mpath);
const moduledeps = &std.ArrayList(u.Module).init(gpa);
var mo... | src/common.zig |
const std = @import("std");
const testing = std.testing;
const f128math = @import("f128math");
const math = f128math;
const inf_f32 = math.inf_f32;
const nan_f32 = math.qnan_f32;
const inf_f64 = math.inf_f64;
const nan_f64 = math.qnan_f64;
const inf_f128 = math.inf_f128;
const nan_f128 = math.qnan_f128;
const test_ut... | tests/log2.zig |
const builtin = @import("builtin");
const TypeInfo = builtin.TypeInfo;
const std = @import("std");
const testing = std.testing;
fn testTypes(comptime types: []const type) void {
inline for (types) |testType| {
testing.expect(testType == @Type(@typeInfo(testType)));
}
}
test "Type.MetaType" {
test... | test/stage1/behavior/type.zig |
const std = @import("std");
const builtin = std.builtin;
const warn = std.debug.warn;
const assertEqual = std.testing.expectEqual;
pub fn ctreduce(
comptime func: anytype,
comptime iterable: []@typeInfo(@TypeOf(func)).Fn.args[0].arg_type.?,
comptime init: @typeInfo(@TypeOf(func)).Fn.return_type.?
) @type... | src/ctmain.zig |
const std = @import("std");
pub const sabaton = @import("../../sabaton.zig");
pub const io = sabaton.io_impl.status_uart_mmio_32;
pub const panic = sabaton.panic;
pub const display = @import("display.zig");
pub const ElfType = [*]u8;
usingnamespace @import("regs.zig");
var page_size: u64 = 0x1000;
pub fn get_page_size... | src/platform/pi3_aarch64/main.zig |
const std = @import("std");
/// Table containing all possible characters used by a Dots Display.
const UnicodeLookup = [256][]const u8 {
" ", "⠁", "⠈", "⠉", "⠂", "⠃", "⠊", "⠋", "⠐", "⠑", "⠘", "⠙", "⠒", "⠓", "⠚", "⠛",
"⠄", "⠅", "⠌", "⠍", "⠆", "⠇", "⠎", "⠏", "⠔", "⠕", "⠜", "⠜", "⠖", "⠗", "⠞", "⠞",
"⠠", "⠡", ... | dots.zig |
const std = @import("std");
const webgpu = @import("../../webgpu.zig");
const dummy = @import("./dummy.zig");
pub const BindGroup = struct {
const vtable = webgpu.BindGroup.VTable{
.destroy_fn = destroy,
};
super: webgpu.BindGroup,
pub fn create(device: *dummy.Device, descriptor: webgpu.Bind... | src/backends/dummy/binding_model.zig |
const u = @import("util.zig");
const std = @import("std");
const TextIterator = @import("TextIterator.zig");
const Expr = @This();
val: Val,
at: ?Range = null,
const Range = struct {
offset: usize,
len: usize,
pub fn view(r: Range, bytes: u.Bin) u.Bin {
return bytes[r.offset..r.end()];
}
... | src/Expr.zig |
// codegen (NodeJS):
// import { comp, distinct, map, mapcat, permutations, range, repeat, run, str, trace zip } from "@thi.ng/transducers";
// D = [2, 3, 4];
// run(
// comp(
// mapcat(d => zip([d, d, d], D)),
// mapcat(([d, n]) => [...permutations(...repeat(range(d), n))]),
// distinct({ key: String })... | src/swizzle.zig |