code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
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 MockFileSystem = yeti.FileSystem;
const analyzeSemantics = yeti.analyzeS... | src/tests/test_error_printer.zig |
const std = @import("std");
const print = std.debug.print;
const napi = @import("./src/napi.zig");
const allocator = std.heap.c_allocator;
comptime {
napi.register(init);
}
comptime {
const n = @import("./src/napi/c-napi/types.zig");
std.testing.refAllDecls(n);
}
fn init(env: napi.env, exports: napi.object) !... | lib.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
const target = fixedStandardTargetOptions(b);
const mode = b.standardReleaseOptions();
{
const tigerbeetle = b.addExecutable("tigerbeetle", "src/main.zig");
tigerbeetle.setTarget(target);
tigerbeetle.setBuildMod... | build.zig |
const std = @import("../std.zig");
const build = @import("../build.zig");
const Step = build.Step;
const Builder = build.Builder;
const fs = std.fs;
const warn = std.debug.warn;
const ArrayList = std.ArrayList;
pub const WriteFileStep = struct {
step: Step,
builder: *Builder,
output_dir: []const u8,
fi... | lib/std/build/write_file.zig |
const std = @import("std");
const crypto = std.crypto;
const IdentityElementError = crypto.errors.IdentityElementError;
const NonCanonicalError = crypto.errors.NonCanonicalError;
const WeakPublicKeyError = crypto.errors.WeakPublicKeyError;
/// Group operations over Curve25519.
pub const Curve25519 = struct {
/// ... | lib/std/crypto/25519/curve25519.zig |
const std = @import("std");
const lola = @import("../main.zig");
/// This map is required by the VM serialization to identify environment pointers
/// and allow serialization/deserialization of the correct references.
pub const EnvironmentMap = struct {
const Self = @This();
const Entry = struct {
env... | src/library/runtime/environmentmap.zig |
const std = @import("std");
const zang = @import("../zang.zig");
const ModuleParam = @import("parse.zig").ModuleParam;
const ParamType = @import("parse.zig").ParamType;
pub const BuiltinModule = struct {
name: []const u8,
params: []const ModuleParam,
num_temps: usize,
num_outputs: usize,
};
pub const ... | src/zangscript/builtins.zig |
const std = @import("std");
const upaya = @import("upaya");
const Color = upaya.math.Color;
usingnamespace upaya.imgui;
const ToDoState = struct {
todos: []ToDo = undefined,
pub const ToDo = struct {
label: [25]u8 = [_]u8{0} ** 25,
done: bool = false,
};
pub fn init() ToDoState {
... | examples/todo.zig |
const std = @import("std");
const geometry = @import("geometry.zig");
const Vec2 = geometry.Vec2;
const Slope = geometry.Slope;
// The algorithm works by dividing up the world around the origin into eight triangular
// regions. Each region is bounded by one orthogonal line and one diagonal line, and
// coordinates a... | src/vision.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArgIterator = std.process.ArgIterator;
const ArrayList = std.ArrayList;
const CompTimeStringMap = std.CompTimeStringMap;
const Writer = std.io.Writer;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqual... | src/arg_parser.zig |
const w4 = @import("../wasm4.zig");
const sprites = @import("../assets/sprites.zig");
const std = @import("std");
pub const Facing = enum { UP, DOWN, LEFT, RIGHT };
const SCREEN_SIZE: u8 = 160;
pub const Projectile = struct {
sprite: sprites.Image,
x: u32,
y: u32,
xOff: u32 = 0,
colors: u16 = 0x04... | src/components/projectile.zig |
const kernel = @import("root").kernel;
const Console = kernel.Console;
const HexColor = Console.HexColor;
const platform = @import("platform.zig");
const vbe = platform.vbe;
const font = vbe.font;
pub fn color_value_from_hex_color(hex_color: HexColor) u32 {
return switch (hex_color) {
HexColor.White => 0x... | kernel/platform/vbe_console.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = debug.assert;
const ArrayList = std.ArrayList;
/// A buffer that allocates memory and maintains a null byte at the end.
pub fn Buffer(comptime T: type) type {
return struct {
const Se... | src/buffer.zig |
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
a76,
aes,
aggressive_fma,
alternate_sextload_cvt_f32_pattern,
altnzcv,
am,
arith_bcc_fusion,
arith_cbz_fusion,
balance_fp_ops,
bti,
... | lib/std/target/aarch64.zig |
extern fn sceRtcGetTickResolution() u32;
extern fn sceRtcGetCurrentTick(tick: *u64) c_int;
extern fn scePowerSetClockFrequency(pllfreq: c_int, cpufreq: c_int, busfreq: c_int) c_int;
/// Required variables
var currentTime: u64 = 0; // What is the current time
var tickRate: u32 = 0; // RTC tick rate
var lastTick: u64 = ... | src/powerscale.zig |
const std = @import("../std.zig");
const CpuFeature = std.Target.Cpu.Feature;
const CpuModel = std.Target.Cpu.Model;
pub const Feature = enum {
ptx32,
ptx40,
ptx41,
ptx42,
ptx43,
ptx50,
ptx60,
ptx61,
ptx63,
ptx64,
sm_20,
sm_21,
sm_30,
sm_32,
sm_35,
sm_37,... | lib/std/target/nvptx.zig |
const std = @import("std");
const parser = @import("parser.zig");
const mem = std.mem;
const Writer = std.fs.File.Writer;
const Reader = std.fs.File.Reader;
pub const Color = struct {
r: u8,
g: u8,
b: u8,
pub fn fromSlice(slice: []const u8) Color {
return .{
.r = slice[0],
... | pal/pal/palette.zig |
const std = @import("std");
const imgui = @import("imgui");
pub const Color = extern union {
value: u32,
comps: packed struct {
r: u8,
g: u8,
b: u8,
a: u8,
},
pub fn fromBytes(r: u8, g: u8, b: u8, a: u8) Color {
return .{ .value = (r) | (@as(u32, g) << 8) | (@as... | src/math/color.zig |
const std = @import("std");
const FailOnAllocationSize = @import("fail_on_allocation_size.zig").FailingAllocator;
const FailOnStochastically = @import("fail_stochastically.zig").FailingAllocator;
const functionThatUsesAnAllocator = @import("util.zig").functionThatUsesAnAllocator;
const rand = std.rand;
test "fail aft... | src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const c = @cImport(@cInclude("lz4.h"));
const testing = @import("testing.zig");
const length_size = 4;
pub fn compress(allocator: *mem.Allocator, data: []const u8) ![]const u8 {
const max_dst_size = c.LZ4_compressBound(@intCast(c_i... | src/lz4.zig |
const std = @import("std");
const NumberKind = @import("ast.zig").NumberKind;
type: Type = .EOF,
value: union(enum) {
char: u8,
string: []const u8,
symbol: []const u8,
nil: void,
} = .nil,
number_kind: NumberKind = .I32,
line_number: i32 = 0,
column_number: i32 = 0,
filename: ?[]const u8 = null,
delimi... | token.zig |
const c = @cImport({
@cInclude("cfl_text.h");
});
const widget = @import("widget.zig");
const enums = @import("enums.zig");
pub const TextBuffer = struct {
inner: ?*c.Fl_Text_Buffer,
pub fn new() TextBuffer {
return TextBuffer{
.inner = c.Fl_Text_Buffer_new(),
};
}
pub ... | src/text.zig |
const std = @import("std");
const assert = std.debug.assert;
/// Whether development or production:
pub const deployment_environment = .development;
/// The maximum log level in increasing order of verbosity (emergency=0, debug=3):
pub const log_level = 2;
/// The maximum number of replicas allowed in a cluster.
pub... | src/config.zig |
const std = @import("std");
const api = @import("./buzz_api.zig");
const utils = @import("../src/utils.zig");
export fn mkDir(vm: *api.VM) c_int {
const filename: []const u8 = std.mem.sliceTo(api.Value.bz_valueToString(vm.bz_peek(0)) orelse {
vm.bz_throwString("Could not get filename");
return -1;... | lib/buzz_fs.zig |
const olin = @import("./olin/olin.zig");
const env = olin.env;
const log = olin.log;
const random = olin.random;
const resource = olin.resource;
const time = olin.time;
const runtime = olin.runtime;
const startup = olin.startup;
pub const os = olin;
pub const panic = os.panic;
const std = @import("std");
const assert... | zig/src/coi.zig |
const std = @import("std");
const builtin = @import("builtin");
const objc = @import("zig-objcrt");
const common = @import("common.zig");
const InitFn = common.InitFn;
const DeinitFn = common.DeinitFn;
const FrameFn = common.FrameFn;
const AudioPlaybackFn = common.AudioPlaybackFn;
const FrameInput = common.FrameInput;... | modules/platform/src/macos.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/day17.txt");
c... | src/day17.zig |
//--------------------------------------------------------------------------------
// Section: Types (20)
//--------------------------------------------------------------------------------
pub const AMSI_RESULT = enum(i32) {
CLEAN = 0,
NOT_DETECTED = 1,
BLOCKED_BY_ADMIN_START = 16384,
BLOCKED_BY_ADMIN_... | win32/system/antimalware.zig |
// todo: use package-merge algorithm to ensure length-limited codes.
const std = @import("std");
const expect = std.testing.expect;
const NodeTag = enum {
internal,
leaf
};
const Node = union(NodeTag) {
internal: struct {
left: *Node,
right: *Node,
count: u64
},
leaf: str... | src/huffman.zig |
const std = @import("std");
const fs = std.fs;
const mem = std.mem;
const print = std.debug.print;
const c = @cImport({
@cInclude("unistd.h");
@cInclude("sys/types.h");
@cInclude("sys/param.h");
});
const proce_stat_core_times = packed struct {
user: u64 = 0,
nice: u64 = 0,
system: u64 = 0,
... | src/info.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XFIXES", .global_id = 0 };
/// @brief QueryVersioncookie
pub const QueryVersioncookie = struct {
sequence: c_uint,
};
/// @brief QueryVersionRequest
pub const QueryVersionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8... | src/auto/xfixes.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day22.txt");
pub fn main() !void {
var timer = try std.time.Timer.start();
print("🎁 On Cubes: {}\n", .{part1(data)});
print("Day 22 - part 01 took {:15}ns\n", .{... | src/day22.zig |
const std = @import("std");
const interop = @import("../interop.zig");
const iup = @import("../iup.zig");
const Impl = @import("../impl.zig").Impl;
const CallbackHandler = @import("../callback_handler.zig").CallbackHandler;
const debug = std.debug;
const trait = std.meta.trait;
const Element = iup.Element;
const H... | src/elements/toggle.zig |
const macro = @import("pspmacros.zig");
comptime {
asm (macro.import_module_start("sceRtc", "0x40010000", "40"));
asm (macro.import_function("sceRtc", "0xC41C2853", "sceRtcGetTickResolution"));
asm (macro.import_function("sceRtc", "0x3F7AD767", "sceRtcGetCurrentTick"));
asm (macro.import_function("sceR... | src/psp/nids/psprtc.zig |
const std = @import("std");
const utils = @import("utils.zig");
const CountConverter = utils.Converter{
.units = &[_][]const u8{ "", "k", "M", "G" },
.dividers = &[_]usize{ 1, 1_000, 1_000_000, 1_000_000_000 },
};
const ByteConverter = utils.Converter{
.units = &[_][]const u8{ "B", "kB", "MB", "GB" },
... | src/progress.zig |
const std = @import("std");
const Span = @import("basics.zig").Span;
const PaintCurve = @import("painter.zig").PaintCurve;
const PaintState = @import("painter.zig").PaintState;
const Painter = @import("painter.zig").Painter;
pub const Envelope = struct {
pub const num_outputs = 1;
pub const num_temps = 0;
... | src/zang/mod_envelope.zig |
pub const SIZEOF_IP4_ADDRESS = @as(u32, 4);
pub const IP4_ADDRESS_STRING_LENGTH = @as(u32, 16);
pub const IP4_ADDRESS_STRING_BUFFER_LENGTH = @as(u32, 16);
pub const DNS_ADDR_MAX_SOCKADDR_LENGTH = @as(u32, 32);
pub const IP6_ADDRESS_STRING_LENGTH = @as(u32, 65);
pub const IP6_ADDRESS_STRING_BUFFER_LENGTH = @as(u32, 65);... | win32/network_management/dns.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = false;
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/day18.txt", run);
const Digit = u8;
const PAIR_MAR... | 2021/day18.zig |
const std = @import("std");
const c = @import("c.zig");
const zigimg = @import("zigimg");
const utils = @import("utils.zig");
/// read all images in the assets folder and render them
/// on a square raster. The images will be stretched/squeezed to fit the raster.
pub fn main() anyerror!void {
_= c.SDL_Init(c.SD... | src/main.zig |
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const math = std.math;
const floatXiYf = @import("floatXiYf.zig").floatXiYf;
// Conversion to f32
const __floatsisf = @import("floatXiYf.zig").__floatsisf;
const __floatunsisf = @import("floatXiYf.zig").__floatunsisf;
const __... | lib/std/special/compiler_rt/floatXiYf_test.zig |
const std = @import("std");
const process = std.process;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const Version = std.builtin.Version;
const max_line_len = 1024 * 40;
const Table = struct {
version: void,
date: void,
values: void,
};
fn getUnicodeVersions(allocator: *Allocato... | tools/generate.zig |
const std = @import("std");
const Rom = @import("rom.zig").Rom;
const Mbc = @import("mbc.zig").Mbc;
pub const Mmu = struct {
mem: []u8,
mbc: Mbc,
bank0: []u8,
bank1: []u8,
vram: []u8,
ram: []u8,
wram0: []u8,
wram1: []u8,
echo: []u8,
oam: []u8,
io: []u8,
hram: []u8,
... | src/mmu.zig |
const std = @import("std");
const mem = std.mem;
pub const NodeType = enum {
text, action, range, if_, else_, end
//, comment, template, block, with
};
pub const Node = union(NodeType) {
text: []const u8,
/// something bounded by delimiters
/// action represents simple field evaluations and parenth... | src/template.zig |
const std = @import("std");
pub const ASTInterpreterError = error{OutOfMemory};
pub const ASTInterpreter = struct {
output: std.ArrayList(u8),
globals: std.StringHashMap(NodeValue),
const Self = @This();
pub fn init(allocator: std.mem.Allocator) Self {
return ASTInterpreter{
.out... | ast_interpreter.zig |
const types = @import("types.zig");
usingnamespace @import("method.zig");
const mailbox = struct {
pub const Record = struct {
id: types.Id,
name: []const u8,
parent_id: ?types.Id,
role: ?[]const u8,
sort_order: types.UnsignedInt = 0,
total_emails: types.UnsignedInt,... | mail/mailbox.zig |
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day19_sample.txt");
pub const Scanner = struct {
pub const Self = @This();
id: u32,
beacons: []const util.Point3d(i32),
allocator: *util.Allocator,
pub fn deserialize(allocator: *util.Allocator, scanner... | src/day19.zig |
const std = @import("std");
const builtin = @import("builtin");
const Pkg = std.build.Pkg;
const string = []const u8;
pub const cache = ".zigmod/deps";
pub fn addAllTo(exe: *std.build.LibExeObjStep) void {
@setEvalBranchQuota(1_000_000);
for (packages) |pkg| {
exe.addPackage(pkg.pkg.?);
}
var ... | deps.zig |
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const Event = uefi.Event;
const Status = uefi.Status;
const Time = uefi.Time;
const SimpleNetworkMode = uefi.protocols.SimpleNetworkMode;
const MacAddress = uefi.protocols.MacAddress;
pub const ManagedNetworkProtocol = extern struct {
_get_mode_data: ext... | lib/std/os/uefi/protocols/managed_network_protocol.zig |
const std = @import("../index.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const mem = std.mem;
const AtomicRmwOp = builtin.AtomicRmwOp;
const AtomicOrder = builtin.AtomicOrder;
const Loop = std.event.Loop;
/// Thread-safe async/await lock.
/// coroutines which are waiting for the lock a... | std/event/lock.zig |
const std = @import("std");
const mem = std.mem;
const os = std.os;
const io = std.io;
const fs = std.fs;
const csv = @import("csv");
//const fmapper = @import("fmapper.zig");
const log_ctx = @import("log.zig");
const fmtDuration = std.fmt.fmtDuration;
const ansi = @import("ansi_esc.zig");
const heap = std.heap;
const... | src/csv_img_dataset.zig |
usingnamespace @cImport({
@cInclude("SDL2/SDL.h");
});
pub const firstevent = SDL_FIRSTEVENT;
pub const quit = SDL_QUIT;
pub const app_terminating = SDL_APP_TERMINATING;
pub const app_lowmemory = SDL_APP_LOWMEMORY;
pub const app_willenterbackground = SDL_APP_WILLENTERBACKGROUND;
pub const app_didenterbackground = ... | sdl/event.zig |
const std = @import("std");
const util = @import("util.zig");
fn getMatchingClosing(c: u8) u8 {
return switch (c) {
'(' => ')',
'[' => ']',
'{' => '}',
'<' => '>',
else => unreachable,
};
}
fn getErrorScore(c: u8) u64 {
return switch (c) {
')' => 3,
... | zig/src/day10.zig |
const std = @import("std");
const vk = @import("../vk.zig");
const c = struct {
usingnamespace @cImport({
@cInclude("glslang_c_interface.h");
});
};
const vkctxt = @import("../vulkan_wrapper/vulkan_context.zig");
const printError = @import("../application/print_error.zig").printError;
const printErrorN... | src/shaders/shader_util.zig |
const std = @import("std");
pub const c_flecs = @import("c_flecs.zig");
pub const Entity = c_flecs.ecs_entity_t;
pub const System = Entity;
pub const Phase = enum(@TagType(c_flecs.EcsSystemKind)) {
OnUpdate = @enumToInt(c_flecs.EcsSystemKind.EcsOnUpdate),
};
pub const Rows = struct {
type_map: std.StringHash... | zig-src/flecs.zig |
const std = @import("std");
const testing = std.testing;
const niceware = @import("niceware.zig");
test "bytes to passphrase does not allocate internally" {
const bytes = &[_]u8{ 0x00, 0x00 };
const size = niceware.passphraseSize(bytes) catch unreachable;
var buf = try testing.allocator.alloc(u8, size);
... | src/test.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Burrow = struct {
const Node = struct {
code: u128,
cost: usize,
pub fn init(code: u128, cost: usize) Node {
var self = Node{ .code = code, .cost = cost };
re... | 2021/p23/burrow.zig |
const std = @import("std");
const builtin = @import("builtin");
const Allocator = std.mem.Allocator;
const serializer = @import("serializer.zig").serializer;
const Message = @import("Message.zig");
const Connection = @This();
const system_bus_address = "unix:path=/var/run/dbus/system_bus_socket";
allocator: *Allocat... | src/Connection.zig |
pub const TASK_SUNDAY = @as(u32, 1);
pub const TASK_MONDAY = @as(u32, 2);
pub const TASK_TUESDAY = @as(u32, 4);
pub const TASK_WEDNESDAY = @as(u32, 8);
pub const TASK_THURSDAY = @as(u32, 16);
pub const TASK_FRIDAY = @as(u32, 32);
pub const TASK_SATURDAY = @as(u32, 64);
pub const TASK_FIRST_WEEK = @as(u32, 1);
pub const... | win32/system/task_scheduler.zig |
const std = @import("std");
const mem = std.mem;
const uefi = std.os.uefi;
const assert = std.debug.assert;
const Allocator = mem.Allocator;
const UefiPoolAllocator = struct {
fn getHeader(ptr: [*]u8) *[*]align(8) u8 {
return @intToPtr(*[*]align(8) u8, @ptrToInt(ptr) - @sizeOf(usize));
}
fn ali... | lib/std/os/uefi/pool_allocator.zig |
const std = @import("std");
const testing = std.testing;
const warn = std.debug.warn;
const snippet = @import("snippet.zig");
test "Builder" {
const fixture = struct {
fn case0(self: *snippet.Builder) anyerror!void {}
fn case1(self: *snippet.Builder) anyerror!void {
try self.writeText(
... | src/lsp/snippet/snippet_test.zig |
const std = @import("std");
const assert = std.debug.assert;
const event = @import("event.zig");
const GameEvent = event.GameEvent;
const GameResult = event.GameResult;
// FIXME Check https://github.com/ziglang/zig/issues/10421
pub const @"u16_2" = std.meta.Vector(2, u16);
pub const @"i16_2" = std.meta.Vector(2, i16)... | src/minesweeper/game.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
pub const ArgTypeTag = enum {
String,
None,
};
pub const ArgType = union(ArgTypeTag) {
String: ?[]u8,
None: void,
};
pub fn Flag(comptime T: ... | src/opt.zig |
const std = @import("std");
const sdk = @import("sdk");
const log = @import("log.zig");
const event = @import("event.zig");
const ifaces = @import("interface.zig").ifaces;
const orig = @import("interface.zig").orig;
var count: u8 = 0;
const Method = switch (@import("builtin").os.tag) {
.windows => std.builtin.Cal... | src/hooks.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_define.zig |
pub const LOGTOKEN_TYPE_MASK = @as(u32, 3);
pub const LOGTOKEN_UNSPECIFIED = @as(u32, 0);
pub const LOGTOKEN_NO_LOG = @as(u32, 1);
pub const LOGTOKEN_SETUPAPI_APPLOG = @as(u32, 2);
pub const LOGTOKEN_SETUPAPI_DEVLOG = @as(u32, 3);
pub const TXTLOG_SETUPAPI_DEVLOG = @as(u32, 1);
pub const TXTLOG_SETUPAPI_CMDLINE = @as(u... | deps/zigwin32/win32/system/application_installation_and_servicing.zig |
const std = @import("std");
const upaya = @import("upaya");
const editor = @import("../editor.zig");
usingnamespace @import("imgui");
var name_buf: [25]u8 = undefined;
pub fn draw(state: *editor.AppState) void {
igSetNextWindowSize(.{ .x = 500, .y = -1 }, ImGuiCond_Always);
var open: bool = true;
if (igBe... | examples/editor/windows/component_editor.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const template = @import("template.zig");
const rendering = @import("rendering/rendering.zig");
pub const ParseError = template.ParseError;
pub const ParseErrorDetail = template.ParseErrorDetail;
pub const ParseResult = template.ParseResult;
pub const ... | src/mustache.zig |
const std = @import("std");
const audio = @import("audio.zig");
const console_ = @import("console.zig");
const Config = console_.Config;
const Console = console_.Console;
const Cpu = @import("cpu.zig").Cpu;
const flags = @import("flags.zig");
const cpu_freq = 1789773;
const frame_counter_rate = 1 / 240.0;
const len... | src/apu.zig |
const c = @import("c.zig");
const std = @import("std");
const Context = @import("context.zig").Context;
const Device = @import("device.zig").Device;
const fromLibusb = @import("constructor.zig").fromLibusb;
const err = @import("error.zig");
pub const DeviceHandle = struct {
ctx: *Context,
raw: *c.libusb_devic... | src/device_handle.zig |
const std = @import("std");
const input = @embedFile("data/input09");
usingnamespace @import("util.zig");
pub fn main() !void {
var allocator_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer allocator_state.deinit();
const allocator = &allocator_state.allocator;
const values = try ... | src/day09.zig |
const std = @import("std");
const slimy = @import("slimy.zig");
export fn searchInit(
world_seed: i64,
threshold: i32,
x0: i32,
x1: i32,
z0: i32,
z1: i32,
) ?*AsyncSearcher {
return AsyncSearcher.init(std.heap.page_allocator, .{
.world_seed = world_seed,
.threshold = thresho... | src/web.zig |
const std = @import("std");
const Builder = std.build.Builder;
const Pkg = std.build.Pkg;
const FileSource = std.build.FileSource;
const examples = [3][]const u8{ "analogWrite", "rgb_led", "random" };
const uno = std.zig.CrossTarget{
.cpu_arch = .avr,
.cpu_model = .{ .explicit = &std.Target.avr.cpu.atmega328p... | build.zig |
const sf = struct {
pub usingnamespace @import("../sfml.zig");
pub usingnamespace sf.audio;
};
const Sound = @This();
// Constructor/destructor
/// Inits an empty sound
pub fn create() !Sound {
var sound = sf.c.sfSound_create();
if (sound == null)
return sf.Error.nullptrUnknownReason;
re... | src/sfml/audio/Sound.zig |
pub const preamble = @import("../preamble.zig");
usingnamespace preamble;
const log = lib.output.log.scoped(.{
.prefix = "Stivale2",
.filter = .info,
}).write;
const memory = os.memory;
const platform = os.platform;
const drivers = os.drivers;
const libalign = lib.util.libalign;
const builtin = std.builtin;
... | subprojects/flork/src/boot/stivale2.zig |
const std = @import("std");
const max = std.math.max;
const min = std.math.min;
const parseInt = std.fmt.parseInt;
const print = std.debug.print;
const testing = std.testing;
const tokenize = std.mem.tokenize;
const input = @embedFile("./input.txt");
const size = 1000;
pub fn main() anyerror!void {
print("--- Pa... | src/day05/day05.zig |
const std = @import("std");
const is64bit = @bitSizeOf(usize) == 64;
fn isStringLiteral(comptime T: type) bool {
return switch (@typeInfo(T)) {
else => false,
.Pointer => |ptr| {
return switch (@typeInfo(ptr.child)) {
else => false,
.Array => |arr| arr.c... | src/quickjs.zig |
const std = @import("std");
const data = @import("data.zig");
usingnamespace @import("wren.zig");
const HashedArrayList = @import("libs/hashed_array_list.zig").HashedArrayList;
/// Registers our Zig-backed fn so it can be called from Wren
pub fn registerMethod(
vm:?*VM,
module:[]const u8,
className:[]const... | src/foreign.zig |
pub const AUDCLNT_STREAMFLAGS_CROSSPROCESS = @as(u32, 65536);
pub const AUDCLNT_STREAMFLAGS_LOOPBACK = @as(u32, 131072);
pub const AUDCLNT_STREAMFLAGS_EVENTCALLBACK = @as(u32, 262144);
pub const AUDCLNT_STREAMFLAGS_NOPERSIST = @as(u32, 524288);
pub const AUDCLNT_STREAMFLAGS_RATEADJUST = @as(u32, 1048576);
pub const AUD... | deps/zigwin32/win32/media/audio/core_audio.zig |
const DEFAULT_MESSAGE = "200 OK";
pub fn concatCodeWithMessage(code: u10) []const u8 {
return switch (code) {
100 => "100 Continue",
101 => "101 Switching Protocols",
102 => "102 Processin",
200 => "200 OK",
201 => "201 Created",
202 => "202 Accepted",
203 =>... | util.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gui = @import("gui");
const nvg = @import("nanovg");
const Document = @import("Document.zig");
const Rect = @import("gui/geometry.zig").Rect;
const Point = @import("gui/geometry.zig").Point;
const PreviewWidget = @This();
widget: gui.Widget,
allo... | src/PreviewWidget.zig |
pub const DML_TENSOR_DIMENSION_COUNT_MAX = @as(u32, 5);
pub const DML_TEMPORARY_BUFFER_ALIGNMENT = @as(u32, 256);
pub const DML_PERSISTENT_BUFFER_ALIGNMENT = @as(u32, 256);
pub const DML_MINIMUM_BUFFER_TENSOR_ALIGNMENT = @as(u32, 16);
//--------------------------------------------------------------------------------
/... | deps/zigwin32/win32/ai/machine_learning/direct_ml.zig |
const std = @import("std");
pub fn Channel(comptime T: type) type {
return struct {
lock: std.Thread.Mutex = .{},
buffer: []T,
head: usize = 0,
tail: usize = 0,
getters: ?*Waiter = null,
putters: ?*Waiter = null,
const Task = std.event.Loop.NextTickNode;
... | src/utils/channel.zig |
const std = @import("std");
const cli = @import("cli.zig");
const utils = @import("utils.zig");
const max_template_len = 12000;
pub const Theme = struct {
theme_name_full: []u8,
theme_name_safe: []u8,
color_bg_main: []u8,
color_bg_alt1: []u8,
color_bg_alt2: []u8,
color_fg: []u8,
color_linenr... | src/templator.zig |
const builtin = @import("builtin");
const std = @import("std");
const expect = std.testing.expect;
const mem = std.mem;
const Tag = std.meta.Tag;
const Number = enum { Zero, One, Two, Three, Four };
fn shouldEqual(n: Number, expected: u3) !void {
try expect(@enumToInt(n) == expected);
}
test "enum to int" {
... | test/behavior/enum.zig |
const std = @import("../std.zig");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const ast = std.zig.ast;
const Node = ast.Node;
const Tree = ast.Tree;
const AstError = ast.Error;
const TokenIndex = ast.TokenIndex;
const Token = std.zig.Token;
const TokenIterator = Tree.TokenList.Iterator;
pub ... | lib/std/zig/parse.zig |
const builtin = @import("builtin");
const expect = std.testing.expect;
const std = @import("../std.zig");
const math = std.math;
/// Returns the greatest integer value less than or equal to x.
///
/// Special Cases:
/// - floor(+-0) = +-0
/// - floor(+-inf) = +-inf
/// - floor(nan) = nan
pub fn floor(x: var) @... | lib/std/math/floor.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;
}
pub const stbPkg = std.build.Pkg{
.name = "stb_image",
.path = std.build.FileSource{ .path = getRelativePath() ++ "src/p... | build.zig |
const std = @import("std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
pub const standard_alphabet_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
pub const standard_pad_char = '=';
pub const standard_encoder = Base64Encoder.init(standard_alphabet... | lib/std/base64.zig |
const std = @import("std");
const crypto = std.crypto;
const fmt = std.fmt;
const io = std.io;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const pwhash = crypto.pwhash;
const phc_format = @import("phc_encoding.zig");
const HmacSha256 = crypto.auth.hmac.sha2.HmacSha256;
const KdfError = pwhash.... | lib/std/crypto/scrypt.zig |
const std = @import("std");
const console = @import("utils/console.zig");
const string = @import("utils/string.zig");
const attacks = @import("bitboards/attacks.zig");
const masks = @import("bitboards/masks.zig");
const MoveList = @import("types/MoveList.zig");
const Square = @import("types/enums.zig").Square;
const... | src/uci.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const Row = []bool;
const open = '.';
const tree = '#';
const Slope = struct { right: u16, down: u16 = 1 };
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
... | src/day03.zig |
const std = @import("std");
const fs = std.fs;
const Image = @import("../image.zig").Image;
const upaya = @import("../upaya_cli.zig");
const math = upaya.math;
const stb = @import("stb");
pub const TexturePacker = struct {
pub const Atlas = struct {
names: [][]const u8,
rects: []math.RectI,
... | src/utils/texture_packer.zig |
const std = @import("std");
const input = @embedFile("data/input07");
usingnamespace @import("util.zig");
pub fn main() !void {
var allocator_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer allocator_state.deinit();
const allocator = &allocator_state.allocator;
const entries = try... | src/day07.zig |
const base = @import("../../base.zig");
//Recorded in Clavis Calendaria: Or, A Compendious Analysis of the Calendar
//by <NAME>
//https://books.google.ca/books?id=pKjhAAAAMAAJ&pg=PA38&redir_esc=y#v=onepage&q&f=false
var french_revolutionary_month_list_en_GB_joke = [_:null]?[*:0]u8{
"Wheezy",
"Sneezy",
"Fre... | src/names/en_GB/french_revolutionary.zig |
const std = @import("std");
const c = @cImport({
@cInclude("nanovg.h");
@cInclude("glad/glad.h");
@cDefine("NANOVG_GL2", "1");
@cInclude("nanovg_gl.h");
});
pub const Pi: f32 = 3.14159265358979323846264338327;
// pub const Color = struct { // ABI incompatible :(
// r: f32,
// g: f32,
// b:... | deps/nanovg/src/nanovg.zig |
const std = @import("std");
const c = @import("internal/c.zig");
const internal = @import("internal/internal.zig");
const log = std.log.scoped(.git);
const git = @import("git.zig");
pub const Config = opaque {
pub fn deinit(self: *Config) void {
log.debug("Config.deinit called", .{});
c.git_confi... | src/config.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Vec2 = tools.Vec2;
pub fn run(input_text: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const Range = struct { min: u3... | 2020/day16.zig |
const c = @import("../c_global.zig").c_imp;
const std = @import("std");
// dross-zig
const TextureGl = @import("backend/texture_opengl.zig").TextureGl;
const Color = @import("../core/color.zig").Color;
const renderer = @import("renderer.zig");
const selected_api = @import("renderer.zig").api;
const Vector2 = @import(".... | src/renderer/texture.zig |
const std = @import("std");
const builtin = @import("builtin");
const log = std.log;
const mem = std.mem;
pub usingnamespace std.c;
pub usingnamespace mach_task;
const mach_task = if (builtin.target.isDarwin()) struct {
pub const MachError = error{
/// Not enough permissions held to perform the requested ... | lib/std/os/darwin.zig |
const std = @import("std");
const immu = @import("mmu.zig");
const Mmu = immu.Mmu;
const A = immu.addresses;
const c = @cImport({
@cInclude("SDL2/SDL.h");
});
pub const Window = struct {
renderer: ?*c.SDL_Renderer,
window: ?*c.SDL_Window,
pixels: [144][160]u32,
mmu: *Mmu,
pub fn init(mmu: *M... | src/window_sdl.zig |