code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const mem = std.mem;
const math = std.math;
const testing = std.testing;
const unicode = std.unicode;
const bog = @import("bog.zig");
const Errors = bog.Errors;
fn isWhiteSpace(c: u32) bool {
return switch (c) {
' ', '\t', '\r',
// NO-BREAK SPACE
0x00A0,
... | src/tokenizer.zig |
//--------------------------------------------------------------------------------
// Section: Types (2)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows8.0'
const IID_IWICImageEncoder_Value = Guid.initString("04c75bf8-3ce1-473b-acc5-... | win32/graphics/imaging/d2d.zig |
const std = @import("std");
const testing = std.testing;
const expectEqualStrings = testing.expectEqualStrings;
const expectEqual = testing.expectEqual;
const expectError = testing.expectError;
pub const Transport = enum {
/// Unix domain sockets
unix,
/// launchd
launchd,
/// systemd socket activa... | src/address.zig |
const clap = @import("clap");
const format = @import("format");
const it = @import("ziter");
const std = @import("std");
const ston = @import("ston");
const util = @import("util");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const log = std.log;
const math... | src/randomizers/tm35-rand-pokemons.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/10.txt", .{});
defer input_file.close();
var buffe... | src/10.zig |
const std = @import("std");
const testing = std.testing;
pub const c = @cImport({
@cInclude("curl/curl.h");
});
pub fn globalInit() Error!void {
return tryCurl(c.curl_global_init(c.CURL_GLOBAL_ALL));
}
pub fn globalCleanup() void {
c.curl_global_cleanup();
}
pub const XferInfoFn = c.curl_xferinfo_callba... | .gyro/zig-libcurl-mattnite-github.com-f1f316dc/pkg/src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const loadFile = @import("../Files.zig").loadFile;
const compress = @import("../Compress/Compress.zig");
const ModelData = @import("../ModelFiles/ModelFiles.zig").ModelData;
const AnimationData = @import("../ModelFiles/AnimationFiles.zig").AnimationData;
cons... | src/Assets/Assets.zig |
const Self = @This();
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const fmt = std.fmt;
const wlr = @import("wlroots");
const wayland = @import("wayland");
const wl = wayland.server.wl;
const zwlr = wayland.server.zwlr;
const render = @import("render.zig");
const server = &@impor... | source/river-0.1.0/river/Output.zig |
const std = @import("std");
const process = std.process;
const chunks = @import("./chunks.zig");
const debug = @import("./debug.zig");
const Allocator = std.mem.Allocator;
const OpCode = chunks.OpCode;
const Chunk = chunks.Chunk;
const Vm = @import("./vm.zig").Vm;
pub fn main() anyerror!u8 {
var general_purpose_al... | src/main.zig |
// test "Item.BrightPowder" {
// // An attack against the holder has its accuracy out of 255 lowered by 20.
// return error.SkipZigTest;
// }
// test "Item.MetalPowder" {
// // If held by a Ditto, its Defense and Sp. Def are 1.5x, even while Transformed.
// return error.SkipZigTest;
// }
// test "Ite... | src/lib/gen2/test.zig |
const std = @import("std");
const allocator = std.heap.c_allocator;
const napi = @import("./napi/headers/c.zig");
pub usingnamespace napi;
pub const serde = @import("./serde.zig");
pub const bind = opaque {
// pub fn class() void {}
pub const function = @import("./bind/function.zig").bind;
};
pub const js_type =... | src/napi.zig |
const builtin = @import("builtin");
const std = @import("std");
const fmt = std.fmt;
const fs = std.fs;
const log = std.log;
const mem = std.mem;
const process = std.process;
const Allocator = std.mem.Allocator;
const utils = @import("utils.zig");
const fatal = utils.fatal;
const DotEnv = @import("dotenv.zig").DotEnv;... | src/elixir.zig |
const cmp = @import("cmp.zig");
const testing = @import("std").testing;
fn test__cmpti2(a: i128, b: i128, expected: i128) !void {
var result = cmp.__cmpti2(a, b);
try testing.expectEqual(expected, result);
}
test "cmpti2" {
// minInt == -170141183460469231731687303715884105728
// maxInt == 17014118346... | lib/std/special/compiler_rt/cmpti2_test.zig |
const std = @import("../std.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const mem = std.mem;
const ast = std.zig.ast;
const Token = std.zig.Token;
const indent_delta = 4;
pub const Error = error{
/// Ran out of memory allocating call stack frames to complete rendering.
OutOfMem... | lib/std/zig/render.zig |
pub usingnamespace @import("builtin");
/// Deprecated: use `std.Target`.
pub const Target = std.Target;
/// Deprecated: use `std.Target.Os`.
pub const Os = std.Target.Os;
/// Deprecated: use `std.Target.Cpu.Arch`.
pub const Arch = std.Target.Cpu.Arch;
/// Deprecated: use `std.Target.Abi`.
pub const Abi = std.Target... | lib/std/builtin.zig |
const assert = @import("std").debug.assert;
const mem = @import("std").mem;
test "arrays" {
var array: [5]u32 = undefined;
var i: u32 = 0;
while (i < 5) {
array[i] = i + 1;
i = array[i];
}
i = 0;
var accumulator = u32(0);
while (i < 5) {
accumulator += array[i];
... | test/cases/array.zig |
const mmio = @import("mmio.zig");
const timer = @import("../../timer.zig");
const Property = struct {
first: u32,
second: u32,
reserved: u32,
fn enable_pin(self: *volatile Property, pin: u8) void {
var one: u32 = 1;
if (pin < 32) {
self.first |= (one << @intCast(u5, pin));... | src/arm/io/gpio.zig |
const std = @import("std");
const math = std.math;
const mem = std.mem;
const Allocator = mem.Allocator;
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
pub fn FixedSizeFifo(comptime T: type) type {
return struct {
allocator: *Allocator,
buf: []u8,
head: ... | lib/std/fifo.zig |
const std = @import("../std.zig");
const c = std.c;
const assert = std.debug.assert;
const maxInt = std.math.maxInt;
pub use @import("darwin/errno.zig");
pub const PATH_MAX = 1024;
pub const STDIN_FILENO = 0;
pub const STDOUT_FILENO = 1;
pub const STDERR_FILENO = 2;
/// [MC2] no permissions
pub const PROT_NONE = 0x... | std/os/darwin.zig |
usingnamespace @import("../windows/bits.zig");
pub const fd_t = HANDLE;
pub const pid_t = HANDLE;
pub const PATH_MAX = 260;
pub const time_t = c_longlong;
pub const timespec = extern struct {
tv_sec: time_t,
tv_nsec: c_long,
};
pub const sig_atomic_t = c_int;
/// maximum signal number + 1
pub const NSIG ... | lib/std/os/bits/windows.zig |
const arm_m = @import("arm_m");
const lpc_protchecker = @import("lpc_protchecker.zig");
const flexcomm_driver = @import("flexcomm.zig");
/// Security access rules for flash memory. Each flash sector is 32 kbytes.
/// There are 20 FLASH sectors in total.
pub const mpc_flash = lpc_protchecker.Mpc{
.base = 0x500ac010... | examples/drivers/lpc55s69.zig |
const std = @import("std");
const getty = @import("getty");
const assert = std.debug.assert;
const expectEqual = std.testing.expectEqual;
const expectEqualSlices = std.testing.expectEqualSlices;
const Token = @import("common/token.zig").Token;
pub const Deserializer = struct {
tokens: []const Token,
const S... | src/tests/de/deserializer.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const builtin = std.builtin;
const assert = std.debug.assert;
pub const ImageReadError = error{EndOfStream} || std.os.ReadError || std.os.SeekError;
pub const ImageReader = union(enum) {
buffer: BufferReader,
file: FileReader,
... | src/io.zig |
const std = @import("std");
const clap = @import("clap");
const io = std.io;
const fs = std.fs;
const mem = std.mem;
const process = std.process;
const doctest = @import("./doctest.zig");
const max_doc_file_size = 10 * 1024 * 1024; // TODO: this should be overridable by the user
const CommandLineCommand = enum {
... | src/main.zig |
const std = @import("std");
const g = @import("spirv/grammar.zig");
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = &arena.allocator;
const args = try std.process.argsAlloc(allocator);
if (args.len != 2) {
usa... | tools/gen_spirv_spec.zig |
// zlib License
//
// (C) 2022 Nelson "darltrash" Lopez
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpo... | iqm.zig |
const vk_xml_path = "C:/VulkanSDK/1.2.198.0/share/vulkan/registry/vk.xml";
//Submodules paths
const vkgen = @import("submodules/vulkan-zig/generator/index.zig");
const glfw = @import("submodules/mach-glfw/build.zig");
const builtin = @import("builtin");
const std = @import("std");
const Step = std.build.Step;
const B... | build.zig |
pub const PACKAGE_PROPERTY_FRAMEWORK = @as(u32, 1);
pub const PACKAGE_PROPERTY_RESOURCE = @as(u32, 2);
pub const PACKAGE_PROPERTY_BUNDLE = @as(u32, 4);
pub const PACKAGE_PROPERTY_OPTIONAL = @as(u32, 8);
pub const PACKAGE_FILTER_HEAD = @as(u32, 16);
pub const PACKAGE_FILTER_DIRECT = @as(u32, 32);
pub const PACKAGE_FILTE... | win32/storage/packaging/appx.zig |
const std = @import("std");
usingnamespace @import("c.zig");
const todo = @import("todo.zig");
const misc = @import("misc.zig");
pub var dateline_count: i32 = 0;
fn drawPointer(window: *WINDOW, enable_unicode: bool, selection_index: usize, list_index: usize, draw_x: *i32, draw_y: i32) void {
if (selection_index =... | src/draw.zig |
const builtin = @import("builtin");
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const Blob = @import("sqlite.zig").Blob;
/// Text is used to represent a SQLite TEXT value when binding a parameter or reading a column.
pub const Text = struct { data: []const u8 };
const BindMarker = u... | query.zig |
const c = @import("../c_global.zig").c_imp;
const std = @import("std");
const za = @import("zalgebra");
// dross-zig
const gl = @import("backend/renderer_opengl.zig");
const RendererGl = gl.RendererGl;
const app = @import("../core/application.zig");
const Application = app.Application;
const TextureId = @import("textu... | src/renderer/renderer.zig |
const std = @import("std");
const panic = std.debug.panic;
const builtin = @import("builtin");
const warn = std.debug.warn;
const join = std.fs.path.join;
usingnamespace @import("c.zig");
const Shader = @import("shader.zig").Shader;
// settings
const SCR_WIDTH: u32 = 1920;
const SCR_HEIGHT: u32 = 1080;
pub fn main(... | src/1_4_textures.zig |
const std = @import("std");
const georgios = @import("georgios");
comptime {_ = georgios;}
const system_calls = georgios.system_calls;
const utils = georgios.utils;
const print_string = system_calls.print_string;
pub fn panic(msg: []const u8, trace: ?*std.builtin.StackTrace) noreturn {
georgios.panic(msg, trace)... | programs/shell/shell.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XVideo", .global_id = 0 };
pub const PORT = u32;
pub const ENCODING = u32;
pub const Type = extern enum(c_uint) {
@"InputMask" = 1,
@"OutputMask" = 2,
@"VideoMask" = 4,
@"StillMask" = 8,
@"ImageMask" = 16,
};
pub const I... | src/auto/xv.zig |
const std = @import("std");
const imgui = @import("imgui");
const colors = @import("../colors.zig");
const Tilemap = @import("tilemap.zig").Tilemap;
const Tileset = @import("tileset.zig").Tileset;
pub const TilemapEditor = struct {
map: Tilemap,
tileset: Tileset,
shift_dragged: bool = false,
dragged:... | src/tilemaps/editor.zig |
const std = @import("std");
const comms = @import("comms.zig");
const fuse = @cImport({
@cDefine("FUSE_USE_VERSION", "39");
@cInclude("fuse3/fuse.h");
@cInclude("fuse3/fuse_common.h");
});
const fuse_ops = fuse.struct_fuse_operations;
var client: Client = undefined;
const FuseFileInfo = extern struct {... | src/fuse_client.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const BitSet = std.bit_set.IntegerBitSet;
const print = std.debug.print;
const data = @embedFile("../inputs/day04.txt");
pub fn main() anyerror!void {
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_impl.deinit();
const... | src/day04.zig |
const std = @import("std");
const uefi = std.os.uefi;
const sabaton = @import("root").sabaton;
const root = @import("root");
pub fn init(page_root: *sabaton.paging.Root) callconv(.Inline) void {
const graphicsProto = root.locateProtocol(uefi.protocols.GraphicsOutputProtocol) orelse {
sabaton.puts("No gra... | src/platform/uefi_aarch64/framebuffer.zig |
const std = @import("std");
const mem = std.mem;
const os = std.os;
const debug = std.debug;
const fs = std.fs;
const Allocator = mem.Allocator;
const page_allocator = std.heap.page_allocator;
const ArrayListAligned = std.ArrayListAligned;
const builtin = @import("builtin");
const s2 = builtin.zig_backend != .stage1;
... | src/CFO.zig |
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const zwin32 = @import("zwin32");
const w32 = zwin32.base;
const d3d12 = zwin32.d3d12;
const hrPanic = zwin32.hrPanic;
const hrPanicOnFail = zwin32.hrPanicOnFail;
const zd3d12 = @import("zd3d12");
const common = @import("common");
cons... | samples/intro/src/intro6.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const Data = @This();
value: union(Type) {
bool: bool,
num: f64,
str: String,
array: Array,
map: Map,
nulled: void,
} = undefined,
allocator: Allocator = undefined,
pub const String = std.ArrayListUnmanaged(u8);
pub const Array ... | src/Data.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const AtomicOrder = builtin.AtomicOrder;
const AtomicRmwOp = builtin.AtomicRmwOp;
const assert = std.debug.assert;
const expect = std.testing.expect;
const windows = std.os.windows;
/// Lock may be held only once. If the same thread
/// tries to acqui... | lib/std/statically_initialized_mutex.zig |
const os = @import("std").os;
const wayland = @import("wayland");
const wl = wayland.server.wl;
pub const Device = extern struct {
fd: c_int,
device_id: c_int,
dev: os.dev_t,
/// Session.devices
link: wl.list.Link,
events: extern struct {
change: wl.Signal(void),
remove: wl.Si... | src/backend/session.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const core = @import("../index.zig");
const Coord = core.geometry.Coord;
const isCardinalDirection = core.geometry.isCardinalDirection;
const isScaledCardinalDirection = core.geometry.isScaledCardinalDirection;
const directionToCardinalIndex = core.geometry.d... | src/server/game_engine.zig |
usingnamespace @import("root").preamble;
const log = lib.output.log.scoped(.{
.prefix = "platform/acpi",
.filter = .info,
}).write;
const paging = os.memory.paging;
const pci = os.platform.pci;
const libalign = lib.util.libalign;
const range = lib.util.range;
const RSDP = packed struct {
signature: [8]u... | subprojects/flork/src/platform/acpi.zig |
const std = @import("std");
const upaya = @import("upaya");
const Writer = std.fs.File.Writer;
const Reader = std.fs.File.Reader;
const AppState = @import("app_state.zig").AppState;
const data = @import("map.zig");
const Map = data.Map;
const RuleSet = data.RuleSet;
const Rule = data.Rule;
const RuleTile = data.RuleT... | tilescript/persistence.zig |
const Wasm = @This();
const std = @import("std");
const Atom = @import("Atom.zig");
const Object = @import("Object.zig");
const types = @import("types.zig");
const Symbol = @import("Symbol.zig");
const sections = @import("sections.zig");
const leb = std.leb;
const fs = std.fs;
const Allocator = std.mem.Allocator;
co... | src/Wasm.zig |
const std = @import("std");
//--------------------------------------------------------------------------------------------------
const Entry = struct {
total_count: u64,
spawn_count: u64,
spawn_pair_left: [2]u8,
spawn_pair_right: [2]u8,
};
//------------------------------------------------------------... | src/day14.zig |
const std = @import("std");
const mem = std.mem;
const ArrayList = std.ArrayList;
const StringHashMap = std.hash_map.StringHashMap;
const LinearFifo = std.fifo.LinearFifo;
const Token = @import("token.zig").Token;
const ParseError = @import("parse_error.zig").ParseError;
const buildNamedCharacterReferenceTable = @impo... | src/tokenizer.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const window = @import("Window.zig");
const img = @import("Image.zig");
const Texture2D = img.Texture2D;
const MinFilter = img.MinFilter;
const ArrayList = std.ArrayList;
const c_allocator = std.heap.c_allocator;
const c = @import("c.zig"... | src/WindowGraphicsInput/ArrayTexture.zig |
const std = @import("std");
const server = &@import("../main.zig").server;
const Error = @import("../command.zig").Error;
const Seat = @import("../Seat.zig");
/// Switch focus to the passed tags.
pub fn setFocusedTags(
allocator: *std.mem.Allocator,
seat: *Seat,
args: []const [:0]const u8,
out: *?[]... | source/river-0.1.0/river/command/tags.zig |
const std = @import("std");
pub const Vec2 = packed struct {
x: f32 = 0.0,
y: f32 = 0.0,
pub fn Scale(self: *Vec2, scalar: f32) void {
self.x *= scalar;
self.y *= scalar;
}
pub fn GetScaled(self: *const Vec2, scalar: f32) Vec2 {
return Vec2{
.x = self.x * scala... | src/math/Vec2.zig |
const std = @import("std");
const traits = @import("./traits.zig");
pub const CommandSerializer = struct {
pub fn serializeCommand(msg: anytype, command: anytype) !void {
// Serializes an entire command.
// Callers can expect this function to:
// 1. Write the number of arguments in the comm... | src/serializer.zig |
const std = @import("std");
const builtin = @import("builtin");
const liu = @import("./lib.zig");
const Spec = liu.packed_asset.Spec;
const TypeInfo = liu.packed_asset.TypeInfo;
const tempEncode = liu.packed_asset.tempEncode;
const parse = liu.packed_asset.parse;
const U32Slice = liu.packed_asset.U32Slice;
test "Pack... | src/liu/test_packed_asset.zig |
const std = @import("std");
pub const ColorLookupTable: []const u8 align(32) = @embedFile("lut.dat");
pub const MapByteSize: usize = (128 * 128);
usingnamespace @import("threadpool");
const PartitionPool = ThreadPool(processMapPartition, null);
var coreCount: usize = undefined;
var pool: ?*PartitionPool = null;
pub ... | nativemap/src/mc.zig |
const std = @import("std");
const testing = std.testing;
const Allocator = std.mem.Allocator;
/// QueryParameters is an alias for a String HashMap
pub const QueryParameters = std.StringHashMap([]const u8);
/// Possible errors when parsing query parameters
const QueryError = error{ MalformedUrl, OutOfMemory, InvalidCh... | src/url.zig |
const std = @import("std");
const fs = std.fs;
const heap = std.heap;
const math = std.math;
const mem = std.mem;
const process = std.process;
const os = std.os;
const ChildProcess = std.ChildProcess;
pub fn copy(allocator: *mem.Allocator) !*ChildProcess {
var env = try process.getEnvMap(allocator);
defer en... | src/core/clipboard.zig |
const std = @import("std");
const utils = @import("utils.zig");
const Vec3 = @import("vec.zig").Vec3;
const Ray = @import("ray.zig").Ray;
const HitRecord = @import("sphere.zig").HitRecord;
pub const Material = union(enum) {
Lambertian: Lambertian,
Metal: Metal,
Dielectric: Dielectric,
pub fn lambert... | src/materials.zig |
const std = @import("std");
const fmt = std.fmt;
const algods = @import("algods");
const compiler = @import("main.zig");
const TokenKind = enum {
TK_IDENT, // Identifiers
TK_PUNCT, // Punctuators
TK_NUM, // Numeric literals
TK_EOF, // End-of-file markers
TK_KEYWORD, //Keywords
};
pub const Token =... | src/tokenizer.zig |
const std = @import("std");
const input = @embedFile("data/input12");
usingnamespace @import("util.zig");
pub fn main() !void {
const part1 = findManhattanDistance(input, .one);
const part2 = findManhattanDistance(input, .two);
print("[Part1] Distance: {}", .{part1});
print("[Part2] Distance: {}", .{p... | src/day12.zig |
const std = @import("std");
const assert = std.debug.assert;
pub const Time = struct {
const Self = @This();
/// Hardware and/or software bugs can mean that the monotonic clock may regress.
/// One example (of many): https://bugzilla.redhat.com/show_bug.cgi?id=448449
/// We crash the process for safet... | src/time.zig |
const MessageHeader = @import("message.zig").MessageHeader;
const futex_wait = @import("futex.zig").futex_wait;
const futex_wake = @import("futex.zig").futex_wake;
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const builtin = @import("builtin");
const AtomicOrder = builtin.... | message_queue.zig |
const std = @import("std");
const testing = std.testing;
const match_path = @import("match.zig");
const warn = std.debug.warn;
const MatchTest = struct {
pattern: []const u8,
s: []const u8,
match: bool,
err: ?match_path.MatchError,
fn init(
pattern: []const u8,
s: []const u8,
... | src/path/match_test.zig |
const serial = @import("../../debug/serial.zig");
pub const KERNEL_CODE = 0x08;
pub const KERNEL_DATA = 0x10;
pub const USER_CODE = 0x20;
pub const USER_DATA = 0x28;
pub const OVMF_DATA = 0x30;
pub const OVMF_CODE = 0x38;
pub const TSS_LOW = 0x40;
pub const TSS_HIGH = 0x48;
pub const KERNEL_RPL = 0b00;
pub const USER... | src/kernel/arch/x86/gdt.zig |
const std = @import("std");
const ztBuild = @import("src/deps/ZT/build.zig");
// ZLS kinda freaks out about not having a build file to parse, so this is
// a dummy build.
pub fn build(b: *std.build.Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const ... | build.zig |
const std = @import("std");
const testing = std.testing;
const SYS = std.os.SYS;
const syspect = @import("syspect");
const generic = @import("generic.zig");
const utils = @import("utils.zig");
const target_argv = [_][]const u8{"zig-cache/bin/tests/example-child_signals"};
const allocator = std.testing.allocator;
te... | tests/src/child_signals.zig |
const std = @import("std");
const ray = @import("ray.zig");
const scene = @import("scene.zig");
const camera = @import("camera.zig");
const config = @import("config.zig");
const sphere = @import("sphere.zig");
const vector = @import("vector.zig");
const material = @import("material.zig");
const Vec3 = config.Vec3;
pu... | src/ray.zig |
const std = @import("std");
const csig = @cImport({
@cInclude("signal.h");
});
const unistd = @cImport({
@cInclude("unistd.h");
});
const config = @import("config.zig");
const fs = std.fs;
const fmt = std.fmt;
const mem = std.mem;
const os = std.os;
const libc = std.c;
const time = std.time;
fn signalToString... | src/process.zig |
// SPDX-License-Identifier: MIT
// This file is part of the Termelot project under the MIT license.
//! Ziro is a super-simple terminal text editor written in Zig.
//! Ziro is inspired by [kilo](https://github.com/antirez/kilo),
//! and is intended to provide an example of using the Termelot
//! library.
const std =... | examples/ziro.zig |
const cc_bake = @import("cc_bake");
const cc_gfx = @import("cc_gfx");
const cc_res = @import("cc_res");
const cc_wnd = @import("cc_wnd");
const cc_wnd_gfx = @import("cc_wnd_gfx");
const Example = struct {
window: cc_wnd.Window,
gctx: cc_gfx.Context,
render_pipeline: cc_gfx.RenderPipeline,
};
pub fn init()... | ex/tri/tri.zig |
const Compilation = @This();
const std = @import("std");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const log = std.log.scoped(.compilation);
const Target = std.Target;
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const target_util = ... | src/Compilation.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const math = std.math;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectApproxEqRel = std.testing.expectApproxEqRel;
const Vector = std.meta.Vector;
test "implicit cast vector to array - bool... | test/behavior/vector.zig |
const std = @import("std");
const concepts = @import("../../lib.zig").concepts;
const assert = std.debug.assert;
pub fn Visitor(
comptime Context: type,
comptime Value: type,
comptime visitBool: @TypeOf(struct {
fn f(_: Context, _: ?std.mem.Allocator, comptime Deserializer: type, _: bool) Deseria... | src/de/interface/visitor.zig |
@compileError("abandoned prototype playground - unused, untested");
const std = @import("std");
// specialises on type like f32, i32 etc.
pub fn typed(comptime val_type) type {
return struct {
// helper for detecting generic struct type
const StructType = enum {
column_vector,
... | src/vecmath.zig |
const std = @import("std");
pub const PrintHelper = struct {
out: std.io.StreamSource.OutStream,
indentation: usize,
indent_next: bool,
pub fn init(out: std.io.StreamSource.OutStream) PrintHelper {
return .{
.out = out,
.indentation = 0,
.indent_next = false... | src/zangscript/print_helper.zig |
pub const D3DRTYPECOUNT = @as(u32, 8);
pub const D3DCS_LEFT = @as(i32, 1);
pub const D3DCS_RIGHT = @as(i32, 2);
pub const D3DCS_TOP = @as(i32, 4);
pub const D3DCS_BOTTOM = @as(i32, 8);
pub const D3DCS_FRONT = @as(i32, 16);
pub const D3DCS_BACK = @as(i32, 32);
pub const D3DCS_PLANE0 = @as(i32, 64);
pub const D3DCS_PLANE... | win32/graphics/direct3d9.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const config = @import("../config.zig");
const Message = @import("../message_pool.zig").MessagePool.Message;
const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
const vsr = @import("../vsr.zig");
const Header =... | src/vsr/replica.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_11_1.txt", std.math.maxInt(usize));
var lines = std.mem.tokenize(input, "\n");
... | 2020/src/day_11.zig |
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const net = std.net;
const os = std.os;
const time = std.time;
const Atomic = std.atomic.Atomic;
const assert = std.debug.assert;
const IO_Uring = std.os.linux.IO_Uring;
const io_ur... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const mem = std.mem;
pub const AnimationData = struct {
frame_count: u32,
frame_duration: u32, // microseconds
bone_count: u32,
bone_names: []const u8,
matrices_relative: []const f32,
matrices_absolute: []... | src/ModelFiles/AnimationFiles.zig |
pub usingnamespace @import("addr.zig");
/// Representations of various x86 specific structures and descriptor tables.
pub const structures = @import("structures/structures.zig");
/// Access to various system and model specific registers.
pub const registers = @import("registers/registers.zig");
/// Special x86_64 in... | src/index.zig |
pub const Resolutions = struct {
pub const Instagram = struct {
pub const square = Res.init(1080, 1080);
pub const portrait = AspectRatio.init(8, 10).shortSide(1080).portrait();
pub const landscape = AspectRatio.init(100, 191).longSide(1080);
pub const story = AspectRatio.init(16, 9)... | lib/resolutions.zig |
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
/// Returns `true` is the the bit at index `bit` is set (equals 1).
/// Note: that index 0 is the least significant bit, while index `length() - 1` is the most significant bit.
///
/// ```zig
/// const a: u8 = 0b00000010;
///
///... | src/internal/bitjuggle.zig |
const std = @import("std");
const assert = std.debug.assert;
const Camera = @import("Camera.zig");
const Light = @import("Light.zig");
const Material = @import("Material.zig");
const Mesh = @import("Mesh.zig");
const Renderer = @import("Renderer.zig");
const zp = @import("../../zplay.zig");
const drawcall = zp.graphics... | src/graphics/3d/SimpleRenderer.zig |
const std = @import("std");
const testing = std.testing;
const cats = @import("../ziglyph.zig").derived_general_category;
const numeric = @import("../ziglyph.zig").derived_numeric_type;
const props = @import("../ziglyph.zig").prop_list;
/// `isDecimal` detects all Unicode decimal numbers.
pub fn isDecimal(cp: u21) b... | .gyro/ziglyph-jecolon-github.com-c37d93b6/pkg/src/category/number.zig |
const std = @import("std");
const testing = std.testing;
const grains = @import("grains.zig");
const ChessboardError = grains.ChessboardError;
test "grains on square 1" {
const expected = 1;
const actual = comptime try grains.square(1);
comptime testing.expectEqual(expected, actual);
}
test "grains on sq... | exercises/practice/grains/test_grains.zig |
const std = @import("std");
const text = @import("text.zig");
const debug = std.debug;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const Content = Text.Content;
const Cursor = text.Cursor;
const Cursors = Text.Cursors;
const Location = text.Locat... | src/core/text_tests.zig |
const std = @import("std");
const net = std.net;
const fs = std.fs;
const os = std.os;
const system = std.system;
const print = std.debug.print;
// pub const io_mode = .evented
pub fn discover() void {
print("doing a discover for some servers\n", .{});
// TODO - run this as a thread, looping forever, and
... | src/disco/discovery.zig |
const std = @import("std");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
fn productT(comptime A: type, comptime B: type) type {
return struct {
const Self = @This();
list1: []const A,
list2: []const B,
pub fn init(list1: []const A, list2: []co... | src/product.zig |
const std = @import("std");
const uefi = std.os.uefi;
const Status = uefi.Status;
const EfiBlockMedia = extern struct {
/// The current media ID. If the media changes, this value is changed.
media_id: u32,
/// `true` if the media is removable; otherwise, `false`.
removable_media: bool,
/// `true` ... | lib/std/os/uefi/protocols/block_io_protocol.zig |
const std = @import("std");
const pokemon = @import("index.zig");
const nds = @import("../nds/index.zig");
const utils = @import("../utils/index.zig");
const common = @import("common.zig");
const fun = @import("../../lib/fun-with-zig/src/index.zig");
const mem = std.mem;
const lu16 = fun.platform.lu16;
const lu32 = f... | src/pokemon/gen4.zig |
const std = @import("std");
const c = @import("c.zig");
const helpers = @import("helpers.zig");
const varint = @import("varint.zig");
const constants = @import("constants.zig");
const Decoders = struct {
pub fn String(env: c.napi_env, source: []u8, start: u32, len: u32) !c.napi_value {
const end = start + ... | src/decode.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day06.txt");
c... | src/day06.zig |
const std = @import("std");
const utils = @import("./utils.zig");
const locks = .{
// ------------ Spin Locks ---------------
//@import("locks/ticket_lock.zig").Lock,
//@import("locks/mcs_lock.zig").Lock,
// ------------ System Locks ---------------
@import("locks/os_lock.zig").Lock,
@import(... | bench.zig |
const std = @import("std");
const warn = std.debug.warn;
pub usingnamespace @import("zig_grammar.tokens.zig");
const identifier_state = [128]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,... | zig/zig_lexer.zig |
const std = @import("std");
const fmt = std.fmt;
const dns = @import("./dns.zig");
const Type = dns.ResourceType;
pub const SOAData = struct {
mname: dns.Name,
rname: dns.Name,
serial: u32,
refresh: u32,
retry: u32,
expire: u32,
minimum: u32,
};
pub const MXData = struct {
preference:... | src/pkg2/rdata.zig |
const std = @import("std");
const nvg = @import("nanovg");
pub fn iconNew(vg: nvg) void {
vg.beginPath();
vg.moveTo(2.5, 0.5);
vg.lineTo(2.5, 15.5);
vg.lineTo(13.5, 15.5);
vg.lineTo(13.5, 3.5);
vg.lineTo(10.5, 0.5);
vg.closePath();
vg.fillColor(nvg.rgb(255, 255, 255));
vg.fill();
... | src/icons.zig |
const build_options = @import("build_options");
const print = @import("std").debug.print;
const CPU = @import("emu").CPU;
var mem: [0x10000]u8 = undefined;
// tick callback
fn tick(num_ticks: usize, pins: usize, userdata: usize) u64 {
_ = num_ticks;
_ = userdata;
if (0 != (pins & CPU.MREQ)) {
// ... | tests/z80zex.zig |
fn destroy(context: *Context, object: Object) anyerror!void {
// return error.DebugFunctionNotImplemented;
}
fn add(context: *Context, zwp_linux_buffer_params: Object, fd: i32, plane_idx: u32, offset: u32, stride: u32, modifier_hi: u32, modifier_lo: u32) anyerror!void {
const params = @intToPtr(*Params, zwp_li... | src/implementations/zwp_linux_buffer_params.zig |
const std = @import("std");
const testing = std.testing;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const mustache = @import("../mustache.zig");
const TemplateOptions = mustache.options.TemplateOptions;
const Element = mustache.Element;
const ref_counter = @import("ref_counter.zig");
cons... | src/parsing/node.zig |