code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const Cpu = @import("../Cpu.zig");
const util = @import("../util.zig");
pub const impl = @import("impl.zig");
const Reg8 = Cpu.Reg8;
const Reg16 = Cpu.Reg16;
const Flags = Cpu.Flags;
const Op = @This();
id: Id,
length: u8,
arg0: Arg,
arg1: Arg,
durations: [2]u8,
/// Positional argumen... | src/Cpu/Op.zig |
const c = @cImport({
@cInclude("cfl_draw.h");
});
const Font = @import("enums.zig").Font;
const FrameType = @import("enums.zig").FrameType;
const Cursor = @import("enums.zig").Cursor;
pub const LineStyle = enum(i32) {
/// Solid line
Solid = 0,
/// Dash
Dash,
/// Dot
Dot,
/// Dash dot
... | src/draw.zig |
const std = @import("std");
usingnamespace @import("raylib");
const max_lights = 4;
pub const Light = struct {
type: LightType,
position: Vector3,
target: Vector3,
color: Color,
enabled: bool,
// Shader locations
enabledLoc: i32,
typeLoc: i32,
posLoc: i32,
targetLoc: i32,
... | examples/shaders/rlights.zig |
const std = @import("std");
const stdx = @import("../stdx/lib.zig");
const graphics = @import("../graphics/lib.zig");
const platform = @import("../platform/lib.zig");
const GraphicsBackend = @import("../platform/backend.zig").GraphicsBackend;
const zig_v8_pkg = @import("../build.zig").zig_v8_pkg;
const uv = @import("... | runtime/lib.zig |
const std = @import("std");
const string = []const u8;
const range = @import("range").range;
const input = @embedFile("../input/day05.txt");
pub fn main() !void {
// part 1
{
var iter = std.mem.split(u8, input, "\n");
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
... | src/day05.zig |
const std = @import("std");
const mem = std.mem;
const OtherAlphabetic = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 837,
hi: u21 = 127369,
pub fn init(allocator: *mem.Allocator) !OtherAlphabetic {
var instance = OtherAlphabetic{
.allocator = allocator,
.array = try allocator.al... | src/components/autogen/PropList/OtherAlphabetic.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Capped Cone",
.data_size = @sizeOf(Data),
.function_definition = function_definition,
.enter_command_fn = util.surfaceEnterCommand(Data),
.exit_command_fn = util.surfaceExitCommand(Data, exitCommand),
.append_m... | src/sdf/surfaces/capped_cone.zig |
const builtin = @import("builtin");
const utils = @import("utils");
const kernel = @import("root").kernel;
const print = kernel.print;
const platform = @import("platform.zig");
const kernel_to_virtual = platform.kernel_to_virtual;
const TaskStateSegment = packed struct {
link: u16 = 0,
zero1: u16 = 0,
... | kernel/platform/segments.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XINERAMA", .global_id = 0 };
/// @brief ScreenInfo
pub const ScreenInfo = struct {
@"x_org": i16,
@"y_org": i16,
@"width": u16,
@"height": u16,
};
/// @brief QueryVersioncookie
pub const QueryVersioncookie = struct {
seque... | src/auto/xinerama.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "DRI3", .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/dri3.zig |
const std = @import("std");
const Queue = std.atomic.Queue;
const warn = std.debug.warn;
test "print_data" {
const S = struct.{
const Self = @This();
b1: u1,
i: u8,
ai: []u8,
/// Custom format routine for S
pub fn format(self: *const Self,
comptime fmt:... | print-data/print_data.zig |
const std = @import("std");
const iup = @import("iup.zig");
const fmt = std.fmt;
const MainLoop = iup.MainLoop;
const Dialog = iup.Dialog;
const Button = iup.Button;
const MessageDlg = iup.MessageDlg;
const Multiline = iup.Multiline;
const Label = iup.Label;
const Text = iup.Text;
const VBox = iup.VBox;
const HBox = ... | src/image_example.zig |
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const log = std.log.scoped(.packet_simulator);
pub const PacketSimulatorOptions = struct {
/// Mean for the exponential distribution used to calculate forward delay.
one_way_delay_mean: u64,
one_way_delay_min: u64,
pa... | src/test/packet_simulator.zig |
const std = @import("std");
const epoll = @import("epoll.zig");
const WlContext = @import("wl/context.zig").Context;
const prot = @import("protocols.zig");
const shm_pool = @import("shm_pool.zig");
const shm_buffer = @import("shm_buffer.zig");
const window = @import("window.zig");
const region = @import("region.zig");
... | src/client.zig |
const std = @import("std");
const log = std.log.scoped(.@"brucelib.platform.linux");
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;
const AudioPl... | modules/platform/src/linux.zig |
const std = @import("std");
const builtin = @import("builtin");
const LE = extern enum(i32) {
Less = -1,
Equal = 0,
Greater = 1,
Unordered = 1,
};
const GE = extern enum(i32) {
Less = -1,
Equal = 0,
Greater = 1,
Unordered = -1,
};
pub fn cmp(comptime T: type, comptime RT: type, a: T,... | lib/std/special/compiler_rt/compareXf2.zig |
//! Thread-local cryptographically secure pseudo-random number generator.
//! This file has public declarations that are intended to be used internally
//! by the standard library; this namespace is not intended to be exposed
//! directly to standard library users.
const std = @import("std");
const root = @import("ro... | lib/std/crypto/tlcsprng.zig |
const std = @import("std");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const mem = std.mem;
const maxInt = std.math.maxInt;
const StringEscapes = union(enum) {
None,
Some: struct {
size_diff: isize,
},
};
/// A single token slice into the parent string.
//... | src/json/std.zig |
const std = @import("std");
pub fn __truncsfhf2(a: f32) callconv(.C) u16 {
return @bitCast(u16, @call(.{ .modifier = .always_inline }, truncXfYf2, .{ f16, f32, a }));
}
pub fn __truncdfhf2(a: f64) callconv(.C) u16 {
return @bitCast(u16, @call(.{ .modifier = .always_inline }, truncXfYf2, .{ f16, f64, a }));
}
... | lib/std/special/compiler_rt/truncXfYf2.zig |
const std = @import("std");
pub const pkg = std.build.Pkg{
.name = "zmesh",
.path = .{ .path = thisDir() ++ "/src/main.zig" },
};
pub fn build(b: *std.build.Builder) void {
const build_mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const tests = buildTests(b, build... | modules/graphics/vendored/zmesh/build.zig |
pub const DIRECTINPUT_VERSION = @as(u32, 2048);
pub const JOY_HW_NONE = @as(u32, 0);
pub const JOY_HW_CUSTOM = @as(u32, 1);
pub const JOY_HW_2A_2B_GENERIC = @as(u32, 2);
pub const JOY_HW_2A_4B_GENERIC = @as(u32, 3);
pub const JOY_HW_2B_GAMEPAD = @as(u32, 4);
pub const JOY_HW_2B_FLIGHTYOKE = @as(u32, 5);
pub const JOY_H... | win32/devices/human_interface_device.zig |
const common = @import("common.zig");
pub const Object = common.Object;
pub const Message = common.Message;
pub const Interface = common.Interface;
pub const Array = common.Array;
pub const Fixed = common.Fixed;
pub const Argument = common.Argument;
pub const Proxy = opaque {
extern fn wl_proxy_create(factory: *Pr... | wayland_client_core.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/puzzle/day17.tx... | src/day17.zig |
pub const cNodetypeSceTemplateServices = Guid.initString("24a7f717-1f0c-11d1-affb-00c04fb984f9");
pub const cNodetypeSceAnalysisServices = Guid.initString("678050c7-1ff8-11d1-affb-00c04fb984f9");
pub const cNodetypeSceEventLog = Guid.initString("2ce06698-4bf3-11d1-8c30-00c04fb984f9");
pub const SCESTATUS_SUCCESS = @as(... | win32/security/configuration_snapin.zig |
const std = @import("std");
const mem = std.mem;
pub const Token = struct {
id: Id,
start: usize,
end: usize,
pub const Id = union(enum) {
Invalid,
Eof,
Nl,
Identifier,
/// special case for #include <...>
MacroString,
StringLiteral: StrKind,
... | lib/std/c/tokenizer.zig |
const fun = @import("fun");
const ascii = fun.ascii;
const generic = fun.generic;
const slice = generic.slice;
const lu16 = fun.platform.lu16;
pub const Banner = extern struct {
version: u8,
has_animated_dsi_icon: u8,
crc16_across_0020h_083Fh: lu16,
crc16_across_0020h_093Fh: lu16,
crc16_across_0... | src/banner.zig |
const std = @import("std");
const server = @import("server.zig");
const comms = @import("comms.zig");
const fuse_client = @import("fuse_client.zig");
const service_name = "n00byedge.qubes-inter-vm-fs";
const config_dir_path = "/rw/config/inter-vm-fs/";
const fake_remote_connection = false;
fn spawnProc(proc_cmdline... | src/main.zig |
const builtin = @import("builtin");
const __divmodsi4 = @import("int.zig").__divmodsi4;
const __udivmodsi4 = @import("int.zig").__udivmodsi4;
const __divmoddi4 = @import("int.zig").__divmoddi4;
const __udivmoddi4 = @import("int.zig").__udivmoddi4;
extern fn memset(dest: ?[*]u8, c: u8, n: usize) ?[*]u8;
extern fn memc... | lib/std/special/compiler_rt/arm.zig |
const Self = @This();
const std = @import("std");
const os = std.os;
const wayland = @import("wayland");
const wl = wayland.client.wl;
const wlr = wayland.client.zwlr;
const c = @cImport({
@cInclude("cairo/cairo.h");
});
const Context = @import("main.zig").Context;
const Buffer = @import("Buffer.zig");
const i... | src/Surface.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const builtin = @import("builtin");
const testing = std.testing;
/// Errors that can occur when parsing an IP Address.
pub const ParseError = error{
InvalidCharacter,
TooManyOctets,
Overflow,
Incomplete,
UnknownAddressType,
}... | src/main.zig |
const std = @import("std");
const testing = std.testing;
fn getFields(comptime args: anytype) []const std.builtin.TypeInfo.StructField {
return @typeInfo(@TypeOf(args)).Struct.fields;
}
fn InputType(comptime fields: []const std.builtin.TypeInfo.StructField) type {
return @typeInfo(fields[0].field_type).Fn.arg... | src/pipe.zig |
const std = @import("std");
const Builder = std.build.Builder;
const zf = @import("pkg.zig").Pkg(".");
const vkgen = @import("render/lib/vulkan-zig/generator/index.zig");
const Example = struct { name: []const u8, path: []const u8, libs: u3 };
pub fn build(b: *Builder) void {
const target = b.standardTargetOptio... | build.zig |
const std = @import("std");
const builtin = std.builtin;
const meta = std.meta;
const testing = std.testing;
const assert = std.debug.assert;
const gzip = std.compress.gzip;
const Allocator = std.mem.Allocator;
const serde = @import("serde.zig");
pub const Tag = enum(u8) {
End = 0,
Byte = 1,
Short = 2,
... | src/nbt.zig |
usingnamespace @import("std").c.builtins;
pub const M3Result = [*c]const u8;
pub const IM3Environment = ?*opaque {};
pub const IM3Runtime = ?*opaque {};
pub const IM3Module = ?*opaque {};
pub const IM3Function = ?*opaque {};
pub const IM3Global = ?*opaque {};
pub const M3ErrorInfo = extern struct {
result: M3Resu... | src/c.zig |
pub const DPI_AWARENESS_CONTEXT_UNAWARE = @import("../zig.zig").typedConst(DPI_AWARENESS_CONTEXT, @as(i32, -1));
pub const DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = @import("../zig.zig").typedConst(DPI_AWARENESS_CONTEXT, @as(i32, -2));
pub const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = @import("../zig.zig").typedConst(DPI_... | deps/zigwin32/win32/ui/hi_dpi.zig |
const std = @import("std");
const c = @import("../c.zig");
const vec3 = @import("vec3.zig");
const util = @import("../util.zig");
const Scene = @import("../scene.zig").Scene;
const Shape = @import("shape.zig").Shape;
const Material = @import("material.zig").Material;
pub fn from_mol_file(alloc: *std.mem.Allocator, c... | src/scene/mol.zig |
const std = @import("std");
const learn = @import("learnBPE.zig");
const apply = @import("applyBPE.zig");
const warn = std.debug.warn;
const resolve = learn.resolve;
fn get_args(args: [][]const u8, n: usize) []const u8 {
if (n >= args.len) return "";
return args[n];
}
pub fn main() anyerror!void {
// var... | fastBPE/main.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Map = struct {
const MATCHES_NEEDED = 12;
pub const Rotations = [24][3][3]isize{
[3][3]isize{
[3]isize{ 1, 0, 0 },
[3]isize{ 0, 1, 0 },
[3]isize{ 0, 0, 1 },
... | 2021/p19/map.zig |
const ActorInterface = @import("actor.zig").ActorInterface;
const MessageAllocator = @import("message_allocator.zig").MessageAllocator;
const messageQueueNs = @import("message_queue.zig");
const MessageQueue = messageQueueNs.MessageQueue;
const SignalContext = messageQueueNs.SignalContext;
const std = @import("std")... | message.zig |
const std = @import("std");
const microzig = @import("microzig");
const regs = microzig.chip.registers;
// this will instantiate microzig and pull in all dependencies
pub const panic = microzig.panic;
const abs = std.math.absCast;
pub const TIM6Timer = struct {
pub fn init() @This() {
// Enable TIM6.
... | src/main.zig |
const sg = @import("gfx.zig");
pub const Pipeline = extern struct {
id: u32 = 0,
};
pub const Error = extern enum(i32) {
ERROR = 0,
VERTICES_FULL,
UNIFORMS_FULL,
COMMANDS_FULL,
STACK_OVERFLOW,
STACK_UNDERFLOW,
};
pub const Desc = extern struct {
max_vertices: i32 = 0,
max_commands:... | src/sokol/gl.zig |
const std = @import("std");
const assert = std.debug.assert;
const tigerbeetle_io_log = std.log.scoped(.@"tigerbeetle-io");
/// An intrusive first in/first out linked list.
/// The element type T must have a field called "next" of type ?*T
pub fn FIFO(comptime T: type) type {
return struct {
const Self = @... | src/fifo.zig |
const std = @import("std");
const ig = @import("imgui");
const zt = @import("zt");
const sling = @import("sling.zig");
pub const ObjectType = enum {
Collection,
Singleton,
};
pub const Clearance = enum {
editorOnly,
gameOnly,
both,
};
pub const Information = struct {
var pointerToId = std.St... | src/object.zig |
const std = @import("std");
const ops = @import("ops.zig");
pub const BytecodePrimitive = enum {
byte,
char,
short,
int,
long,
float,
double,
reference,
pub fn fromShorthand(shorthand: u8) BytecodePrimitive {
return switch (shorthand) {
'a' => .reference,
... | src/bytecode/wrapped.zig |
const builtin = @import("builtin");
const std = @import("std");
const ascii = std.ascii;
const fs = std.fs;
const log = std.log;
const mem = std.mem;
const os = std.os;
const process = std.process;
const unicode = std.unicode;
const testing = std.testing;
const stdout = std.io.getStdOut();
const stderr = std.io.getStd... | src/main.zig |
const std = @import("std");
const net = std.net;
const meta = std.meta;
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const log = std.log;
const time = std.time;
const atomic = std.atomic;
const math = std.math;
const Uuid = @import("uuid6");
const mcp = @import("mcproto.zig");
const mcn = @import("... | src/game.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const EditorWidget = @import("EditorWidget.zig");
const Document = @import("Document.zig");
const Snapshot = []u8;
pub const Buffer = struct {
allocator: Allocator,
stack: ArrayList(Snapshot),
index: usize =... | src/history.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const c_allocator = std.heap.c_allocator;
const lib = @import("main.zig");
const Error = lib.Error;
const FlightPlan = lib.FlightPlan;
const Waypoint = lib.Waypoint;
const Route = lib.Route;
const testutil = @import("test.zig");
const c = @cImport({
... | src/binding.zig |
const ctz = @import("count0bits.zig");
const testing = @import("std").testing;
fn test__ctzsi2(a: u32, expected: i32) !void {
var x = @bitCast(i32, a);
var result = ctz.__ctzsi2(x);
try testing.expectEqual(expected, result);
}
test "ctzsi2" {
try test__ctzsi2(0x00000001, 0);
try test__ctzsi2(0x000... | lib/std/special/compiler_rt/ctzsi2_test.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const nvg = @import("nanovg");
const gui = @import("../gui.zig");
const Rect = @import("../geometry.zig").Rect;
const Self = @This();
widget: gui.Widget,
allocator: *Allocator,
has_grip: bool = false,
separators: Arra... | src/gui/widgets/Toolbar.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const vr = @import("vr.zig");
const Header = vr.Header;
const MessageBus = @import("message_bus.zig").MessageBusClient;
const Message = @import("message_bus.zig").Message;
const Operation = @import(... | src/client.zig |
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const io = std.io;
const mem = std.mem;
const os = std.os;
const test_nums = []u32 { 2, 3, 0, 3, 10, 11, 12, 1, 1, 0, 1, 99, 2, 1, 1, 2, };
const debug_logging: bool = false;
pub fn main() !void {
var allocator = &std.heap.DirectAllocator.i... | 2018/day_08.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const Entry = @import("entry.zig").Entry;
const Options = @import("Options.zig");
const PathDirTuple = struct {
iter: std.fs.Dir.Iterator,
path: []const u8,
};
pub const DepthFirstWalker = struct {
start_pat... | src/depth_first.zig |
const std = @import("std");
pub fn Scanner(comptime InputType: type, max_buffer_size_: anytype) type {
return struct {
const Self = @This();
const TestData = struct {
read_count: usize = 0,
};
/// The input to read for scanning -- we own this for the following reasons:... | src/scan.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const data = @embedFile("../inputs/day18.txt");
pub fn main() anyerror!void {
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_impl.deinit();
const gpa = gpa_impl.allocator();
return m... | src/day18.zig |
const x86_64 = @import("index.zig");
const bitjuggle = @import("bitjuggle");
const std = @import("std");
const PageTableIndex = x86_64.structures.paging.PageTableIndex;
const PageOffset = x86_64.structures.paging.PageOffset;
/// A canonical 64-bit virtual memory address.
///
/// On `x86_64`, only the 48 lower bits of... | src/addr.zig |
const std = @import("std");
const platform = @import("platform.zig");
const util = @import("util.zig");
const Cookie = util.Cookie;
const RefCount = util.RefCount;
pub const max_name_len = 256;
pub const max_path_len = 4096;
pub const Error = error{ NotImplemented, NotDirectory, NotFile, NoSuchFile, FileExists, NotE... | kernel/vfs.zig |
const std = @import("std");
const zt = @import("zt");
const sling = @import("../sling.zig");
const ig = @import("imgui");
var pathCallback: ?fn ([]const u8) void = null;
var folders: std.BoundedArray([128:0]u8, 64) = std.BoundedArray([128:0]u8, 64).init(0) catch unreachable;
var files: std.BoundedArray([128:0]u8, 256... | src/editor/fileSelector.zig |
const std = @import("std");
const allocator = std.testing.allocator;
const builtin = @import("builtin");
const debug = std.debug;
const expect = std.testing.expect;
const fs = std.fs;
const mem = std.mem;
const os = std.os;
const tmpDir = std.testing.tmpDir;
const warn = std.debug.print;
const ArrayList = std.ArrayLis... | src/hwzip_test.zig |
const std = @import("std");
fn tagKind(tree: *std.zig.ast.Tree, node: *std.zig.ast.Node) u8 {
return switch (node.id) {
std.zig.ast.Node.Id.FnProto => 'f',
std.zig.ast.Node.Id.VarDecl => blk: {
const var_decl_node = node.cast(std.zig.ast.Node.VarDecl).?;
if (var_decl_node.in... | src/main.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const TypedValue = @import("TypedValue.zig");
const assert = std.debug.assert;
const zir = @import("zir.zig");
const Module = @import("Module.zig");
cons... | src/astgen.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const mem = std.mem;
const path = std.fs.path;
const assert = std.debug.assert;
const target_util = @import("target.zig");
const Compilation = @import("Compilation.zig");
const build_options = @import("build_options");
const trace = @import("tracy.zig").... | src/glibc.zig |
const Plan9 = @This();
const link = @import("../link.zig");
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const aout = @import("Plan9/aout.zig");
const codegen = @import("../codegen.zig");
const trace = @import("../tracy.zig").trace;
const File = link.File;
const build_opt... | src/link/Plan9.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
// normal comment
/// this is a documentation comment
/// doc comment line 2
fn emptyFunctionWithComments() void {}
test "empty function w... | test/behavior/basic.zig |
const std = @import("std");
const TestContext = @import("../../src/test.zig").TestContext;
const archs = [2]std.Target.Cpu.Arch{
.aarch64, .x86_64,
};
pub fn addCases(ctx: *TestContext) !void {
for (archs) |arch| {
const target: std.zig.CrossTarget = .{
.cpu_arch = arch,
.os_ta... | test/stage2/darwin.zig |
const std = @import("std");
const assertOrPanic = std.debug.assertOrPanic;
fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {
assertOrPanic(Key == @IntType(false, Key.bit_count));
assertOrPanic(Key.bit_count >= mask_bit_count);
const ShardKey = @IntType(fals... | test/stage1/behavior/bit_shifting.zig |
const std = @import("std");
pub fn mmio(addr: usize, comptime size: u8, comptime PackedT: type) *volatile Mmio(size, PackedT) {
return @intToPtr(*volatile Mmio(size, PackedT), addr);
}
pub fn Mmio(comptime size: u8, comptime PackedT: type) type {
if ((size % 8) != 0)
@compileError("size must be divisi... | src/mmio.zig |
const std = @import("std");
const Context = @import("context.zig").Context;
const Source = @import("context.zig").Source;
const BuiltinPackage = @import("builtins.zig").BuiltinPackage;
const Curve = @import("parse.zig").Curve;
const Track = @import("parse.zig").Track;
const Module = @import("parse.zig").Module;
const p... | src/zangscript/compile.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(stdout: anytype) anyerror!void {
{
var input_ = try input.readFile("inputs/day14");
defer input_.deinit();
const result = try part1(&input_);
try stdout.print("14a: {}\n", .{ result });
std.debug.as... | src/day14.zig |
const Tokenizer = @This();
index: usize = 0,
bytes: []const u8,
state: State = .lhs,
const std = @import("std");
const testing = std.testing;
const assert = std.debug.assert;
pub fn next(self: *Tokenizer) ?Token {
var start = self.index;
var must_resolve = false;
while (self.index < self.bytes.len) {
... | src/DepTokenizer.zig |
const std = @import("std");
const parser = @import("parser.zig");
const compiler = @import("main.zig");
const AstNode = parser.AstTree.AstNode;
const Function = parser.Function;
const ExprList = parser.ExprList;
const CodeGenerator = @This();
const Asm = @import("asm.zig");
const Error = error{
InvalidExpression... | src/code_generator.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
pub fn isZigPrimitiveType(name: []const u8) bool {
if (name.len > 1 and (name[0] == 'u' or name[0] == 'i')) {
for (name[1..]) |c| {
switch (c) {
'0'...'9' => {},
else => break,
... | generator/id_render.zig |
const std = @import("std");
const zzz = @import("zzz");
pub const default_root = "src/main.zig";
pub const ZChildIterator = struct {
val: ?*zzz.ZNode,
pub fn next(self: *ZChildIterator) ?*zzz.ZNode {
return if (self.val) |node| blk: {
self.val = node.sibling;
break :blk node;
... | src/common.zig |
const std = @import("std");
const reg = @import("registry.zig");
const xml = @import("../xml.zig");
const renderRegistry = @import("render.zig").render;
const parseXml = @import("parse.zig").parseXml;
const IdRenderer = @import("../id_render.zig").IdRenderer;
const mem = std.mem;
const Allocator = mem.Allocator;
const ... | generator/vulkan/generator.zig |
const wlr = @import("../wlroots.zig");
const wl = @import("wayland").server.wl;
pub const OutputManagerV1 = extern struct {
server: *wl.Server,
global: *wl.Global,
resources: wl.list.Head(wl.Resource, null),
heads: wl.list.Head(OutputHeadV1, "link"),
serial: u32,
current_configuration_dirty: b... | src/types/output_management_v1.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const mem = std.mem;
pub const ModelData = struct {
pub const VertexAttributeType = enum(u8) {
Position = 0,
Colour = 1,
TextureCoordinates = 2,
Normal = 3,
BoneIndices = 4,
Bon... | src/ModelFiles/ModelFiles.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const ArrayMap = std.AutoArrayHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
va... | 2021/src/util.zig |
const std = @import("std");
const bottom = @import("encoder.zig").BottomEncoder;
const ByteEnum = @import("encoder.zig").ByteEnum;
const mem = @import("zig-native-vector");
const help_text = @embedFile("help.txt");
pub const DecoderError = error{
invalid_input,
} || std.mem.Allocator.Error;
/// This struct is jus... | src/decoder.zig |
const builtin = @import("builtin");
const std = @import("std");
const expect = std.testing.expect;
const expectEqualSlices = std.testing.expectEqualSlices;
const expectEqual = std.testing.expectEqual;
const mem = std.mem;
// comptime array passed as slice argument
comptime {
const S = struct {
fn indexOfSc... | test/behavior/slice.zig |
const MMIO = @import("mmio.zig").MMIO;
const PINB = MMIO(0x23, u8, packed struct {
PINB0: u1 = 0,
PINB1: u1 = 0,
PINB2: u1 = 0,
PINB3: u1 = 0,
PINB4: u1 = 0,
PINB5: u1 = 0,
PINB6: u1 = 0,
PINB7: u1 = 0,
});
const DDRB = MMIO(0x24, u8, packed struct {
DDB0: u1 = 0,
DDB1: u1 = 0,... | src/gpio.zig |
const std = @import("std");
const builtin = std.builtin;
const Builder = std.build.Builder;
pub fn makeLib(b: *Builder, mode: builtin.Mode, target: std.zig.CrossTarget, comptime prefix: []const u8) !*std.build.LibExeObjStep {
const lib = b.addStaticLibrary("nfd", prefix ++ "src/lib.zig");
lib.setBuildMode(mode... | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gui = @import("gui");
const nvg = @import("nanovg");
const Rect = @import("gui/geometry.zig").Rect;
const Point = @import("gui/geometry.zig").Point;
const ColorLayer = @import("color.zig").ColorLayer;
pub const ChangeType = enum {
color,
a... | src/ColorForegroundBackgroundWidget.zig |
const combn = @import("../combn/combn.zig");
const Parser = combn.gllparser.Parser;
const String = @import("String.zig");
const Node = @import("Node.zig");
const CompilerContext = @import("CompilerContext.zig");
const std = @import("std");
const mem = std.mem;
const Compilation = @This();
value: union(ValueTag) {
... | src/dsl/Compilation.zig |
const std = @import("std");
const assert = std.debug.assert;
/// Marzullo's algorithm, invented by <NAME> for his Ph.D. dissertation in 1984, is an
/// agreement algorithm used to select sources for estimating accurate time from a number of noisy
/// time sources. NTP uses a modified form of this called the Intersecti... | src/vsr/marzullo.zig |
const vk = @import("../../../vk.zig");
const std = @import("std");
const rg = @import("../render_graph.zig");
const vkctxt = @import("../../../vulkan_wrapper/vulkan_context.zig");
const printError = @import("../../../application/print_error.zig").printError;
const RGResource = @import("../render_graph_resource.zig").... | src/renderer/render_graph/resources/texture.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gui = @import("gui");
const nvg = @import("nanovg");
const Rect = @import("gui/geometry.zig").Rect;
const ColorPickerWidget = @This();
widget: gui.Widget,
allocator: *Allocator,
spinners: [4]*gui.Spinner(i32) = undefined,
sliders: [5]*gui.Slider(... | src/ColorPickerWidget.zig |
pub const SYS = enum(usize) {
restart_syscall = 0x00,
exit = 0x01,
fork = 0x02,
read = 0x03,
write = 0x04,
open = 0x05,
close = 0x06,
creat = 0x08,
link = 0x09,
unlink = 0x0a,
execve = 0x0b,
chdir = 0x0c,
mknod = 0x0e,
chmod = 0x0f,
lchown = 0x10,
lseek = ... | src/linux/arm/consts.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = true;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
pub fn main() anyerror!void {
const stdout = std.io.getStdOut().writer();
var arena... | 2017/day25.zig |
const std = @import("std");
const za = @import("zalgebra");
const Vec4 = za.vec4;
const Mat4 = za.mat4;
// dross-zig
const Vector3 = @import("vector3.zig").Vector3;
const Vector4 = @import("vector4.zig").Vector4;
// -----------------------------------------
// - Matrix4 -
// --------------------------------------... | src/core/matrix4.zig |
const __floatdidf = @import("floatdidf.zig").__floatdidf;
const testing = @import("std").testing;
fn test__floatdidf(a: i64, expected: f64) void {
const r = __floatdidf(a);
testing.expect(r == expected);
}
test "floatdidf" {
test__floatdidf(0, 0.0);
test__floatdidf(1, 1.0);
test__floatdidf(2, 2.0)... | lib/std/special/compiler_rt/floatdidf_test.zig |
const std = @import("std");
// TODO make this receive a stream and write into it directly instead of
// dealing with memory.
pub fn prettyMemoryUsage(buffer: []u8, kilobytes: u64) ![]const u8 {
const megabytes = kilobytes / 1024;
const gigabytes = megabytes / 1024;
if (kilobytes < 1024) {
return t... | src/util.zig |
const builtin = @import("builtin");
const std = @import("std");
const io = std.io;
const os = std.os;
const fs = std.fs;
const Builder = std.build.Builder;
const FileSource = std.build.FileSource;
const thread = @import("src/thread.zig");
pub fn write_struct_def(comptime T: type) void {
const file = fs.cwd().cr... | kernel/build.zig |
const program_version = "0.0.0"; // TODO
const program_name = "st";
const std = @import("std");
const clap = @import("deps/clap");
const cfg = @import("config.zig");
const c = @import("c.zig");
const st = @import("st.zig");
const Bitset = @import("util.zig").Bitset;
const Glyph = st.Glyph;
pub const Shortcut = struc... | src/main.zig |
const std = @import("std");
const panic = std.debug.panic;
const assert = std.debug.assert;
const os = std.os;
const gl = @import("opengl.zig");
const genexp = @import("genexp004.zig");
fn updateFrameStats(window: os.windows.HWND, name: [*:0]const u8) struct { time: f64, delta_time: f32 } {
const state = struct {
... | src/main.zig |
const std = @import("std");
const api = @import("api.zig");
const EmbedInfo = @import("main.zig").EmbedInfo;
var log_file: ?std.fs.File = null;
var log_allocator = std.heap.page_allocator;
/// The function that gets called when the child plugin
/// is first initialized.
pub const HotReloadInit = fn (
embed_info: ... | src/hot_reload.zig |
pub const INVALID_HANDLE_VALUE = @import("zig.zig").typedConst(HANDLE, @as(i32, -1));
pub const E_NOTIMPL = @import("zig.zig").typedConst(HRESULT, @as(i32, -2147467263));
pub const E_OUTOFMEMORY = @import("zig.zig").typedConst(HRESULT, @as(i32, -2147024882));
pub const E_INVALIDARG = @import("zig.zig").typedConst(HRESU... | deps/zigwin32/win32/foundation.zig |
const std = @import("std");
const clap = @import("clap");
const config = @import("config.zig");
const gui = @import("gui.zig");
const VTE = @import("vte");
const c = VTE.c;
const allocator = std.heap.page_allocator;
const fmt = std.fmt;
const mem = std.mem;
const os = std.os;
const process = std.process;
const stderr =... | src/main.zig |
const builtin = @import("builtin");
const std = @import("std");
const Random = std.rand.Random;
const zeroCaseFn = switch (builtin.zig_backend) {
.stage1 => fn (*Random, f64) f64,
else => *const fn (*Random, f64) f64,
};
const pdfFn = switch (builtin.zig_backend) {
.stage1 => fn (f64) f64,
else => *con... | test/behavior/bugs/920.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
pub const Lexer = @import("Lexer.zig");
pub const Parser = @import("Parser.zig");
pub const Cst = @import("Cst.zig");
// pub const Span = struct {
// offset_or_index: u32, // index if len_or_tag is tag
// len_or_tag: u16, // tag if u16 max
// ... | fexc/src/parse/!mod.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const StringHashMap = std.StringHashMap;
const SysInfoWMI = @import("../../../../core/wmi.zig").SysInfoWMI;
const VariantElem = SysInfoWMI.VariantElem;
const util = @import("../../../../core/util.zig");
const _WMI = @impor... | lib/managers/hardware/OS/windows/windows.zig |