code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
pub const WM_CAP_START = @as(u32, 1024);
pub const MODM_USER = @as(u32, 16384);
pub const MIDM_USER = @as(u32, 16384);
pub const MODM_MAPPER = @as(u32, 8192);
pub const MIDM_MAPPER = @as(u32, 8192);
pub const MODM_INIT = @as(u32, 100);
pub const MIDM_INIT = @as(u32, 100);
pub const MODM_INIT_EX = @as(u32, 104);
pub con... | win32/media/multimedia.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Crab = struct {
pub const Mode = enum {
Unit,
Sum,
};
mode: Mode,
pMin: isize,
pMax: isize,
pos: std.ArrayList(isize),
pub fn init(mode: Mode) Crab {
var sel... | 2021/p07/crab.zig |
const std = @import("std");
const mem = std.mem;
const time = std.time;
const math = std.math;
const inf = math.inf;
const nan = math.nan;
const warn = std.debug.warn;
inline fn toDigit(ch: u8) !u8 {
if (ch >= '0' and ch <= '9') return ch - '0';
return error.InvalidCharacter;
}
fn parseFloat(comptime T: type... | src/lib/float.zig |
pub const SYS = enum(usize) {
read = 0x00,
write = 0x01,
open = 0x02,
close = 0x03,
stat = 0x04,
fstat = 0x05,
lstat = 0x06,
poll = 0x07,
lseek = 0x08,
mmap = 0x09,
mprotect = 0x0a,
munmap = 0x0b,
brk = 0x0c,
rt_sigaction = 0x0d,
rt_sigprocmask = 0x0e,
rt_... | src/linux/x86_64/consts.zig |
const std = @import("std");
const SplitResult = struct {
lower: ?*Node,
equal: ?*Node,
greater: ?*Node,
};
const NodePair = struct {
first: ?*Node,
second: ?*Node,
};
const Node = struct {
x: usize,
y: usize,
left: ?*Node = null,
right: ?*Node = null,
var rng = std.rand.Defau... | zig/main.zig |
const std = @import("std");
const builtin = @import("builtin");
const build_options = @import("build_options");
const utils = @import("utils");
const georgios = @import("georgios");
pub const platform = @import("platform.zig");
pub const fprint = @import("fprint.zig");
pub const print = @import("print.zig");
pub cons... | kernel/kernel.zig |
const sf = struct {
pub usingnamespace @import("../sfml.zig");
pub usingnamespace sf.system;
pub usingnamespace sf.graphics;
};
const std = @import("std");
const assert = std.debug.assert;
const TextureType = enum { _ptr, _const_ptr };
pub const Texture = union(TextureType) {
// Constructor/destruct... | src/sfml/graphics/texture.zig |
const std = @import("std");
test "" {
std.meta.refAllDecls(@This());
}
pub inline fn __enable_irq() void {
asm volatile ("cpsie i");
}
pub inline fn __disable_irq() void {
asm volatile ("cpsid i");
}
pub inline fn __enable_fault_irq() void {
asm volatile ("cpsie f");
}
pub inline fn __disable_fault_ir... | research-chamber/libs/lpc1768/lpc1768.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");
/// Representation of a reference log
pub const Reflog = opaque {
/// Free the reflog
pub fn deinit(self: *Reflog) void {
... | src/reflog.zig |
const std = @import("std");
const log = std.log;
const ascii = std.ascii;
const mem = std.mem;
const testing = std.testing;
const Allocator = mem.Allocator;
const web = @import("zhp.zig");
const util = web.util;
const Request = web.Request;
const Headers = web.Headers;
const simd = @import("simd.zig");
// Represents... | src/forms.zig |
const getty = @import("../../../lib.zig");
const std = @import("std");
pub fn Visitor(comptime Pointer: type) type {
if (@typeInfo(Pointer) != .Pointer or @typeInfo(Pointer).Pointer.size != .One) {
@compileError("expected one pointer, found `" ++ @typeName(Pointer) ++ "`");
}
return struct {
... | src/de/impl/visitor/pointer.zig |
const std = @import("std");
const mem = std.mem;
const TerminalPunctuation = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 33,
hi: u21 = 121482,
pub fn init(allocator: *mem.Allocator) !TerminalPunctuation {
var instance = TerminalPunctuation{
.allocator = allocator,
.array = try a... | src/components/autogen/PropList/TerminalPunctuation.zig |
pub const WNGETCON_CONNECTED = @as(u32, 0);
pub const WNGETCON_DISCONNECTED = @as(u32, 1);
pub const WNNC_SPEC_VERSION = @as(u32, 1);
pub const WNNC_SPEC_VERSION51 = @as(u32, 327681);
pub const WNNC_NET_TYPE = @as(u32, 2);
pub const WNNC_NET_NONE = @as(u32, 0);
pub const WNNC_DRIVER_VERSION = @as(u32, 3);
pub const WNN... | win32/network_management/wnet.zig |
const std = @import("std");
const testing = std.testing;
pub const Customs = struct {
const SIZE: usize = 26;
count_any: bool,
count: [SIZE]usize,
line_count: usize,
total_sum: usize,
pub fn init(count_any: bool) Customs {
var self = Customs{
.count_any = count_any,
... | 2020/p06/customs.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const Allocator = std.mem.Allocator;
const geo = @import("modules/zig-geometry/index.zig");
const json = @import("json.zig");
const parseJsonFile = @import("parse_json_file.zig").parseJsonFile;
const DBG = false;
const DBG1 = fa... | create_mesh_from_babylon_json.zig |
const clap = @import("clap");
const std = @import("std");
const util = @import("util");
const gen3 = @import("gen3.zig");
const gen4 = @import("gen4.zig");
const gen5 = @import("gen5.zig");
const rom = @import("rom.zig");
const script = @import("script.zig");
const fs = std.fs;
const heap = std.heap;
const io = std.i... | src/core/tm35-disassemble-scripts.zig |
const std = @import("std");
const TaskMod = @import("task.zig");
const Task = TaskMod.Task;
const TaskState = TaskMod.TaskState;
const platform = @import("platform.zig");
const serial = @import("debug/serial.zig");
const Allocator = std.mem.Allocator;
const TailQueue = std.TailQueue;
const TaskQueue = TailQueue(*Task);... | src/kernel/scheduler.zig |
const x86_64 = @import("../index.zig");
const bitjuggle = @import("bitjuggle");
const std = @import("std");
const formatWithoutFields = @import("../common.zig").formatWithoutFields;
/// The RFLAGS register.
pub const RFlags = packed struct {
/// Set by hardware if last arithmetic operation generated a carry out of... | src/registers/rflags.zig |
const std = @import("std");
const cuda_sdk = @import("cudaz/sdk.zig");
const CUDA_PATH = "/usr/local/cuda";
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const RunStep = std.build.RunStep;
var target: std.zig.CrossTarget = undefined;
var mode: std.builtin.Mode = undefined;
pub fn ... | CS344/build.zig |
const std = @import("std");
const panic = std.debug.panic;
const dpmi = @import("dpmi.zig");
const FarPtr = @import("far_ptr.zig").FarPtr;
pub const fd_t = u16;
pub const mode_t = u8;
pub const off_t = i32;
pub const E = @import("errno.zig").E;
pub const PATH_MAX = 260;
pub const STDIN_FILENO = 0;
pub const STDOUT... | src/dos/system.zig |
const windows = @import("windows.zig");
const UINT = windows.UINT;
const UINT64 = windows.UINT64;
const DWORD = windows.DWORD;
const FLOAT = windows.FLOAT;
const BOOL = windows.BOOL;
const GUID = windows.GUID;
const WINAPI = windows.WINAPI;
const IUnknown = windows.IUnknown;
const HRESULT = windows.HRESULT;
const WCHAR... | modules/platform/vendored/zwin32/src/dxgi.zig |
const std = @import("std");
const IguanaTLS = @import("iguanaTLS");
const Definitions = @import("./definitions.zig");
const Helpers = @import("./helpers.zig");
pub const Result = @import("./result.zig");
const Allocator = std.mem.Allocator;
const Address = std.net.Address;
const ArrayList = std.ArrayList;
const Strea... | src/driver.zig |
const std = @import("std");
const logger = std.log.scoped(.website);
const Date = @import("zig-date/src/main.zig").Date;
pub const log_level = if (std.builtin.mode == .Debug)
std.log.Level.debug
else
std.log.Level.info;
/// Global variables aren't too hard to keep track of when you only have one file.
var incl... | src/main.zig |
const std = @import("std");
pub const out = std.log.scoped(.libressl);
pub const tls = @cImport({
@cInclude("tls.h");
});
const tls_config = @import("tls_config.zig");
pub const TlsConfiguration = tls_config.TlsConfiguration;
pub const TlsConfigurationParams = tls_config.TlsConfigurationParams;
pub const SslStrea... | src/main.zig |
const inputFile = @embedFile("./input/day04.txt");
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const assert = std.debug.assert;
fn parseU32(buf: []const u8) std.fmt.ParseIntError!u32 {
return std.fmt.parseInt(u32, buf, 10);
}
const BingoBoard = struct {
co... | src/day04.zig |
const std = @import("std");
const clap = @import("zig-clap");
const cursesui = @import("cursesui.zig");
pub const Args = struct {
width: u8,
height: u8,
nmines: u16,
characters: cursesui.Characters,
color: bool,
};
fn parseSize(str: []const u8, width: *u8, height: *u8) !void {
const i = std.m... | src/argparser.zig |
const std = @import("std");
const sdk = @import("sdk");
const ifaces = @import("interface.zig").ifaces;
const font_manager = @import("font_manager.zig");
var scale_i: f32 = 1;
var origin_i = std.meta.Vector(2, i32){ 0, 0 };
var units_per_pixel_i: f32 = 1;
pub const scale = &scale_i; // TODO: this should affect text, ... | src/surface.zig |
const std = @import("std");
const zwin32 = @import("zwin32");
const w = zwin32.base;
const wasapi = zwin32.wasapi;
const hrErrorOnFail = zwin32.hrErrorOnFail;
pub const WasapiInterface = @This();
client: *wasapi.IAudioClient3,
render_client: *wasapi.IAudioRenderClient,
buffer_ready_event: w.HANDLE,
num_channels: u32... | modules/platform/src/win32/WasapiInterface.zig |
const std = @import("std");
const c = @import("../c.zig");
const vec3 = @import("vec3.zig");
pub const Sphere = struct {
const Self = @This();
center: c.vec3,
radius: f32,
fn encode(self: Self, buf: *std.ArrayList(c.vec4)) !void {
try buf.append(vec3.to_vec4(self.center, self.radius));
}... | src/scene/primitive.zig |
usingnamespace @import("bits.zig");
pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(WINAPI) ?*c_void;
pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(WINAPI) c_ulong;
pub extern "kernel32" fn CancelIoEx(hFile: HANDLE,... | lib/std/os/windows/kernel32.zig |
const std = @import("../std.zig");
const builtin = @import("builtin");
const Lock = std.event.Lock;
const testing = std.testing;
const Allocator = std.mem.Allocator;
/// ReturnType must be `void` or `E!void`
/// TODO This API was created back with the old design of async/await, when calling any
/// async function requ... | lib/std/event/group.zig |
const std = @import("../../std.zig");
const os = std.os;
const mem = std.mem;
const time = std.time;
pub fn Mixin(comptime Socket: type) type {
return struct {
/// Open a new socket.
pub fn init(domain: u32, socket_type: u32, protocol: u32, flags: std.enums.EnumFieldStruct(Socket.InitFlags, bool,... | lib/std/x/os/socket_posix.zig |
const ser = @import("../../../lib.zig").ser;
/// Map serialization interface.
///
/// Getty maps are only partially serialized by `getty.Serializer`
/// implementations due to the fact that there are many different ways to
/// iterate over and access the keys and values of a map. As such, this
/// interface is provide... | src/ser/interface/map.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const info = std.log.info;
const print = std.debug.print;
const fmt = std.fmt;
const utils = @import("utils.zig");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
pub fn parseBusId(data: []const u8) ?usize {
if (std.mem.eql(u8, data, "x")) {
... | day_13/src/main.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const os = std.os;
const assert = std.debug.assert;
const target = builtin.target;
const Atomic = std.atomic.Atomic;
pub const AutoResetEvent = @import("Thread/AutoResetEvent.zig");
pub const Futex = @import("Thread/Futex.zig");
pub const ResetEvent ... | lib/std/Thread.zig |
const std = @import("std");
const io = std.io;
const Args = @import("argparse.zig").Args;
const curl = @import("curl.zig");
const search = @import("pacman.zig").search;
const Pacman = @import("pacman.zig").Pacman;
const build_version = @import("build_options").version;
pub const log_level: std.log.Level = .info;
co... | src/main.zig |
const std = @import("std");
const zang = @import("zang");
const common = @import("common.zig");
const c = @import("common/c.zig");
const Recorder = @import("recorder.zig").Recorder;
const example = @import(@import("build_options").example);
const visual = @import("visual.zig");
const AUDIO_FORMAT = example.AUDIO_FORM... | examples/example.zig |
pub fn isEmoji(cp: u21) bool {
if (cp < 0x23 or cp > 0x1faf6) return false;
return switch (cp) {
0x23 => true,
0x2a => true,
0x30...0x39 => true,
0xa9 => true,
0xae => true,
0x203c => true,
0x2049 => true,
0x2122 => true,
0x2139 => true,
... | src/components/autogen/EmojiData.zig |
const std = @import("std");
const w4 = @import("wasm4.zig");
pub const Point = struct {
x: i32,
y: i32,
pub fn init(x: i32, y: i32) @This() {
return @This(){
.x = x,
.y = y,
};
}
pub fn equals(this: @This(), other: @This()) bool {
return (this.x == o... | src/snake.zig |
const std = @import("std");
const ssl = @import("ssl");
const SSLConnection = ssl.SSLConnection;
const Address = std.net.Address;
const Allocator = std.mem.Allocator;
pub const HeaderMap = std.StringHashMap(Header);
pub const Header = struct {
value: []const u8
};
pub const HttpResponse = struct {
headers: He... | zervo/protocols/http.zig |
pub const DEVPKEY_MTPBTH_IsConnected = PROPERTYKEY { .fmtid = Guid.initString("ea1237fa-589d-4472-84e4-0abe36fd62ef"), .pid = 2 };
pub const GUID_DEVINTERFACE_WPD = Guid.initString("6ac27878-a6fa-4155-ba85-f98f491d4f33");
pub const GUID_DEVINTERFACE_WPD_PRIVATE = Guid.initString("ba0c718f-4ded-49b7-bdd3-fabe28661211");... | win32/devices/portable_devices.zig |
//--------------------------------------------------------------------------------
// Section: Types (34)
//--------------------------------------------------------------------------------
pub const JOB_OBJECT_LIMIT = enum(u32) {
LIMIT_WORKINGSET = 1,
LIMIT_PROCESS_TIME = 2,
LIMIT_JOB_TIME = 4,
LIMIT_A... | win32/system/job_objects.zig |
// TODO: implement Op as a Redis.Arguments?
pub const BITOP = struct {
//! ```
//! const cmd = BITOP.init(.AND, "result", &[_][]const u8{ "key1", "key2" });
//! ```
operation: Op,
destKey: []const u8,
sourceKeys: []const []const u8,
pub fn init(operation: Op, destKey: []const u8, sourceK... | src/commands/strings/bitop.zig |
const builtin = @import("builtin");
const std = @import("std");
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
const expectStringStartsWith = std.testing.expectStringStartsWith;
// Most tests here can be comptime but use runtime so that a stacktrace
// can show failure lo... | test/behavior/typename.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectEqualSlices = std.testing.expectEqualSlices;
const expectEqual = std.testing.expectEqual;
const mem = std.mem;
const x = @intToPtr([*]i32, 0x1000)[0..0x500];
const y = x[0x100..];
test "compile time slice of pointer to hard coded address" {
... | test/stage1/behavior/slice.zig |
const std = @import("std");
pub const NodeValue = union(enum) {
integer: i32,
string: []const u8,
fn fromToken(token: Token) ?NodeValue {
if (token.value) |value| {
switch (value) {
.integer => |int| return NodeValue{ .integer = int },
.string => |str| r... | parser.zig |
const std = @import("std");
const BoolMap = enum(u8) {
auto_left_margin = 0,
auto_right_margin = 1,
no_esc_ctlc = 2,
ceol_standout_glitch = 3,
eat_newline_glitch = 4,
erase_overstrike = 5,
generic_type = 6,
hard_copy = 7,
has_meta_key = 8,
has_status_line = 9,
insert_null_gl... | src/terminfo.zig |
const std = @import("std");
const builtin = std.builtin;
const time = std.time;
const unicode = std.unicode;
const Timer = time.Timer;
const N = 1_000_000;
const KiB = 1024;
const MiB = 1024 * KiB;
const GiB = 1024 * MiB;
const ResultCount = struct {
count: usize,
throughput: u64,
};
fn benchmarkCodepointC... | lib/std/unicode/throughput_test.zig |
const std = @import("std");
const assert = std.debug.assert;
const panic = std.debug.panic;
const zp = @import("../../zplay.zig");
const gl = zp.deps.gl;
const Self = @This();
pub const Error = error{
TextureUnitUsed,
};
pub const TextureType = enum(c_uint) {
texture_1d = gl.GL_TEXTURE_1D,
texture_2d = gl... | src/graphics/common/Texture.zig |
const std = @import("std");
const warn = std.debug.print;
const Allocator = std.mem.Allocator;
const util = @import("../util.zig");
const config = @import("../config.zig");
const simple_buffer = @import("../simple_buffer.zig");
const toot_lib = @import("../toot.zig");
const thread = @import("../thread.zig");
const fil... | src/gui/gtk.zig |
//--------------------------------------------------------------------------------
// Section: Types (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Functions (4)
//-------------------... | win32/system/mailslots.zig |
const std = @import("std");
const datetime = @import("datetime");
const Channel = @import("utils/channel.zig").Channel;
const GlobalEventUnion = @import("main.zig").Event;
const Chat = @import("Chat.zig");
const parser = @import("network/parser.zig");
const EmoteCache = @import("network/EmoteCache.zig");
const build_o... | src/Network.zig |
const std = @import("std");
const VM = @import("./vm.zig").VM;
const Compiler = @import("./compiler.zig").Compiler;
const debug = @import("./debug.zig");
const Allocator = std.mem.Allocator;
const Value = @import("./value.zig").Value;
const Obj = @import("./object.zig").Obj;
const Table = @import("./table.zig").Table;
... | src/memory.zig |
pub const FACILITY_EAP_MESSAGE = @as(u32, 2114);
pub const EAP_GROUP_MASK = @as(i32, 65280);
pub const EAP_E_EAPHOST_FIRST = @as(i32, -2143158272);
pub const EAP_E_EAPHOST_LAST = @as(i32, -2143158017);
pub const EAP_I_EAPHOST_FIRST = @as(i32, -2143158272);
pub const EAP_I_EAPHOST_LAST = @as(i32, -2143158017);
pub const... | win32/security/extensible_authentication_protocol.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
// TIMES
//
// Dijkstra optimized:
// part 1: 0.037 seconds (answer: 707)
// part 2: 0.719 seconds (answer: 2942)
//
// A*:
// part 1: 0.052 seconds (answer: 707)
// part 2: 1.034 seconds (answer: 2942)
pub const ... | 2021/p15/map.zig |
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const L = std.unicode.utf8ToUtf16LeStringLiteral;
const zwin32 = @import("zwin32");
const w = zwin32.base;
const d3d12 = zwin32.d3d12;
const hrPanic = zwin32.hrPanic;
const hrPanicOnFail = zwin32.hrPanicOnFail;
const zd3d12 = @import("... | samples/intro/src/intro1.zig |
const std = @import("std");
const input = @embedFile("../input.txt");
const Vector = struct {
x: i64 = 0,
y: i64 = 0,
z: i64 = 0,
w: i64 = 0,
};
const CubeList = std.ArrayList(Vector);
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
var al... | 2020/day17/zig/day17.zig |
const pokemon = @import("pokemon");
const fun = @import("../../lib/fun-with-zig/index.zig");
const std = @import("std");
const math = std.math;
const gen3 = pokemon.gen3;
const common = pokemon.common;
const lu16 = fun.platform.lu16;
const lu32 = fun.platform.lu32;
const lu64 = fun.platform.lu64;
pub const em_first... | tools/offset-finder/gen3-constants.zig |
pub usingnamespace @import("std").zig.c_builtins;
pub const WGPUNonZeroU64 = c_ulonglong;
pub const WGPUOption_NonZeroU32 = c_ulong;
pub const WGPUOption_NonZeroU64 = c_ulong;
pub const WGPUOption_AdapterId = c_ulonglong;
pub const WGPUOption_BufferId = c_ulonglong;
pub const WGPUOption_SamplerId = c_ulonglong;
pub con... | vendor/wgpu.zig |
const std = @import("std");
const assert = std.debug.assert;
// I borrowed this name from HLSL
fn all(vector: anytype) bool {
const type_info = @typeInfo(@TypeOf(vector));
assert(type_info.Vector.child == bool);
assert(type_info.Vector.len > 1);
return @reduce(.And, vector);
}
fn any(vector: anytype)... | src/raytracer.zig |
const Self = @This();
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const wlr = @import("wlroots");
const wayland = @import("wayland");
const wl = wayland.server.wl;
const server = &@import("main.zig").server;
const util = @import("util.zig");
const Layout = @import("Layout.zig")... | source/river-0.1.0/river/LayoutDemand.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const expect = std.testing.expect;
const Obj = @import("./object.zig").Obj;
pub const Value = union(enum) {
const Self = @This();
nil,
boolean: bool,
number: f64,
obj: *Obj,
pub fn isNil(self: Self) bool {
return self == ... | src/value.zig |
const std = @import("std");
const mem = std.mem;
pub const output_len_unknown = 0;
pub const Blake2Xb = struct {
const Self = @This();
const Blake2 = std.crypto.hash.blake2.Blake2b512;
const magic_unknown_output_len = (1 << 32) - 1;
const max_output_len = (1 << 32) * 64;
const iv = [8]u64{
... | src/blake2x.zig |
const std = @import("std");
const Self = @This();
step: std.build.Step,
builder: *std.build.Builder,
source: std.build.FileSource,
output_file: std.build.GeneratedFile,
pub fn create(builder: *std.build.Builder, file: []const u8) *Self {
return createSource(builder, .{ .path = file });
}
pub fn createSource(bu... | src/TemplateStep.zig |
pub const GUID_DEVINTERFACE_DISPLAY_ADAPTER = Guid.initString("5b45201d-f2f2-4f3b-85bb-30ff1f953599");
pub const GUID_DEVINTERFACE_MONITOR = Guid.initString("e6f07b5f-ee97-4a90-b076-33f57bf4eaa7");
pub const GUID_DISPLAY_DEVICE_ARRIVAL = Guid.initString("1ca05180-a699-450a-9a0c-de4fbe3ddd89");
pub const GUID_DEVINTERFA... | deps/zigwin32/win32/devices/display.zig |
const std = @import("std");
const allocator = @import("memory.zig").allocator;
const state = @import("state.zig");
const enums = @import("enums.zig");
/// hostcallErrors is a wrapper of erred enums.Status.
pub const hostcallErrors = error{
NotFound,
BadArgument,
SerializationFailure,
InvalidMemoryAcces... | lib/hostcalls.zig |
const std = @import("std");
const concepts = @import("../../../lib.zig").concepts;
const DefaultSeed = @import("../../../lib.zig").de.DefaultSeed;
pub fn MapAccess(
comptime Context: type,
comptime Error: type,
comptime nextKeySeed: @TypeOf(struct {
fn f(c: Context, seed: anytype) Error!?@TypeOf(s... | src/de/interface/access/map.zig |
const std = @import("std");
const assert = std.debug.assert;
pub const DNA = struct {
pub const Unit = "nt";
pub const SupportsStrands = true;
pub fn complement(letter: u8) u8 {
return switch (letter) {
'A' => 'T',
'G' => 'C',
'C' => 'G',
'T', 'U' =... | src/bio/alphabet/dna.zig |
const std = @import("std");
const nc = @import("notcurses.zig");
const time = @import("time.zig");
const BOX_NUM: usize = 10;
const c_red: u32 = 14101551;
const c_yel: u32 = 16764969;
const c_blu: u32 = 3950975;
const c_whi: u32 = 16711422;
const box_colors = [BOX_NUM]u32{ c_red, c_whi, c_yel, c_whi, c_blu, c_whi, c_bl... | src/main.zig |
const std = @import("std");
const stdx = @import("stdx");
const t = stdx.testing;
const log = stdx.log.scoped(.builder);
const string = stdx.string;
const grammar = @import("grammar.zig");
const CharSetRangeSlice = grammar.CharSetRangeSlice;
const CharSlice = grammar.CharSlice;
const Grammar = grammar.Grammar;
const T... | parser/builder.zig |
const vk = @import("vk");
pub fn createRenderPass(device: vk.VkDevice, format: vk.VkFormat) vk.VkRenderPass {
const attachment = vk.VkAttachmentDescription{
.format = format,
.samples = vk.VK_SAMPLE_COUNT_1_BIT,
.loadOp = vk.VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = vk.VK_ATTACHMENT_S... | graphics/src/backend/vk/renderpass.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
pub fn main() !void {
const input = [_]u32{
1408, 1335, 1648, 1458, 1627, 1928, 1967, 1827, 1606, 1569, 1893, 1866, 1768, 1795, 1264,
1684, 1552, 1343, 1917, 1675, 1731, ... | src/day01.zig |
pub const KnightMoves = struct {
pub const dx = [8]i32{-2, -1, 1, 2, 2, 1, -1, -2};
pub const dy = [8]i32{1, 2, 2, 1, -1, -2, -2, -1};
};
pub const KingMoves = struct {
pub const dx = [8]i32{0, 1, 1, 1, 0, -1, -1, -1};
pub const dy = [8]i32{1, 1, 0, -1, -1, -1, 0, 1};
};
pub fn sum_for_all_position... | src/utils.zig |
pub const Bool32 = i32;
pub const CString = [*:0]const u8;
pub const MutCString = [*:0]u8;
pub const FileType = enum(c_int) {
invalid,
gltf,
glb,
};
pub const Result = enum(c_int) {
success,
data_too_short,
unknown_format,
invalid_json,
invalid_gltf,
invalid_options,
file_not_f... | libs/zmesh/src/zcgltf.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/day24.txt", run);
const Reg = enum { x, y, z, w };... | 2021/day24.zig |
const std = @import("std");
const leb = std.leb;
const macho = std.macho;
const mem = std.mem;
const assert = std.debug.assert;
const Allocator = mem.Allocator;
pub const ExternSymbol = struct {
/// MachO symbol table entry.
inner: macho.nlist_64,
/// Id of the dynamic library where the specified entries... | src/link/MachO/imports.zig |
const std = @import("std");
const os = std.os;
const ComptimeStringMap = std.ComptimeStringMap;
const File = std.fs.File;
const expectEqual = std.testing.expectEqual;
pub const EntryType = enum {
/// `no`: Normal (non-filename) text
Normal,
/// `fi`: Regular file
RegularFile,
/// `di`: Directory
... | src/entry_types.zig |
const std = @import("std");
const zriscv = @import("zriscv");
const resource_path: []const u8 = @import("build_options").resource_path;
test "rv64ui_p_lui" {
try runTest("rv64ui_p_lui.bin");
}
test "rv64ui_p_auipc" {
try runTest("rv64ui_p_auipc.bin");
}
test "rv64ui_p_jal" {
try runTest("rv64ui_p_jal.bin... | tests/tests.zig |
export fn mission2_main() noreturn {
Bss.prepare();
Uart.prepare();
Timer0.prepare();
Timer1.prepare();
Timer2.prepare();
LedMatrix.prepare();
CycleActivity.prepare();
TerminalActivity.prepare();
ThrottleActivity.prepare();
Uart.setUpdater(LedMatrix.update);
while (true) {... | mission2_model_railroad_pwm.zig |
const std = @import("std");
const wl = @import("wayland").server.wl;
const B = struct {
data: u32,
link: wl.list.Link = undefined,
};
const C = struct {
data: u32,
link: wl.list.Link = undefined,
pub fn getLink(c: *C) *wl.list.Link {
return &c.link;
}
pub fn fromLink(link: *wl.li... | example/list.zig |
usingnamespace @import("root").preamble;
/// Node hook for the queue. Embedded inside queue element.
pub const Node = struct {
next: ?*Node = undefined,
};
/// Non-atomic queue
pub fn Queue(comptime T: type, comptime member_name: []const u8) type {
return struct {
head: ?*Node = null,
tail: ?*... | lib/containers/queue.zig |
const tests = @import("tests.zig");
const std = @import("std");
const CrossTarget = std.zig.CrossTarget;
pub fn addCases(cases: *tests.TranslateCContext) void {
const default_enum_type = if (std.Target.current.abi == .msvc) "c_int" else "c_uint";
cases.add("field access is grouped if necessary",
\\uns... | test/translate_c.zig |
const std = @import("std");
const analysis = @import("analysis.zig");
const offsets = @import("offsets.zig");
const DocumentStore = @import("document_store.zig");
const types = @import("types.zig");
const ast = std.zig.ast;
const Token = std.zig.Token;
const identifierFromPosition = @import("main.zig").identifierFromPo... | src/signature_help.zig |
const std = @import("std");
const ast = std.zig.ast;
const Tree = ast.Tree;
const Node = ast.Node;
const full = ast.full;
const assert = std.debug.assert;
fn fullPtrType(tree: Tree, info: full.PtrType.Ast) full.PtrType {
const token_tags = tree.tokens.items(.tag);
// TODO: looks like stage1 isn't quite smart ... | src/ast.zig |
const std = @import("std");
const builtin = @import("builtin");
pub const CityHash32 = struct {
const Self = @This();
// Magic numbers for 32-bit hashing. Copied from Murmur3.
const c1: u32 = 0xcc9e2d51;
const c2: u32 = 0x1b873593;
fn fetch32(ptr: [*]const u8) u32 {
var v: u32 = undefine... | lib/std/hash/cityhash.zig |
//
// AUTO GENERATED! DO NOT EDIT!
//
const std = @import("std");
pub const StateFlags = enum(c_ulong) {
/// Enable R write.
WriteR = 0x0000000000000001,
/// Enable G write.
WriteG = 0x0000000000000002,
/// Enable B write.
WriteB = 0x0000000... | bindings/zig/bgfx.zig |
const upaya = @import("upaya.zig");
usingnamespace upaya.imgui;
pub fn setTintColor(color: ImVec4) void {
var colors = &igGetStyle().Colors;
colors[ImGuiCol_FrameBg] = hsvShiftColor(color, 0, 0, -0.2);
colors[ImGuiCol_Border] = hsvShiftColor(color, 0, 0, -0.2);
const header = hsvShiftColor(color, 0, -... | src/colors.zig |
const std = @import("std");
const fs = std.fs;
const mem = @import("std").mem;
const assert = std.debug.assert;
const expect = std.testing.expect;
// Simulator: http://spacetech.github.io/LC3Simulator/
// https://wchargin.com/lc3web/
// Specification: https://justinmeiners.github.io/lc3-vm/supplies/lc3-isa.pdf
const ... | src/main.zig |
//--------------------------------------------------------------------------------
// Section: Types (92)
//--------------------------------------------------------------------------------
const CLSID_MbnConnectionProfileManager_Value = Guid.initString("bdfee05a-4418-11dd-90ed-001c257ccff1");
pub const CLSID_MbnConnec... | win32/network_management/mobile_broadband.zig |
const std = @import("std");
const TypeInfo = std.builtin.TypeInfo;
pub fn Bitmask(comptime BackingType: type, comptime fields: anytype) type {
const BaseStruct = packed struct {};
var base_struct_info = @typeInfo(BaseStruct);
var incoming_fields: [fields.len]TypeInfo.StructField = undefined;
inline fo... | src/util.zig |
const std = @import("std");
const Planet = struct {
parent: []const u8,
childs: u32 = 0,
};
const Hash = std.StringHashMap(Planet);
pub fn main() anyerror!void {
const allocator = &std.heap.ArenaAllocator.init(std.heap.page_allocator).allocator;
const limit = 1 * 1024 * 1024 * 1024;
const text =... | 2019/day6a.zig |
const rl = @import("raylib");
pub fn main() anyerror!void
{
// Initialization
//--------------------------------------------------------------------------------------
const screenWidth = 800;
const screenHeight = 450;
rl.InitWindow(screenWidth, screenHeight, "raylib-zig [core] example - mouse inp... | examples/core/input_mouse.zig |
const std = @import("std");
pub extern const tinyfd_version: [8]u8;
pub extern const tinyfd_needs: [*c]const u8;
pub extern var tinyfd_verbose: c_int;
pub extern var tinyfd_silent: c_int;
pub extern var tinyfd_forceConsole: c_int;
pub extern var tinyfd_response: [1024]u8;
pub extern fn tinyfd_beep() void;
pub extern ... | src/deps/filebrowser/filebrowser.zig |
const std = @import("std.zig");
const assert = debug.assert;
const autoHash = std.hash.autoHash;
const debug = std.debug;
const warn = debug.warn;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const trait = meta.trait;
const Allocator = mem.Allocator;
const Wyhash = std.hash.Wyhash;
pub fn getAuto... | lib/std/hash_map.zig |
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day10.txt");
pub const ChunkType = enum {
Paren,
Bracket,
CurlyBrace,
Angle,
};
/// Given a valid chunk-opening character, map it to the enum type for the type of chunk it is starting.
fn openingType(char: ... | src/day10.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const test_allocator = std.testing.allocator;
const FLIR = @import("./Old_FLIR.zig");
const CFO = @import("./CFO.zig");
const print = std.debug.print;
const Self = @This();
const Inst = FLIR.Inst;
flir: *FLIR,
// tmp: [10]?u16 = .{null} ** 10,
tmp: [10... | src/parse.zig |
map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
items: std.MultiArrayList(Item) = .{},
extra: std.ArrayListUnmanaged(u32) = .{},
const InternArena = @This();
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const KeyAdapter = struct {
intern_arena: *const Int... | src/InternArena.zig |
const std = @import("std");
const c = @import("../../c.zig");
const zupnp = @import("../../lib.zig");
const xml = @import("xml");
const logger = std.log.scoped(.@"zupnp.upnp.device.action");
pub const ActionRequest = struct {
allocator: std.mem.Allocator,
handle: *const c.UpnpActionRequest,
pub fn getDev... | src/upnp/device/action.zig |
const std = @import("std");
const imgui = @import("imgui");
const glfw = @import("glfw");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
// ----------------------- Engine submodules -------------------------
pub const render = @import("render.zig");
pub const time = @import("time.zig");
pub con... | src/engine.zig |
const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day04.txt");
const Tile = struct {
number: u8,
marked: bool = false,
};
const Board = struct {
const Self = @This();
const board_size = 5;
tiles: [board_size * board_size]Tile,
pub fn initFromSeri... | src/day04.zig |