code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const crypto = std.crypto;
const debug = std.debug;
const fmt = std.fmt;
const mem = std.mem;
const Blake = crypto.hash.blake2.Blake2b512;
/// Blake2b variation of Ed25519 (EdDSA) signatures.
pub const Ed25519Blake2b = struct {
/// The underlying elliptic curve.
pub const Curve = cr... | ed25519-blake2b.zig |
const std = @import("std");
const mem = std.mem;
const fmt = std.fmt;
const zig = std.zig;
const fs = std.fs;
const stdlib_renames = std.ComptimeStringMap([]const u8, .{
// Most 64-bit archs.
.{ "newfstatat", "fstatat64" },
// POWER.
.{ "sync_file_range2", "sync_file_range" },
// ARM EABI/Thumb.
... | tools/generate_linux_syscalls.zig |
const std = @import("std");
const bcrypt = std.crypto.pwhash.bcrypt;
const clap = @import("clap.zig");
const debug = std.debug;
const Allocator = std.mem.Allocator;
const windows = std.os.windows;
const WINAPI = std.os.windows.WINAPI;
const HANDLE = std.os.windows.HANDLE;
const DWORD = std.os.windows.DWORD;
const LPDWO... | main.zig |
const DragIcon = @This();
const std = @import("std");
const wlr = @import("wlroots");
const wl = @import("wayland").server.wl;
const server = &@import("main.zig").server;
const util = @import("util.zig");
const Seat = @import("Seat.zig");
const Subsurface = @import("Subsurface.zig");
seat: *Seat,
wlr_drag_icon: *w... | source/river-0.1.0/river/DragIcon.zig |
const Self = @This();
const build_options = @import("build_options");
const std = @import("std");
const wlr = @import("wlroots");
const wl = @import("wayland").server.wl;
const xkb = @import("xkbcommon");
const command = @import("command.zig");
const server = &@import("main.zig").server;
const util = @import("util.z... | source/river-0.1.0/river/Seat.zig |
const std = @import("std");
const print = std.debug.print;
const List = std.ArrayList;
const StrMap = std.StringHashMap;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day12.txt");
const Edge = struct {
a: []const u8,
b: []const u8,
};
const Node = struct {
is_s... | 2021/src/day12.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const data = @embedFile("../inputs/day07.txt");
pub fn main() anyerror!void {
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_impl.deinit();
const gpa = gpa_impl.allocator();
return m... | src/day07.zig |
const std = @import("std");
pub usingnamespace std.os.windows;
pub const WS_VISIBLE = 0x10000000;
pub const VK_ESCAPE = 0x001B;
pub const VK_LBUTTON = 0x01;
pub const VK_RBUTTON = 0x02;
pub const POINT = extern struct {
x: LONG,
y: LONG,
};
pub const RECT = extern struct {
left: LONG,
top: LONG,
... | src/windows/windows.zig |
const std = @import("std");
const os = std.os;
const warn = std.debug.warn;
const syspect = @import("syspect");
pub fn main() !void {
const allocator = std.heap.c_allocator;
const syscalls = &[_]os.SYS{
.open,
.openat,
};
var inspector = syspect.Inspector.init(allocator, syscalls, .{... | examples/print_pathname.zig |
const std = @import("std");
const zap = @import("zap");
const hyperia = @import("hyperia.zig");
const os = std.os;
const mem = std.mem;
const builtin = std.builtin;
const testing = std.testing;
const assert = std.debug.assert;
pub const cache_line_length = switch (builtin.cpu.arch) {
.x86_64, .aarch64, .powerpc6... | mpsc.zig |
const std = @import("std");
const int = @import("int.zig");
pub const blz = @import("nds/blz.zig");
const debug = std.debug;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const os = std.os;
const testing = std.testing;
const lu16 = int.lu16;
const lu32 = int.lu32;
pub const f... | src/core/rom/nds.zig |
const peripherals = @import("peripherals.zig");
const AddressRange = peripherals.AddressRange;
const std = @import("std");
/// A structure containin info about the BCM2835 chip
/// see this website which does a brilliant job of explaining everything
/// https://www.pieter-jan.com/node/15
/// The most important thing... | src/bcm2835.zig |
usingnamespace @import("root").preamble;
/// Allocator used to allocate memory for new tasks
const task_alloc = os.memory.pmm.phys_heap;
/// Load balancer lock. Locked when scheduler finds the best CPU for the task
/// or when task terminates
var balancer_lock = os.thread.Spinlock{};
/// Move to the next task.
/// N... | subprojects/flork/src/thread/scheduler.zig |
pub const LOCATION_API_VERSION = @as(u32, 1);
//--------------------------------------------------------------------------------
// Section: Types (23)
//--------------------------------------------------------------------------------
const CLSID_Location_Value = @import("../zig.zig").Guid.initString("e5b8e079-ee6d-4e... | deps/zigwin32/win32/devices/geolocation.zig |
const std = @import("std");
const objc = @import("objc.zig");
const Class = objc.Class;
const object = objc.object;
const id = objc.id;
const SEL = objc.SEL;
const IMP = objc.IMP;
const c = @import("c.zig");
pub const Error = error{
FailedToGetClassForObject,
FailedToGetInstanceVariable,
ClassNotRegiste... | modules/platform/vendored/zig-objcrt/src/runtime.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const fmt = std.fmt;
const util = @import("utils.zig");
const input = @embedFile("../in/day04.txt");
const PassportField = enum(usize) {
byr,
iyr,
eyr,
hgt,
... | src/day04.zig |
const std = @import("std");
const expect = std.testing.expect;
const io = std.io;
const mem = std.mem;
const testing = std.testing;
const ArrayList = std.ArrayList;
const deflate = @import("compressor.zig");
const inflate = @import("decompressor.zig");
const deflate_const = @import("deflate_const.zig");
test "best s... | lib/std/compress/deflate/deflate_fast_test.zig |
const Builder = @import("std").build.Builder;
pub fn build(b: *Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// ... | build.zig |
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
const KV = @import("kv.zig").KV;
const Link = @import("link.zig").Link;
const LinkTag = @import("link.zig").LinkTag;
const Pruned = @import("link.zig").Pruned;
const Stored = @import("link.zig").Stored;
const Hash = @import("hash.zig").H;
con... | src/tree.zig |
const std = @import("std");
const log = std.log;
const utils = @import("utils.zig");
const tokenizer = @import("tokenizer.zig");
const Tokenizer = tokenizer.Tokenizer;
const Token = tokenizer.Token;
const TokenKind = tokenizer.TokenKind;
const ast = @import("ast.zig");
const Node = ast.Node;
const NodeKind = ast.Nod... | src/parser.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const grid_serial_number: u32 = 5791;
const grid_side_len = 300;
pub fn main() void {
const result1 = regionOfHighestTotalPower(grid_serial_number);
debug.assert(V2.eq(V2.init(20, 68), result1));
debug.warn("11-1: {}\n", result1);
... | 2018/day_11.zig |
const std = @import("std");
const maxIgnorePatternLength: u32 = 1024;
const maxIgnoreFilenameLength: u32 = 1024;
fn trim(str: []u8) []u8 {
var first: u64 = 0;
while (first < str.len and str[first] == ' ') {
first += 1;
}
var last: u64 = str.len;
while (last > 0 and str[last - 1] == ' ')... | src/main.zig |
pub const DescIter = struct {
drv: *Driver,
i: u8,
curr: Descriptor,
next: Descriptor,
/// Put the head of a descriptor chain on the available ring
pub fn begin(iter: *DescIter) void {
var i = &iter.drv.queues[iter.i];
iter.next = iter.drv.descr(iter.i);
i.avail.rings(i.wrap(i.avail.idx +% i.pe... | src/drivers/virtio/virtio-pci.zig |
const std = @import("std");
const print = std.debug.print;
const List = std.ArrayList;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day09.txt");
const desc = std.sort.desc(usize);
pub fn main() !void {
var lines = try util.toStrSlice(data, "\n");
const rows = line... | 2021/src/day09.zig |
const std = @import("std");
const os = std.os;
const builtin = @import("builtin");
fn no_op_print(fmt: []const u8, args: var) void {}
const print = if (builtin.is_test or builtin.mode != .Debug) no_op_print else std.debug.warn;
const waitpid_file = @import("waitpid.zig");
const waitpid = waitpid_file.waitpid;
const W... | src/events.zig |
const main = @import("main.zig");
const vectors = @import("vectors.zig");
pub export fn _start() callconv(.Naked) noreturn {
// At startup the stack pointer is at the end of RAM
// so, no need to set it manually!
// Reference this such that the file is analyzed and the vectors
// are added.
_ = ve... | src/start.zig |
const std = @import("std");
const os = std.os;
const mem = std.mem;
const net = std.net;
const time = std.time;
const testing = std.testing;
const print = std.debug.print;
pub const Socket = struct {
fd: os.socket_t,
pub fn init(domain: u32, socket_type: u32, protocol: u32) !Socket {
return Socket{ ... | socket.zig |
// SPDX-License-Identifier: MIT
// This file is part of the Termelot project under the MIT license.
const std = @import("std");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const Pkg = std.build.Pkg;
const fs = std.fs;
const BackendName = @import("src/backend.zig").BackendName;
... | build.zig |
const std = @import("std");
const fs = std.fs;
const os = std.os;
const Connector = @import("connector.zig").Connector;
const WireBuffer = @import("wire.zig").WireBuffer;
const Table = @import("table.zig").Table;
pub const FRAME_METHOD = 1;
pub const FRAME_HEADER = 2;
pub const FRAME_BODY = 3;
pub const FRAME_HEARTBEA... | src/protocol.zig |
const std = @import("std");
const stdx = @import("stdx");
const t = stdx.testing;
const log = stdx.log.scoped(.incremental_test);
const _parser = @import("parser.zig");
const Parser = _parser.Parser;
const ParseConfig = _parser.ParseConfig;
const DebugInfo = _parser.DebugInfo;
const grammar = @import("grammar.zig");
c... | parser/incremental.test.zig |
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expo2 = @import("expo2.zig").expo2;
const expect = std.testing.expect;
const maxInt = std.math.maxInt;
/// Returns the hyperbolic cosine of x.
///
/// Special Cases:
/// - cosh(+-0) = 1
/// - cosh(+-inf) = +inf
///... | lib/std/math/cosh.zig |
const std = @import("../../../std.zig");
const linux = std.os.linux;
const socklen_t = linux.socklen_t;
const iovec = linux.iovec;
const iovec_const = linux.iovec_const;
const stack_t = linux.stack_t;
const sigset_t = linux.sigset_t;
const uid_t = linux.uid_t;
const gid_t = linux.gid_t;
const pid_t = linux.pid_t;
pub ... | lib/std/os/bits/linux/arm-eabi.zig |
const std = @import("std");
const lola = @import("../main.zig");
const whitespace = [_]u8{
0x09, // horizontal tab
0x0A, // line feed
0x0B, // vertical tab
0x0C, // form feed
0x0D, // carriage return
0x20, // space
};
const root = @import("root");
const milliTimestamp = if (std.builtin.os.ta... | src/library/libraries/stdlib.zig |
const std = @import("std");
// Compile time regular expressions for zig
// by alexnask
// https://github.com/alexnask/ctregex.zig
fn utf16leCharSequenceLength(first_char: u16) !u2 {
const c0: u21 = first_char;
if (first_char & ~@as(u21, 0x03ff) == 0xd800) {
return 2;
} else if (c0 & ~@as(u21, 0x03... | src/ctregex.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const common = @import("common.zig");
const instruction_ = @import("../instruction.zig");
const Op = instruction_.Op;
const Addressing = instruction_.Addressing;
const Instruction = instruction_.Instruction;
const opToString = instruction_.opToString;
... | src/cpu/fast.zig |
const std = @import("std");
const testing = std.testing;
const math = std.math;
const mem = std.mem;
/// Given a type and value, cast the value to the type as c would.
pub fn cast(comptime DestType: type, target: anytype) DestType {
// this function should behave like transCCast in translate-c, except it's for mac... | lib/std/zig/c_translation.zig |
const std = @import("std");
const Builder = std.build.Builder;
const Pkg = std.build.Pkg;
const string = []const u8;
const alloc = std.heap.page_allocator;
const fmt_description = "Run the {s} example";
const Pkgs = struct {
const QObject: Pkg = .{
.name = "QObject",
.path = "src/QObject.zig",
... | build.zig |
const std = @import("std");
usingnamespace @import("vector3.zig");
usingnamespace @import("quaternion.zig");
pub fn Matrix4Fn(comptime T: type) type {
if (@typeInfo(T) != .Float) {
@compileError("Matrix4 not implemented for " ++ @typeName(T) ++ " must use float type");
}
return struct {
co... | src/linear_math/matrix4.zig |
const std = @import("std");
const Tokenizer = @import("tokenizer.zig");
pub const Token = Tokenizer.Token;
const TokenIterator = Tokenizer.TokenList.Iterator;
const OOMhandler = Tokenizer.OOMhandler;
const algods = @import("algods");
const compiler = @import("main.zig");
const types = @import("type.zig");
const Type = ... | src/parser.zig |
const std = @import("std");
fn ok(comptime s: []const u8) void {
std.debug.assert(std.json.validate(s));
}
fn err(comptime s: []const u8) void {
std.debug.assert(!std.json.validate(s));
}
fn any(comptime s: []const u8) void {
std.debug.assert(true);
}
///////////////////////////////////////////////////... | json_test.zig |
const std = @import("std");
const with_trace = false;
const assert = std.debug.assert;
fn trace(comptime fmt: []const u8, args: anytype) void {
if (with_trace) std.debug.print(fmt, args);
}
const Vec3 = [3]i32;
fn abs(x: i32) u32 {
return if (x >= 0) @intCast(u32, x) else @intCast(u32, -x);
}
fn length(d: Ve... | 2019/day12.zig |
const std = @import("std");
const tvg = @import("tvg");
pub fn main() !void {
try std.fs.cwd().writeFile("examples/app_menu.tvg", &app_menu);
try std.fs.cwd().writeFile("examples/workspace.tvg", &workspace);
try std.fs.cwd().writeFile("examples/workspace_add.tvg", &workspace_add);
try std.fs.cwd().writ... | src/data/ground-truth.zig |
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const fmt = b.addFmt(&[_][]const u8{ "src", "build.zig" });
{
const panel = b.step("panel", "Build panel");
const mode = b.standardReleaseOptions();
const lib = b.addSharedLibrary("tenhourt... | build.zig |
const std = @import("std");
const analysis = @import("./analysis.zig");
const types = @import("./types.zig");
const offsets = @import("./offsets.zig");
const URI = @import("./uri.zig");
const allocator = std.testing.allocator;
fn makeDocument(uri: []const u8, text: []const u8) !types.TextDocument {
const mem = tr... | src/unit_tests.zig |
const std = @import("std");
const printf = std.io.stdout.printf;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const Buffer = std.Buffer;
const MdState = enum {
Normal,
FencedCodeBlock,
};
const HeaderWeight = enum {
H1, H2, H3, H4, H5, H6,
};
const MdTextAttribute = enum {
N... | src/markdown.zig |
const std = @import("std");
fn calculateChecksum(packet_data: []const u8) u8 {
var result: u8 = 0;
for (packet_data) |c| result +%= c;
return result;
}
fn verifyChecksum(packet_data: []const u8, checksum: u8) !void {
if (calculateChecksum(packet_data) != checksum)
return error.BadChecksum;
... | src/lib/gdb.zig |
const std = @import("std");
const testing = std.testing;
const binary_search = @import("binary_search.zig");
const SearchError = binary_search.SearchError;
test "finds a value in an array with one element" {
comptime try testing.expectEqual(0,
try binary_search.binarySearch(i4, 6,
&[_]i4{6}));... | exercises/practice/binary-search/test_binary_search.zig |
pub extern "LALR" const zig_grammar = struct {
const Precedence = struct {
right: enum {
Precedence_enumlit,
},
left: enum {
// AssignOp
Equal,
AsteriskEqual,
SlashEqual,
PercentEqual,
PlusEqual,
... | zig/ziglang.zig |
const stdm = @import("std").math;
pub const colorsRGB8 = @import("ColorRGB8.zig");
pub const colorsRGBA8 = @import("ColorRGBA8.zig");
pub const colorsRGBA = @import("ColorRGBA.zig");
pub const colorsRGB = @import("ColorRGB.zig");
fn ColorEquals(comptime colorType: type, lhs: *const colorType, rhs: *const colorType) b... | src/math/Color.zig |
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const Metric = @import("metric.zig").Metric;
const Self = @This();
metric: Metric = Metric{
.getResultFn = getResult,
},
value: std.atomic.Atomic(u64) = .{ .value = 0 },
pub fn init(allocator: mem.Allocator) !*Self {
const self = ... | src/Counter.zig |
const std = @import("std");
const sdk = @import("sdk");
const log = @import("log.zig");
const hooks = @import("hooks.zig");
var ifaces_internal = blk: { // This is a workaround for a weird result location bug, will be fixed in stage2
var i: Ifaces = undefined;
break :blk i;
};
pub const ifaces = &ifaces_intern... | src/interface.zig |
const std = @import("std");
const c = @import("c.zig");
const ft = @import("ft.zig");
const msgpack = @import("msgpack.zig");
const shaderc = @import("shaderc.zig");
const util = @import("util.zig");
const paste = @import("paste.zig");
const Buffer = @import("buffer.zig").Buffer;
const Debounce = @import("debounce.zi... | src/tui.zig |
const std = @import("std");
const fmt = std.fmt;
const testing = std.testing;
const Allocator = std.mem.Allocator;
pub const Error = struct {
_buf: [32]u8,
end: usize,
/// Get the error code.
pub fn getCode(self: Error) []const u8 {
return self._buf[0..self.end];
}
};
pub const FullError ... | src/types/error.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 pad: f32 = 2;
const Self = @This();
widget: gui.Widget,
allocator: Allocator,
has_grip: bool = fals... | src/gui/widgets/Toolbar.zig |
const std = @import("std");
const Module = @import("module.zig");
const Instance = @import("instance.zig");
const Memory = @import("Memory.zig");
const Wasi = @This();
argv: [][]u8,
environ: [][]u8 = &.{},
exit_code: ?Exitcode = null,
const P = Memory.P;
pub fn run(self: *Wasi, allocator: *std.mem.Allocator, reader... | src/wasi.zig |
const std = @import("std");
const sqlite = @import("sqlite");
const manage_main = @import("main.zig");
const libpcre = @import("libpcre");
const Context = manage_main.Context;
const log = std.log.scoped(.arm);
const VERSION = "0.0.1";
const HELPTEXT =
\\ arm: remove files from the index
\\
\\ usage:
\... | src/rm_main.zig |
const root = @import("root");
const builtin = @import("builtin");
const std = @import("std");
const backend = @import("backend.zig");
const style = @import("style.zig");
const Widget = @import("widget.zig").Widget;
const Class = @import("widget.zig").Class;
const Size = @import("data.zig").Size;
const DataWrapper = @im... | src/internal.zig |
const std = @import("std");
const string = []const u8;
const input = @embedFile("../input/day03.txt");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
// part 1
{
var arena = std.heap.ArenaAllocator.init(&gpa.allocator);
defer arena.dei... | src/day03.zig |
const Scope = @import("scope.zig").Scope;
pub const Instruction = struct {
id: Id,
scope: &Scope,
pub const Id = enum {
Br,
CondBr,
SwitchBr,
SwitchVar,
SwitchTarget,
Phi,
UnOp,
BinOp,
DeclVar,
LoadPtr,
StorePtr,
... | src-self-hosted/ir.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/day09.txt");
//... | src/day09.zig |
pub const GUID_PROP_TEXTOWNER = Guid.initString("f1e2d520-0969-11d3-8df0-00105a2799b5");
pub const GUID_PROP_ATTRIBUTE = Guid.initString("34b45670-7526-11d2-a147-00105a2799b5");
pub const GUID_PROP_LANGID = Guid.initString("3280ce20-8032-11d2-b603-00105a2799b5");
pub const GUID_PROP_READING = Guid.initString("5463f7c0-... | win32/ui/text_services.zig |
//--------------------------------------------------------------------------------
// Section: Types (1)
//--------------------------------------------------------------------------------
pub const NV_MEMORY_RANGE = extern struct {
BaseAddress: ?*anyopaque,
Length: usize,
};
//-------------------------------... | win32/system/memory/non_volatile.zig |
const std = @import("std");
const builtin = @import("builtin");
const os = std.os;
const linux = os.linux;
const windows = os.windows;
const kernel32 = os.windows.kernel32;
const GetConsoleScreenBufferInfo = kernel32.GetConsoleScreenBufferInfo;
const GetStdHandle = kernel32.GetStdHandle;
const GetLastError = kernel32.... | src/main.zig |
const std = @import("std");
const builtin = @import("builtin");
const trait = std.meta.trait;
const debug = std.debug;
const assert = debug.assert;
const Allocator = mem.Allocator;
const mem = std.mem;
const cleveldb = @cImport({
@cInclude("leveldb/c.h");
});
const c = @cImport({
@cInclude("stdio.h");
@cI... | leveldb.zig |
const std = @import("std");
const format = @import("format.zig");
const decode = @import("decode.zig");
const value = @import("value.zig");
const expect = std.testing.expect;
const Format = format.Format;
const DecodeError = decode.DecodeError;
const ValueWithRest = struct {
v: value.Value,
rest: []const u8,
... | src/decode_value.zig |
const std = @import("std");
const zjson = @import("zjson");
const lib = @import("main.zig");
const model = lib.model;
pub fn parseSearch(input: []const u8, allocator: std.mem.Allocator) !model.SearchResult {
const shelves = try zjson.get(input, .{ "contents", "tabbedSearchResultsRenderer", "tabs", 0, "tabRenderer... | src/parser.zig |
const graph = @import("weighted_graph.zig").WeightedGraph;
const std = @import("std");
const ArrayList = std.ArrayList;
const graph_err = @import("graph.zig").GraphError;
const testing = std.testing;
const AutoArrayHashMap = std.AutoArrayHashMap;
const mem = std.mem;
const testing_alloc = std.testing.allocator;
pub fn... | src/weighted_data_graph.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) !void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for res... | build.zig |
const std = @import("std");
const unitbounds = @import("unitbounds.zig");
const Allocator = std.mem.Allocator;
pub fn Screen(comptime Cell: type) type {
return struct {
const Self = @This();
allocator: *Allocator,
cells: []Cell,
width: usize,
height: usize,
ub: un... | lib/screen.zig |
const std = @import("std");
const fb = @import("../console/fb.zig");
const hw = @import("../hw.zig");
const printf = @import("../console/fb.zig").printf;
pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
hw.entry_uart.carefully(.{"\r\n!!!!!!!!!!!!\r\nkernel panic\r\n!!!!!!!!!!!... | dainkrnl/src/arm64/arch.zig |
//--------------------------------------------------------------------------------
// Section: Types (5)
//--------------------------------------------------------------------------------
// TODO: this type has a FreeFunc 'wglDeleteContext', what can Zig do with this information?
pub const HGLRC = *opaque{};
pub cons... | deps/zigwin32/win32/graphics/open_gl.zig |
const std = @import("std");
const system = std.os.linux;
const ArrayList = std.ArrayList;
const Candidate = filter.Candidate;
const File = std.fs.File;
const filter = @import("filter.zig");
pub const Terminal = struct {
tty: File,
termios: std.os.termios,
raw_termios: std.os.termios,
height: usize =... | src/ui.zig |
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const unicode = std.unicode;
pub const ascii = @import("src/ascii.zig");
pub const utf8 = @import("src/utf8.zig");
/// All the ways in which a parser can fail.
/// Parser... | mecha.zig |
const std = @import("std");
const testing = std.testing;
fn flattenT(comptime T: type) type {
return struct {
const Self = @This();
list: []const []const T,
const Iterator = struct {
list: []const []const T,
outer: usize,
inner: usize,
fn n... | src/flatten.zig |
const std = @import("std");
const os = std.os;
const tcp = std.x.net.tcp;
const ip = std.x.net.ip;
const net = std.net;
const linux = std.os.linux;
const IPv4 = std.x.os.IPv4;
const Socket = std.x.os.Socket;
const fd_t = linux.fd_t;
const IO_Uring = linux.IO_Uring;
const io_uring_sqe = linux.io_uring_sqe;
const IORING_... | src/io_uring-tcp-hasher/v3.zig |
const std = @import("std");
const testing = std.testing;
pub const Password = struct {
pub fn init() Password {
var self = Password{};
return self;
}
pub fn deinit(self: *Password) void {
_ = self;
}
pub fn check_count(self: Password, line: []const u8) bool {
_ = s... | 2020/p02/password.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const input = @embedFile("../inputs/day05.txt");
const i32_max: i32 = std.math.maxInt(i32);
const i32_min: i32 = std.math.minInt(i32);
pub fn run(alloc: Allocator, stdout_: anytype) !void {
var bottom_left: [2]i32 = undefined;
var top_right: [2]... | src/day05.zig |
const std = @import("std");
pub const CodeGeneratorError = error{OutOfMemory};
pub const CodeGenerator = struct {
allocator: std.mem.Allocator,
string_pool: std.ArrayList([]const u8),
globals: std.ArrayList([]const u8),
bytecode: std.ArrayList(u8),
const Self = @This();
const word_size = @siz... | codegen.zig |
const Self = @This();
const std = @import("std");
const wayland = @import("wayland");
const wl = wayland.server.wl;
const zriver = wayland.server.zriver;
const util = @import("util.zig");
const Output = @import("Output.zig");
const View = @import("View.zig");
const ViewStack = @import("view_stack.zig").ViewStack;
... | source/river-0.1.0/river/OutputStatus.zig |
const std = @import("std");
const mem = std.mem;
const meta = std.meta;
const net = std.net;
const ArrayList = std.ArrayList;
usingnamespace @import("../frame.zig");
usingnamespace @import("../primitive_types.zig");
usingnamespace @import("../query_parameters.zig");
const testing = @import("../testing.zig");
/// QUER... | src/frames/query.zig |
const std = @import("std");
const math = std.math;
const INT_MIN = math.minInt(i32);
const INT_MAX = math.maxInt(i32);
const LEAPOCH = @as(i64, 946684800) + 86400 * (31 + 29);
const DAYS_PER_400Y = (365 * 400 + 97);
const DAYS_PER_100Y = (365 * 100 + 24);
const DAYS_PER_4Y = (365 * 4 + 1);
const ConversionError = err... | src/time.zig |
const cuckoo = @import("./cuckoofilter.zig");
// CONSTS
export const CF_OK: c_int = 0;
export const CF_TOOFULL: c_int = 1;
export const CF_BROKEN: c_int = 2;
export const CF_BADLEN: c_int = 3;
export const CF_ALIGN8: usize = cuckoo.Filter8.Align;
export const CF_ALIGN16: usize = cuckoo.Filter16.Align;
export const C... | src/cuckoofilter_c.zig |
const std = @import("std");
const math = std.math;
const zp = @import("zplay");
const alg = zp.deps.alg;
const Vec2 = alg.Vec2;
const dig = zp.deps.dig;
const nvg = zp.deps.nvg;
const nsvg = zp.deps.nsvg;
var rng: std.rand.DefaultPrng = undefined;
var rg: std.rand.Random = undefined;
var tiger: nsvg.SVG = undefined;
... | examples/vg_benchmark.zig |
const std = @import("std");
const assert = std.debug.assert;
const wren = @import("./wren.zig");
const Vm = @import("./vm.zig").Vm;
const ErrorType = @import("./vm.zig").ErrorType;
fn cStrToSlice(str: [*c]const u8) []const u8 {
return str[0..std.mem.lenZ(str)];
}
pub fn writeWrapper(cvm: ?*wren.Vm, ctext: [*c]co... | src/zapata/c_wrappers.zig |
const c = @cImport({
@cInclude("cfl.h");
@cInclude("cfl_menu.h");
});
const widget = @import("widget.zig");
const enums = @import("enums.zig");
pub const WidgetPtr = ?*c.Fl_Widget;
fn shim(w: ?*c.Fl_Widget, data: ?*c_void) callconv(.C) void {
_ = w;
c.Fl_awake_msg(data);
}
pub const MenuFlag = enum(i... | src/menu.zig |
const std = @import("std");
const stdx = @import("stdx");
const ds = stdx.ds;
const process = std.process;
const build_options = @import("build_options");
const graphics = @import("graphics");
const v8 = @import("v8");
const runtime = @import("../runtime/runtime.zig");
const printFmt = runtime.printFmt;
const log = st... | docs/doc_gen.zig |
const std = @import("std");
const TestContext = @import("../../src/test.zig").TestContext;
const wasi = std.zig.CrossTarget{
.cpu_arch = .wasm32,
.os_tag = .wasi,
};
pub fn addCases(ctx: *TestContext) !void {
{
var case = ctx.exe("wasm function calls", wasi);
case.addCompareOutput(
... | test/stage2/wasm.zig |
const builtin = @import("builtin");
const std = @import("std");
const CrossTarget = std.zig.CrossTarget;
const Builder = std.build.Builder;
const Step = std.build.Step;
const LibExeObjStep = std.build.LibExeObjStep;
const warn = std.debug.warn;
const allocPrint = std.fmt.allocPrint;
const eql = std.mem.eql;
const eqlI... | examples/build.zig |
const format = @import("std").fmt.format;
const OutStream = @import("std").io.OutStream;
const arm_m = @import("arm_m");
const arm_cmse = @import("arm_cmse");
const lpc55s69 = @import("../../drivers/lpc55s69.zig");
pub const VTOR_NS = 0x00010000;
extern var __nsc_start: usize;
extern var __nsc_end: usize;
const Flex... | examples/ports/lpc55s69/secure.zig |
const std = @import("std");
/// The only output of the tokenizer.
pub const ZNodeToken = struct {
const Self = @This();
/// 0 is root, 1 is top level children.
depth: usize,
/// The extent of the slice.
start: usize,
end: usize,
};
/// Parses text outputting ZNodeTokens. Does not convert stri... | src/main.zig |
//--------------------------------------------------------------------------------
// Section: Types (3)
//--------------------------------------------------------------------------------
pub const PFN_PDF_CREATE_RENDERER = fn(
param0: ?*IDXGIDevice,
param1: ?*?*IPdfRendererNative,
) callconv(@import("std").os... | win32/system/win_rt/pdf.zig |
pub const CF_REQUEST_KEY_DEFAULT = @as(u32, 0);
pub const CF_PLACEHOLDER_MAX_FILE_IDENTITY_LENGTH = @as(u32, 4096);
pub const CF_MAX_PRIORITY_HINT = @as(u32, 15);
pub const CF_MAX_PROVIDER_NAME_LENGTH = @as(u32, 255);
pub const CF_MAX_PROVIDER_VERSION_LENGTH = @as(u32, 255);
//-----------------------------------------... | win32/storage/cloud_filters.zig |
const std = @import("std");
const assert = std.debug.assert;
const print = std.debug.print;
const tools = @import("tools");
const Vec2 = tools.Vec2;
const stride: usize = 11;
const width = 10;
const height = 10;
const Border = u10;
const Map = struct {
ident: u32,
map: []const u8,
borders: ?struct { cano... | 2020/day20.zig |
const io = @import("../../lib/io.zig");
const heap = @import("std").heap;
const fmt = @import("std").fmt;
const mem = @import("std").mem;
const Writer = @import("std").io.Writer;
const VGA_WIDTH = 80;
const VGA_HEIGHT = 25;
const VGA_SIZE = VGA_WIDTH * VGA_HEIGHT;
pub const ConsoleColors = enum(u8) {
Black = 0,
... | stage1/bios/console.zig |
//--------------------------------------------------------------------------------
// Section: Types (5)
//--------------------------------------------------------------------------------
pub const PFN_D3D11ON12_CREATE_DEVICE = fn(
param0: ?*IUnknown,
param1: u32,
param2: ?[*]const D3D_FEATURE_LEVEL,
F... | win32/graphics/direct3d11on12.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "RENDER", .global_id = 0 };
pub const PictType = extern enum(c_uint) {
@"Indexed" = 0,
@"Direct" = 1,
};
pub const Picture = extern enum(c_uint) {
@"None" = 0,
};
pub const PictOp = extern enum(c_uint) {
@"Clear" = 0,
@"Sr... | src/auto/render.zig |
const os = @import("root").os;
const paging_common = @import("../paging.zig");
const std = @import("std");
pub const page_sizes =
[_]u64 {
0x1000, // 4K << 0
0x4000, // 16K << 0
0x10000, // 32K << 0
0x200000, // 4K << 9
0x2000000, // 16K << 11
0x10000000, // 32K << 12
0x40000000, // 4K <... | src/platform/aarch64/paging.zig |
const std = @import("std");
const crypto = std.crypto;
const math = std.math;
const mem = std.mem;
const rand = std.rand;
const testing = std.testing;
const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const min_inc: u63 = 33;
const max_inc: u63 = 333;
const base: u6 = 62;
const max_seq: u... | src/nuid.zig |
const std = @import("std");
const array = @import("array.zig");
const Array = array.Array;
const DType = array.DType;
const reference_counter = @import("reference_counter.zig");
const ReferenceCounter = reference_counter.ReferenceCounter;
pub const NO_FLAGS = 0;
pub const REQUIRES_GRAD = 1;
pub const IS_BRA... | src/tensor.zig |
const std = @import("std");
const builtin = std.builtin;
const crypto = std.crypto;
const mem = std.mem;
const meta = std.meta;
const EncodingError = crypto.errors.EncodingError;
const IdentityElementError = crypto.errors.IdentityElementError;
const NonCanonicalError = crypto.errors.NonCanonicalError;
const NotSquareE... | lib/std/crypto/pcurves/p256.zig |