text stringlengths 32 314k | url stringlengths 93 243 |
|---|---|
//
// Another useful application for bit manipulation is setting bits as flags.
// This is especially useful when processing lists of something and storing
// the states of the entries, e.g. a list of numbers and for each prime
// number a flag is set.
//
// As an example, let's take the Pangram exercise from Exercism:... | https://raw.githubusercontent.com/zzhaolei/ziglings/e8c3b28199122b983adf9b7a24d6477054b25758/exercises/098_bit_manipulation2.zig |
const std = @import("std");
pub fn twoFer(buffer: []u8, name: ?[]const u8) anyerror![]u8 {
return std.fmt.bufPrint(buffer, "One for {s}, one for me.", .{name orelse "you"});
}
| https://raw.githubusercontent.com/ArturMroz/exercism/89c48a757e1e2e3b6973b8dd23366243337bbc30/zig/two-fer/two_fer.zig |
pub const AllocateType = @import("tables/boot_services.zig").AllocateType;
pub const BootServices = @import("tables/boot_services.zig").BootServices;
pub const ConfigurationTable = @import("tables/configuration_table.zig").ConfigurationTable;
pub const global_variable align(8) = @import("tables/runtime_services.zig").g... | https://raw.githubusercontent.com/ziglang/gotta-go-fast/c915c45c5afed9a2e2de4f4484acba2df5090c3a/src/self-hosted-parser/input_dir/os/uefi/tables.zig |
const std = @import("std");
const wren = @import("wren");
pub var alloc = std.testing.allocator;
pub fn main() anyerror!void {
// Initialize the data structures for the wrapper
wren.init(alloc);
defer wren.deinit();
// Set up a VM configuration using the supplied default bindings
// You can overr... | https://raw.githubusercontent.com/NewbLuck/zig-wren/cdb4ee342c00ce17518720333a8d07203d78bdd2/example/basic.zig |
pub const cell_phone = struct {
pub usingnamespace @import("../locales/fa/cell_phone.zig");
};
pub const color = struct {
pub usingnamespace @import("../locales/fa/color.zig");
};
pub const commerce = struct {
pub usingnamespace @import("../locales/fa/commerce.zig");
};
pub const company = struct {
p... | https://raw.githubusercontent.com/cksac/faker-zig/5a51eb6e6aa4ce50a25a354affca36e8fa059675/src/locale/fa.zig |
const std = @import("std");
const base64 = @import("base64.zig"); // Assume the provided code is in base64.zig
export fn decodeBase64(encoded: [*c]const u8, encoded_len: usize, decoded: [*]u8, decoded_len: *usize) c_int {
var allocator = std.heap.page_allocator;
const encoded_slice = std.mem.slice(u8, encoded,... | https://raw.githubusercontent.com/TylerKerch/TreeHacks2024/921eeadd49457d55d18ea84864b8473c063af3ad/backend/base64.zig |
const std = @import("std");
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "games",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimiz... | https://raw.githubusercontent.com/Hejsil/games/f78ccccae233aefe863af9ab2ea1be41eae5cd8b/build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
try sierpinski_triangle(allocator, stdou... | https://raw.githubusercontent.com/acmeism/RosettaCodeData/29a5eea0d45a07fe7f50994dd8a253eef2c26d51/Task/Sierpinski-triangle/Zig/sierpinski-triangle-2.zig |
pub const SourceFile = @import("SourceFile.zig");
pub const FileWatcher = @import("FileWatcher.zig");
| https://raw.githubusercontent.com/guidoschmidt/zreload/749f5d4a982547f2e4b763ad818f445f1c450256/src/lib.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 util = @import("util.zig");
const gpa = util.gpa;
pub const data = @embedFile("data/day03.txt");
const testdata = "^>v<";
... | https://raw.githubusercontent.com/jgh713/aoc/9ce203e4d6f53a81ad14e7b0eb095657df4f18e6/2015/src/day03.zig |
const std = @import("std");
const utils_mod = @import("../utils.zig");
const print = utils_mod.print;
const value_mod = @import("../value.zig");
const Value = value_mod.Value;
const ValueDictionary = value_mod.ValueDictionary;
const ValueHashMapContext = value_mod.ValueHashMapContext;
const ValueSliceHashMapContext =... | https://raw.githubusercontent.com/dstrachan/openk/0a739d96593fe3e1a7ebe54e5b82e2a69f64302a/src/verbs/group.zig |
const std = @import("std");
const Compiler = @import("Compiler.zig");
const Context = @import("Context.zig");
const Lexer = @import("Lexer.zig");
const Node = @import("Node.zig");
const Parser = @import("Parser.zig");
fn printUsage() !void {
std.log.err("Usage: zedc <your_program_file.zed>", .{});
return erro... | https://raw.githubusercontent.com/jreniel/zed/a40574112ad11db60157608ebf9e2835fb149ee6/src/zedc.zig |
//! Misc things that will be moved into the standard library once this is complete
const std = @import("std");
const builtin = @import("builtin");
pub const windows = struct {
const HKEY = std.os.windows.HKEY;
const USHORT = std.os.windows.USHORT;
const ULONG = std.os.windows.ULONG;
const HANDLE = std... | https://raw.githubusercontent.com/squeek502/get-known-folder-path/8dce70ef977400212ba88905ed4aeefed4c5915c/src/misc.zig |
const builtin = @import("builtin");
const std = @import("std");
const utils = @import("../utils.zig");
const apputils = @import("./utils.zig");
const State = @import("./State.zig");
const Item = @import("../fs/Item.zig");
const ascii = std.ascii;
const log = std.log.scoped(.actions);
pub fn moveCursorUp(state: *Sta... | https://raw.githubusercontent.com/18alantom/fex/e17853f3833391127863a30e35435af52da89a1e/app/actions.zig |
const std = @import("std");
const Parser = @import("../Parser.zig");
pub const LispState = struct {};
pub const Type = union(enum(u32)) {
Nil: void, // nil
Char: void, // 'a'
String: void, // "abc"
Integer32: void, // (as i32 1)
UInteger32: void, // (as u32 1)
Boolean: void, // true, false
... | https://raw.githubusercontent.com/QuentinTessier/ZigParsec/c8a00cc2ec8d67a875e3ce11f8b98ff2d90cafa8/src/examples/lisp.zig |
const gl = @import("gl");
pub const ShaderError = error{
CompileError,
LinkError,
};
var error_buffer: [8192]u8 = undefined;
var message: ?[]const u8 = null;
pub fn getErrorMessage() []const u8 {
if (message) |msg| {
message = null;
return msg;
} else {
@panic... | https://raw.githubusercontent.com/ousttrue/zigsg/52ffe00bd9f078468331b964f878d11574db9eb4/zigsg/pkgs/glo/src/error_handling.zig |
const std = @import("std");
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const backend = b.addStaticLibrary(.{
.name = "li8z",
.root_source_file = b.path("src/backend.zig"),
.target = target,
... | https://raw.githubusercontent.com/Kapongoboy/li8z/2e96227e4089a86d1da0948698fe1a3c9e42922c/build.zig |
const std = @import("std");
const root = @import("root");
const rl = @import("raylib");
const ecs = @import("../ecs/ecs.zig");
const simulation = @import("../simulation.zig");
const render = @import("../render.zig");
const input = @import("../input.zig");
const AssetManager = @import("../AssetManager.zig");
const Invar... | https://raw.githubusercontent.com/INDA23PlusPlus/plusplusparty/15ed55659234db31b2db7c4f1ab1ee2e8704084e/src/minigames/hot_n_steamy.zig |
const std = @import("std");
const vk = @import("vulkan");
const core = @import("core");
const VkConstants = @import("vk_constants.zig");
const meshes = @import("mesh.zig");
const NeonVkContext = @import("vk_renderer.zig").NeonVkContext;
const vk_pipeline = @import("vk_pipeline.zig");
const NeonVkPipelineBuilde... | https://raw.githubusercontent.com/peterino2/NeonWood/705a04e06aa60736e0af02ad00cd0d4c37f07921/engine/graphics/src/materials.zig |
///
/// TOPPERS/ASP Kernel
/// Toyohashi Open Platform for Embedded Real-Time Systems/
/// Advanced Standard Profile Kernel
///
/// Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
/// Toyohashi Univ. of Technology, JAPAN
/// Copyright (C) 2004-2021 by Embe... | https://raw.githubusercontent.com/toppers/asp3_in_zig/7413474dc07ab906ac31eb367636ecf9c1cf2580/sample/sample3.zig |
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const ArrayList = std.ArrayList;
/// An operation on the bus.
pub const BusOperation = enum {
/// A request to read a byte from the bus.
Read,
/// A request to write a byte to the bus.
Write,
};
/// An interface for anything... | https://raw.githubusercontent.com/brodeuralexis/zasm-emulator/aa6b25f79eb710efde1f96261222e04d8cc326b6/src/bus.zig |
const str = []const u8;
const std = @import("std");
const builtin = @import("builtin");
const util = @import("util.zig");
const init = @import("./init.zig");
const repl = @import("./repl.zig");
const compile = @import("./compile.zig");
const build = @import("./build.zig");
const help = @import("./help.zig");
const proc... | https://raw.githubusercontent.com/clpi/idula/7b12447620025e86b3c460f52239337214838135/src/cli/run.zig |
const std = @import("std");
const windows = std.os.windows;
const builtin = @import("builtin");
const Foo = @import("root.zig").Foo;
// Windows
extern "kernel32" fn GetProcAddress(h_module: windows.HMODULE, fn_name: windows.LPCSTR) callconv(windows.WINAPI) ?windows.FARPROC;
extern "kernel32" fn LoadLibraryA(fn_name: ... | https://raw.githubusercontent.com/Skarsh/zig-dll-demo/3aed5223653a4307236e2be9853e7ba138ce589d/src/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const split = std.mem.splitSequence;
const splitBackwards = std.mem.splitBackwardsSequence;
const tokenize = std.mem.tokenizeAny;
const sort = std.mem.sort;
const parseInt = std.fmt.parseInt;... | https://raw.githubusercontent.com/Frechdachs/AoC/07e32616f4b8b08830eb5e4206a336ff97d61ec7/2023/05.zig |
pub const area_code = [_][]const u8{ "392", "510", "512", "522", "562", "564", "592", "594", "800", "811", "822", "850", "888", "898", "900", "322", "416", "272", "472", "382", "358", "312", "242", "478", "466", "256", "266", "378", "488", "458", "228", "426", "434", "374", "248", "224", "286", "376", "364", "258", "41... | https://raw.githubusercontent.com/cksac/faker-zig/5a51eb6e6aa4ce50a25a354affca36e8fa059675/src/locales/tr/phone_number.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for rest... | https://raw.githubusercontent.com/zakinomiya/zigsh/ac41ea5de049e2feeb54dfe047a699114cbf75e4/build.zig |
const std = @import("std");
const zsdl_build = @import("zsdl");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) !void {
// Standard target options allows the person running `zig ... | https://raw.githubusercontent.com/thng292/nese/b7597b5298194564acc4251def549df21a1c118e/build.zig |
// SPDX-License-Identifier: MIT
// Copyright (c) 2015-2021 Zig Contributors
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const std = @import("std");
const builtin = ... | https://raw.githubusercontent.com/dip-proto/zig/8f79f7e60937481fcf861c2941db02cbf449cdca/lib/std/c.zig |
const std = @import("std");
pub const parser = @import("parser/parser.zig");
pub const base = @import("base/base.zig");
const common = @import("common.zig");
pub const MessageHeader = common.MessageHeader;
pub const Opcode = common.Opcode;
comptime {
std.testing.refAllDecls(@This());
}
| https://raw.githubusercontent.com/truemedian/wz/fa698c2493bcc084b86e77fc9baa54dac6bfed44/src/main.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for rest... | https://raw.githubusercontent.com/mamico/adventofcode/f97f3f2da4c0c9b07227951e0ad84b22fb5775ac/day-01/build.zig |
//
// File: main.zig
// Created on: Monday, 2023-12-04 @ 21:01:06
// Author: HackXIt (<hackxit@gmail.com>)
// -----
// Last Modified: Monday, 2023-12-04 @ 23:52:36
// Modified By: HackXIt (<hackxit@gmail.com>) @ HACKXIT
// -----
//
const std = @import("std");
const expect = std.testing.expect;
fn sumOfLine(line: []c... | https://raw.githubusercontent.com/HackXIt/advent-of-code-2023/9da0ace2a824ba1364d78aa32032d337a920535e/day1/src/main.zig |
//!
//! Implements a N*M keyboard matrix that will be scanned in column-major order.
//!
const std = @import("std");
const mdf = @import("../framework.zig");
/// A single key in a 2D keyboard matrix.
pub const Key = enum(u16) {
// we just assume we have enough encoding space and not more than 256 cols/rows
_,... | https://raw.githubusercontent.com/ZigEmbeddedGroup/microzig-driver-framework/50f97ff54c1f2e738b85b8d1394428612728aeb9/driver/input/keyboard-matrix.zig |
const std = @import("std");
const lib = @import("lib.zig");
const constants = @import("constants.zig");
pub const STAR = constants.STAR;
pub const TEXT = constants.TEXT;
pub const IMAGE = constants.IMAGE;
pub const AUDIO = constants.AUDIO;
pub const VIDEO = constants.VIDEO;
pub const APPLICATION = constants.APPLICATI... | https://raw.githubusercontent.com/yukiolabs/mime/4b3b700ad78ef85024c41f083408b94136391d93/src/parse/parse.zig |
const std = @import("std");
const Runtime = @import("runtime.zig");
pub const base = @import("ipc/base.zig");
pub const socket = @import("ipc/socket.zig");
pub const Type = base.Type;
/// Kinds of IPC instances
pub const Kind = enum {
socket,
};
pub const Params = union(Kind) {
socket: socket.Params,
pub fn ... | https://raw.githubusercontent.com/ExpidusOS/neutron/65ee6242e8ea42d072dfdaf07ee475d18ae5a3e1/src/neutron/runtime/ipc.zig |
const std = @import("std");
const w4 = @import("wasm4.zig");
var frame: u64 = 0;
var rng_impl = std.rand.DefaultPrng.init(0xdeadbeef);
pub const rng = rng_impl.random();
pub fn update() void {
// gather entropy from player inputs
if (w4.GAMEPADS[0].v != 0) {
rng_impl.s[0] = hash(rng_impl.s[0] ^ w4.GAM... | https://raw.githubusercontent.com/12Boti/wloku/379277fdad85c9236623da0ef441ad2f1af03f33/src/rng.zig |
const std = @import("std");
const base64 = @import("base64");
fn runEncodeBench(use_std: bool) !usize {
var file = try std.fs.cwd().openFile("./benchmark/testdata/encode-test-data", .{});
defer file.close();
var buf_reader = std.io.bufferedReader(file.reader());
var in_stream = buf_reader.reader();
... | https://raw.githubusercontent.com/dying-will-bullet/base64-simd/ac5bb035e131548cdd0f7924d55e391c39aef1d3/benchmark/main.zig |
const std = @import("std");
const uefi = std.os.uefi;
const io = std.io;
const Guid = uefi.Guid;
const Time = uefi.Time;
const Status = uefi.Status;
pub const FileProtocol = extern struct {
revision: u64,
_open: fn (*const FileProtocol, **const FileProtocol, [*:0]const u16, u64, u64) callconv(.C) Status,
_... | https://raw.githubusercontent.com/ziglang/gotta-go-fast/c915c45c5afed9a2e2de4f4484acba2df5090c3a/src/self-hosted-parser/input_dir/os/uefi/protocols/file_protocol.zig |
const std = @import("std");
const Entities = @import("Entities.zig");
const Entity = @import("Entity.zig");
const World = @import("World.zig");
fn isQueryItemPointer(comptime T: type) bool {
switch (@typeInfo(T)) {
.Pointer => |pointer| return pointer.size == .One and !pointer.is_const,
else => re... | https://raw.githubusercontent.com/Sudoku-Boys/Sudoku/218ea16ecc86507698861b59a496ff178a7a7587/src/engine/query.zig |
const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const c = @cImport({
@cInclude("raylib.h");
@cInclude("iconset.rgi.h");
@cDefine("RAYGUI_CUSTOM_ICONS", "");
@cDefine("RAYGUI_IMPLEMENTATION", "");
@cInclude("raygui.h");
});
state: State,
pixel_size: ... | https://raw.githubusercontent.com/ianprime0509/ripple-garden/f25d88738d31874656d29cebd4767dabef4cc897/src/App.zig |
const std = @import("std");
const Builder = std.build.Builder;
const Pkg = std.build.Pkg;
pub fn build(b: *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 ... | https://raw.githubusercontent.com/haze/zirconium/44f8ab6eab755c8b4a8d6a527099bdae3aaacdd6/examples/bruh/build.zig |
const std = @import("std");
const expect = std.testing.expect;
fn parseString(comptime string: []const u8) usize {
comptime {
var i: usize = 0;
for (string, 0..) |char, pos| {
if (char == '$') i += 1;
_ = pos;
}
return i;
}
}
test "parsing string at co... | https://raw.githubusercontent.com/jacksonmowry/jacksonmowry.github.io/40f9a0d2df7da0cf17b77eb4a8108584ac3e5e27/zig/string_parsing.zig |
//
// Now let's create a function that takes a parameter. Here's an
// example that takes two parameters. As you can see, parameters
// are declared just like any other types ("name": "type"):
//
// fn myFunction(number: u8, is_lucky: bool) {
// ...
// }
//
const std = @import("std");
pub fn main() voi... | https://raw.githubusercontent.com/samwho/ziglings/3c59fe9a6e341e04eaa154c047ce5d861a44ea8c/exercises/019_functions2.zig |
const std = @import("std");
const builtin = @import("biiltin");
const Writer = struct {
ptr: *anyopaque,
writeAllFn: *const fn (ptr: *anyopaque, data: []const u8) anyerror!void,
fn init(ptr: anytype) Writer {
const T = @TypeOf(ptr);
const ptr_info = @typeInfo(T);
if (ptr_info != .P... | https://raw.githubusercontent.com/rsphing/algo.zig/66b4ddfcc48f9cd006e5f726145f2408b55a7848/interface.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const StringHashMap = std.StringHashMap;
const mem = std.mem;
const Dependency = @import("Dependency.zig");
const Entry = StringHashMap(Dependency).Entry;
pub fn write(alloc: Allocator, out: anytype, deps: StringHashMap(Dependency)) !void {
try out... | https://raw.githubusercontent.com/nix-community/zon2nix/4394c25250810fdeb9559f3cda7a08226ce6e5a7/src/codegen.zig |
const std = @import("std");
const za = @import("zalgebra");
const gl = @import("../web/webgl.zig");
const Vec3 = za.Vec3;
const Mat4 = za.Mat4;
const Plane = @import("../math.zig").Plane;
const ShaderInfo = @import("../Model.zig").ShaderInfo;
const Map = @import("../Map.zig");
const Actor = @import("Actor.zig");
const ... | https://raw.githubusercontent.com/fabioarnold/3d-game/ea0ad17d23cedfa9008b25f8a1dd35eb0fc4773f/src/actors/Solid.zig |
const std = @import("std");
pub fn main() void {
std.debug.print("Powers of two: {} {} {} {}\n", .{
twoToThe(1),
twoToThe(2),
twoToThe(3),
twoToThe(4),
});
}
fn twoToThe(my_number: u32) u32 {
return std.math.pow(u32, 2, my_number);
}
| https://raw.githubusercontent.com/4klabs/ziglings/0538ef97f1fea0b54c1b2c5be013a52e3066fc06/exercises/019_functions2.zig |
const std = @import("std"); //lib base.
const c = @import("c.zig"); //import all C lib declared.
const AllocatorManager = @import("allocator_manager.zig").AllocatorManager;
pub fn ValuePrintable(comptime type_send: type) type {
return struct {
value: type_send = undefined,
texture: *c.SDL_Texture =... | https://raw.githubusercontent.com/Ailten/zigTuber/695a6cd342fb02fbf1ac8ea2066d6d5a0d4d3d63/src/value_printable.zig |
//! Build-time tool for generating copy-and-patch instruction templates
const std = @import("std");
comptime {
// So we can liberally throw around `unreachable`s without worrying about safety :)
std.debug.assert(@import("builtin").mode == .Debug);
}
const Sections = struct {
text: ?std.elf.Elf64_Shdr = nu... | https://raw.githubusercontent.com/silversquirl/chip8/9f48263f580526e5463fda693ef50fedbad77ca1/build/copy_patch_gen.zig |
// Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
//
// SPDX-License-Identifier: GPL-3.0-only
const std = @import("std");
const Allocator = std.mem.Allocator;
const ref_counted = @import("./ref_counted.zig");
fn WeakHandle(comptime T: type) type {
return struct {
allocator: Allocator,
ptr: ... | https://raw.githubusercontent.com/sin-ack/zigself/0610529f7a04ec0d0628abc3e89dafd45b995562/src/utility/weak_ref.zig |
const std = @import("std");
const isNan = std.math.isNan;
const isInf = std.math.isInf;
const copysign = std.math.copysign;
pub fn Complex(comptime T: type) type {
return extern struct {
real: T,
imag: T,
};
}
/// Implementation based on Annex G of C17 Standard (N2176)
pub inline fn mulc3(comp... | https://raw.githubusercontent.com/mazino3/ziglang/3db8cffa3b383011471f425983a7e98ad8a46aa5/lib/compiler_rt/mulc3.zig |
const std = @import("std");
const utils = @import("utils.zig");
pub const Writer = std.net.Stream.Writer;
pub const Reader = std.net.Stream.Reader;
const PlaybackError = error{ PauseFailure, BadSongIndex, NotPlaying, GeneralError, ReadError };
pub fn pause(writer: Writer) anyerror!void {
try writer.writeAll("pau... | https://raw.githubusercontent.com/tgmatos/mpdz/d9d396cff8cb8a34f41bd552de74f34e2061de11/src/playback.zig |
pub fn main() void {
std.debug.print("Hello World", .{});
}
| https://raw.githubusercontent.com/resqiar/playground/de1d7dc9d5d0617cc113e969bc126007396522b5/zig/hello.zig |
const Allocator = std.mem.Allocator;
const std = @import("std");
pub fn Grid(comptime T: type) type {
return struct {
items: [][]T = &[_][]T{},
neighbor_list: std.ArrayListUnmanaged(T) = .{},
default_value: T,
pub fn init(a: Allocator, width: usize, height: usize, default_value: T)... | https://raw.githubusercontent.com/VisenDev/ziggity/7dce0f51e093f2f9f352697b3d659be51672098d/src/grid.zig |
const std = @import("std");
pub const audio_graph = @import("audio_graph.zig");
pub const system = @import("system.zig");
pub const module = @import("module.zig");
pub const modules = module.modules;
pub const sample_buffer = @import("sample_buffer.zig");
const Utility = modules.Utility;
const SamplePlayer = modules.... | https://raw.githubusercontent.com/yurapyon/kasumi/ab28ba23fb4883978be762e25f1ce93fc0f8874c/src/main.zig |
const std = @import("std");
// For each location in the configuration and each group index store the number
// of possible valid states from there.
const DataCache = struct {
cache: [][]?u64,
fn init(config_len: usize, num_groups: usize, alloc: std.mem.Allocator) !DataCache {
var cache = try alloc.alloc([]?u6... | https://raw.githubusercontent.com/AlexKent3141/aoc23/540e74c40a558e4b2eb2068f9d60af33b0626e66/day12/d12.zig |
const std = @import("std");
pub const TicketLock = struct {
serving: u64 = 0,
taken: u64 = 0,
pub fn lock(self: *TicketLock) void {
const ticket = @atomicRmw(u64, &self.taken, .Add, 1, .seq_cst);
while (true) {
if (@cmpxchgWeak(
u64,
&self.serving... | https://raw.githubusercontent.com/DanB91/Wozmon64/29920645644a04037a7906850ac58ab43312ada3/src/toolbox/src/atomic.zig |
const builtin = @import("builtin");
const common = @import("./common.zig");
const floatToInt = @import("./float_to_int.zig").floatToInt;
pub const panic = common.panic;
comptime {
if (common.want_windows_v2u64_abi) {
@export(__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage... | https://raw.githubusercontent.com/mazino3/ziglang/3db8cffa3b383011471f425983a7e98ad8a46aa5/lib/compiler_rt/fixunsdfti.zig |
//! This file is auto-generated by tools/update_cpu_features.zig.
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
a510,
a65,
a710,
a76,
a78,
a78c,
aes,
aggressive_fma,
alternate_sextload... | https://raw.githubusercontent.com/2lambda123/ziglang-zig/d7563a7753393d7f0d1af445276a64b8a55cb857/lib/std/Target/aarch64.zig |
const std = @import("std");
const App = @import("app.zig").App;
const Terminal = @import("terminal.zig");
const DB = @import("db.zig");
const ansi_term = @import("ansi-term");
const Command = union(enum) {
add: []const u8,
rm: []const u8,
reset,
help,
sync,
};
const helpMenu =
\\Usage: sw [opt... | https://raw.githubusercontent.com/1nwf/switch/a8d03f3430f7a06689b5506c4e9f837a073cc863/src/main.zig |
//
// Now let's create a function that takes a parameter. Here's an
// example that takes two parameters. As you can see, parameters
// are declared just like any other types ("name": "type"):
//
// fn myFunction(number: u8, is_lucky: bool) {
// ...
// }
//
const std = @import("std");
pub fn main() voi... | https://raw.githubusercontent.com/rhysd/misc/5beb6fa40784e82452ce60af2adbb5d73903a5d7/ziglings/19_functions2.zig |
pub const QueenError = error{
InitializationFailure,
};
pub const Queen = struct {
row: i8,
col: i8,
pub fn init(row: i8, col: i8) QueenError!Queen {
if (row < 0 or 7 < row) {
return QueenError.InitializationFailure;
}
if (col < 0 or 7 < col) {
return Qu... | https://raw.githubusercontent.com/ar90n/lab/6623f927466522ab5a47dfe67a5903da7c97d48b/sandbox/exercism/zig/queen-attack/queen_attack.zig |
allocator: std.mem.Allocator,
const RHI = @This();
var rhi: *RHI = undefined;
fn messageCallback(
source: c.GLenum,
err_type: c.GLenum,
id: c.GLuint,
severity: c.GLenum,
length: c.GLsizei,
message: [*c]const c.GLchar,
_: ?*const anyopaque,
) callconv(.C) void {
const source_str: []con... | https://raw.githubusercontent.com/btipling/foundations/287121cad75f9af5d5188d2ced629e7509d96843/src/foundations/rhi/rhi.zig |
const std = @import("std");
const root = @import("main.zig");
const math = std.math;
const expectEqual = std.testing.expectEqual;
const expect = std.testing.expect;
const panic = std.debug.panic;
pub const Vec2 = GenericVector(2, f32);
pub const Vec2_f64 = GenericVector(2, f64);
pub const Vec2_i32 = GenericVector(2, i... | https://raw.githubusercontent.com/contextfreeinfo/taca/9ad697eae9b372620121b2c77305b1b1890ea658/examples/zig/zalgebra/generic_vector.zig |
const std = @import("std");
const api = @import("../api.zig");
// backends
const sdl = @import("Backends/SDL.zig");
pub const GraphicsError = error{
InitFailure,
OutOfBounds,
};
pub const GfxError = error{
FileNotFound,
AllocFailure,
InvalidFile,
};
const RenderType = enum {
software,
h... | https://raw.githubusercontent.com/GeffDev/mode7/91844e40e483babe876bab61ee68f5620f6ea810/src/Graphics/Drawing.zig |
pub const parseFloat = @import("parse_float/parse_float.zig").parseFloat;
pub const ParseFloatError = @import("parse_float/parse_float.zig").ParseFloatError;
const std = @import("std");
const math = std.math;
const testing = std.testing;
const expect = testing.expect;
const expectEqual = testing.expectEqual;
const exp... | https://raw.githubusercontent.com/beingofexistence13/multiversal-lang/dd769e3fc6182c23ef43ed4479614f43f29738c9/zig/lib/std/fmt/parse_float.zig |
const std = @import("std");
const serializer = @import("serializer.zig");
pub const JsonLexicon: serializer.Lexicon = .{ .convert = _jsonLexConv, .parse = _jsonLexParse };
fn _jsonLexConv(alloc: *std.mem.Allocator, tree: *serializer.Tree) []const u8 {
var bytes = std.ArrayList(u8).init(alloc);
_jsonLexInner(t... | https://raw.githubusercontent.com/JonSnowbd/slingworks/2c6b059431c6944511dc55717ef226cd3baaf800/src/serializer_json.zig |
const std = @import("std");
pub usingnamespace std.log.scoped(.zigscanner);
| https://raw.githubusercontent.com/Sirius902/zigscanner/77d2c9567c98e82025c1ed71cf3e104efd4cf56e/src/log.zig |
const GPT = @This();
const lib = @import("lib");
const assert = lib.assert;
const kb = lib.kb;
const mb = lib.mb;
const gb = lib.gb;
const CRC32 = lib.CRC32;
const Disk = lib.Disk;
const Filesystem = lib.Filesystem;
const FAT32 = Filesystem.FAT32;
const log = lib.log.scoped(.GPT);
const MBR = lib.PartitionTable.MBR;
c... | https://raw.githubusercontent.com/birth-software/birth/23a3c67990b504c487bbcf21dc4f76e898fa23b8/src/lib/partition_table/gpt.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;
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
pub const gpa = gpa_impl.allocator();
// Add uti... | https://raw.githubusercontent.com/famuyiwadayo/advent-of-code-2020-zig/3a8d532b9a3b1e33df21062119df8a30ac388a44/src/util.zig |
//! Randomly test data and lower it down
const std = @import("std");
const trait = @import("trait.zig");
pub fn forAll(comptime T: type) Iterator(T) {
return Iterator(T).init();
}
fn threwError(func: anytype, item: anytype) bool {
const originalStackDepth: usize = blk: {
if (@errorReturnTrace()) |trac... | https://raw.githubusercontent.com/capy-ui/capy/0f714f8317f69e283a1cdf49f2f39bdfdd88ec95/src/fuzz.zig |
//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (64)
//--------------------------------------------------------------------------------
pub const WM_DDE_FIRST = @as(u32, 992);
pub const WM_DDE_TERMINATE = @as(u3... | https://raw.githubusercontent.com/OAguinagalde/tinyrenderer/20e140ad9a9483d6976f91c074a2e8a96e2038fb/dep/zigwin32/src/win32/api/data_exchange.zig |
//! Base integer ISA, proceeded by RV32 or RV64 depending on register width
const instruction = @import("../instruction.zig");
const opcode = instruction.opcode;
const funct3 = instruction.funct3;
const funct12 = instruction.funct12;
const FenceOperands = instruction.FenceOperands;
const mmu = @import("../mmu.zig");
c... | https://raw.githubusercontent.com/LindonKelley/riscv-emu/6dd1a4937aafb5cf350f8b961f4000e77ef04c92/src/extension/I.zig |
//
// One of the more common uses of 'comptime' function parameters is
// passing a type to a function:
//
// fn foo(comptime MyType: type) void { ... }
//
// In fact, types are ONLY available at compile time, so the
// 'comptime' keyword is required here.
//
// Please take a moment to put on the wizard hat which h... | https://raw.githubusercontent.com/booklearner/ziglings/a723a4c1df3276b31733e13b16a33e859c831188/exercises/069_comptime4.zig |
//
// You can also make pointers to multiple items without using a slice.
//
// var foo: [4]u8 = [4]u8{ 1, 2, 3, 4 };
// var foo_slice: []u8 = foo[0..];
// var foo_ptr: [*]u8 = &foo;
//
// The difference between foo_slice and foo_ptr is that the slice has
// a known length. The pointer doesn't. It is up to ... | https://raw.githubusercontent.com/gmeir/ziglings/3af093bb3ac426fc57d68ed8a75bf896600c4932/exercises/054_manypointers.zig |
const std = @import("std");
const PrintHelper = @import("print_helper.zig").PrintHelper;
const CodegenState = @import("codegen.zig").CodegenState;
const CodegenModuleState = @import("codegen.zig").CodegenModuleState;
const ExpressionResult = @import("codegen.zig").ExpressionResult;
const BufferDest = @import("codegen.z... | https://raw.githubusercontent.com/justjosias/zang/13e78fd332c30be704863eb96e27a2a39df1bacd/src/zangscript/codegen_print.zig |
const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target t... | https://raw.githubusercontent.com/ThePrimeagen/ts-rust-zig-deez/3441b21d30a8d8488f2bec85cef4f9054891e9ea/zig/build.zig |
//------------------------------------------------------------------------------
// blend.zig
// Test/demonstrate blend modes.
//------------------------------------------------------------------------------
const sokol = @import("sokol");
const slog = sokol.log;
const sg = sokol.gfx;
const sapp = sokol.app;
con... | https://raw.githubusercontent.com/CU-Production/nesemu.zig/5cc75ac5dd88a49c542a5fe2695134be8fa469a2/lib/sokol-zig/src/examples/blend.zig |
const std = @import("std");
pub fn build(b: *std.Build) !void {
const target_query: std.Target.Query = .{};
const target = b.resolveTargetQuery(target_query);
const optimize = b.standardOptimizeOption(.{});
const lib = b.addStaticLibrary(.{
.name = "llvm",
.root_source_file = .{.path ... | https://raw.githubusercontent.com/kassane/llvm-zig/6cb8d824d6c67e43e371f1bd5ec3ad1cf5773021/build.zig |
const std = @import("std");
const SyntaxNode = @import("SyntaxNode.zig");
const StatementSyntax = @import("StatementSyntax.zig");
const ExpressionSyntax = @import("ExpressionSyntax.zig");
const SyntaxToken = @import("SyntaxToken.zig");
const AllocError = std.mem.Allocator.Error;
base: StatementSyntax,
keyword_token: ... | https://raw.githubusercontent.com/Phytolizer/Minsk/50609232b5d6fecccfebb68f742523b38ed8ec4e/zig/minsk/src/code_analysis/syntax/VariableDeclarationSyntax.zig |
const std = @import("std");
const llvm = @import("llvm.zig");
const Allocator = std.mem.Allocator;
const ValueSeq = std.ArrayListUnmanaged(llvm.Value);
allocator: Allocator,
write_operands: ValueSeq = undefined,
read_operands: ValueSeq = undefined,
pub fn init(allocator: Allocator) @This() {
return .{
.a... | https://raw.githubusercontent.com/lovebaihezi/diff-based-analyze/bb2d88328d5d858c124e2d5e0e3c957326a0ab52/src/variable_info.zig |
const std = @import("std");
const tk = @import("tokamak");
const fr = @import("fridge");
const schema = @import("../schema.zig");
const llama = @import("../llama.zig");
const template = @import("../template.zig");
const completions = @import("completions.zig");
const GenerateParams = struct {
model: []const u8,
... | https://raw.githubusercontent.com/cztomsik/ava/b3de783520a3e8bd1bed485d6f7cb6942fabf57d/src/api/quick-tools.zig |
// SPDX-License-Identifier: MIT
// Copyright (c) 2015-2021 Zig Contributors
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const uefi = @import("std").os.uefi;
const G... | https://raw.githubusercontent.com/dip-proto/zig/8f79f7e60937481fcf861c2941db02cbf449cdca/lib/std/os/uefi/protocols/ip6_protocol.zig |
usingnamespace @import("std").math;
usingnamespace @import("./math3d.zig");
pub fn clamp(val: f32, min_val: f32, max_val: f32) f32 {
return min(max_val, max(min_val, val));
}
pub fn saturate(f: f32) f32 {
if (f < 0) return 0;
if (f > 1) return 1;
return f;
}
pub fn unlerp(ax: f32, a1: f32, a2: f32) f... | https://raw.githubusercontent.com/kevinw/zig-wasm-game/31322890a15d25f1fca134980be7f043767d37a2/src/game_math.zig |
const std = @import("std");
const expect = std.testing.expect;
const Environment = @import("./env.zig");
const string = bun.string;
const stringZ = bun.stringZ;
const CodePoint = bun.CodePoint;
const bun = @import("root").bun;
pub const joiner = @import("./string_joiner.zig");
const log = bun.Output.scoped(.STR, true);... | https://raw.githubusercontent.com/beingofexistence13/multiversal-lang/dd769e3fc6182c23ef43ed4479614f43f29738c9/javascript/bun/src/string_immutable.zig |
const std = @import("std");
const core = @import("core.zig");
const ArrayListUnmanaged = std.ArrayListUnmanaged;
const tracy = core.tracy;
pub const Transform = core.Mat;
pub const SceneAttachMode = enum {
none, // default, parent attachment is irrelevant and not used
relativePositionOnly, // only position i... | https://raw.githubusercontent.com/peterino2/NeonWood/705a04e06aa60736e0af02ad00cd0d4c37f07921/engine/core/src/scene.zig |
const PacketNumberSpace = @import("../packet_number_space.zig").PacketNumberSpace;
pub const PacketType = enum {
// Long Header Packets
// https://www.rfc-editor.org/rfc/rfc9000.html#name-long-header-packets
initial,
zero_rtt,
handshake,
retry,
// This packet type is not identified by the p... | https://raw.githubusercontent.com/shiguredo/quic-server-zig/5e4a03df1063cf673b4ed9811e7280e6ddb1d2cc/src/packet/packet_type.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
const target = b.standardTargetOptions(.{});
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
//c... | https://raw.githubusercontent.com/YZITE/devpkg/6fbc88ba76707b8fe673708e19a8b77300e11155/build.zig |
const std = @import("std");
const Type = @import("type.zig").Type;
const log2 = std.math.log2;
const assert = std.debug.assert;
const BigIntConst = std.math.big.int.Const;
const BigIntMutable = std.math.big.int.Mutable;
const Target = std.Target;
const Allocator = std.mem.Allocator;
const Module = @import("Module.zig")... | https://raw.githubusercontent.com/collinalexbell/all-the-compilers/7f834984f71054806bfec8604e02e86b99c0f831/zig/src/value.zig |
const std = @import("std");
const os = @import("std").os;
const DnsPacket = @import("packet.zig").DnsPacket;
const Buffer = @import("buffer.zig").Buffer;
const MAX_BUFF = @import("buffer.zig").MAX_BUFF;
pub fn main() !void {
const addr = try std.net.Address.parseIp("127.0.0.1", 53);
const sock = try std.os.soc... | https://raw.githubusercontent.com/joeydewaal/DNS/62e160945d2baabfbc435d07e2a8463f910d2da6/src/main.zig |
const math = @import("std").math;
pub fn isArmstrongNumber(num: u128) bool {
var n = num;
var numDigits: u8 = 0;
while (n > 0) : (n /= 10) {
numDigits += 1;
}
n = num;
var sum: u128 = 0;
while (n > 0) : (n /= 10) {
sum += math.pow(u128, n % 10, numDigits);
}
retu... | https://raw.githubusercontent.com/ArturMroz/exercism/89c48a757e1e2e3b6973b8dd23366243337bbc30/zig/armstrong-numbers/armstrong_numbers.zig |
const std = @import("std");
pub const Transports = @import("client/Transports.zig");
pub const cbor_commands = @import("client/cbor_commands.zig");
pub const err = @import("client/error.zig");
| https://raw.githubusercontent.com/r4gus/keylib/4a9a400ab512cf6730051fca707ef8ead5c3b818/lib/client.zig |
const std = @import("std");
pub fn main() void {
var value: i32 = -1; // runtime-known
_ = &value;
const unsigned: u32 = @intCast(value);
std.debug.print("value: {}\n", .{unsigned});
}
// exe=fail
| https://raw.githubusercontent.com/ziglang/zig/d9bd34fd0533295044ffb4160da41f7873aff905/doc/langref/runtime_invalid_cast.zig |
usingnamespace @import("std").builtin;
/// Deprecated
pub const arch = Target.current.cpu.arch;
/// Deprecated
pub const endian = Target.current.cpu.arch.endian();
pub const output_mode = OutputMode.Obj;
pub const link_mode = LinkMode.Static;
pub const is_test = false;
pub const single_threaded = false;
pub const abi =... | https://raw.githubusercontent.com/creationix/zig-wasm-async/a71d0acd089942e3d9e5e95262a4f42765646d06/src/zig-cache/o/f93d1cf410b99bfb9beef8931313d820/builtin.zig |
//
// Grouping values in structs is not merely convenient. It also allows
// us to treat the values as a single item when storing them, passing
// them to functions, etc.
//
// This exercise demonstrates how we can store structs in an array and
// how doing so lets us print them using a loop.
//
const std = @import("st... | https://raw.githubusercontent.com/JanBaig/Ziglings/1a963e73e62a6cd27f2a49623c337fb615a35b3e/exercises/038_structs2.zig |
const std = @import("std");
const fs_utils = @import("../utils/fs.zig");
pub fn run(allocator: std.mem.Allocator, args: std.ArrayList([]const u8)) anyerror!fs_utils.InitializationResult {
if (args.items.len > 0) {
// this could be -h
// won't handle this case for now
}
const isInitialized ... | https://raw.githubusercontent.com/RamziA961/git_clone/f5699222792eecf48792d71f4bcee7160a58b41b/src/commands/init.zig |
///! Handles a task queue for multithreading
const std = @import("std");
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const Atomic = std.atomic.Value;
const ms = std.time.ns_per_ms;
/// The struct that handles task management.
pub const TaskManager = struct {
const Self = @This();
pub const Tas... | https://raw.githubusercontent.com/TheZipCreator/codevolution/1e96a3c88ce111a227ad587765ac8f44aafc50b5/src/task.zig |
const std = @import("../std.zig");
const builtin = @import("builtin");
const root = @import("root");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const os = std.os;
const windows = os.windows;
const maxInt = std.math.maxInt;
const Thread = std.Thread;
const is_windows = builtin.os... | https://raw.githubusercontent.com/ziglang/gotta-go-fast/c915c45c5afed9a2e2de4f4484acba2df5090c3a/src/self-hosted-parser/input_dir/event/loop.zig |
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var list = std.TailQueue(u8){};
defer while (list.pop()) |item| {
allocator.destroy(item);
};
const node1 = try allocator.... | https://raw.githubusercontent.com/zsytssk/zig-learn/e23ea099d24ada2776c7872e36e42eebc064d3c7/temp/tailQueue.zig |
const std = @import("std");
const srcRoot = struct {
fn getSrcDir() []const u8 {
return std.fs.path.dirname(@src().file).?;
}
}.getSrcDir();
pub fn addIup(b: *std.Build, target: std.zig.CrossTarget, optimize: std.builtin.Mode) *std.Build.Step.Compile {
const manifest_32 = srcRoot ++ "/iup.manifest... | https://raw.githubusercontent.com/bauripalash/cpank/ca86a38b72d0ed9e6653bd1c83291ecc207d2e4a/cpank/ext/iup/build.zig |
const micro = @import("microzig");
const mmio = micro.mmio;
pub const devices = struct {
pub const ATmega32U2 = struct {
pub const properties = struct {
pub const family = "megaAVR";
pub const arch = "AVR8";
};
pub const VectorTable = extern struct {
con... | https://raw.githubusercontent.com/burgrp/microzig-avr/f6f7a766fac9f85d2643789b46bc882ff4ade0ed/src/chips/ATmega32U2.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.