code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const os = @import("windows.zig");
const HRESULT = os.HRESULT;
pub const Rect = extern struct {
X: c_int,
Y: c_int,
Width: c_int,
Height: c_int,
};
pub const DecodeOptions = extern enum {
MetadataCacheOnDemand = 0,
MetadataCacheOnLoad = 0x1,
};
pub const BitmapPale... | src/windows/wincodec.zig |
const std = @import("std");
const c = @import("c.zig");
const git = @import("../git.zig");
pub fn blobFilterOptions(self: git.BlobFilterOptions) c.git_blob_filter_options {
return .{
.version = c.GIT_BLOB_FILTER_OPTIONS_VERSION,
.flags = @bitCast(u32, self.flags),
.commit_id = @ptrCast(?*c... | src/internal/make_c_option.zig |
const std = @import("std");
const ascii = std.ascii;
const mem = std.mem;
const os = std.os;
const expect = std.testing.expect;
/// Parsed option struct.
pub const Option = struct {
/// Option character.
opt: u8,
/// Option argument, if any.
arg: ?[]const u8 = null,
};
pub const Error = error{ Invali... | getopt.zig |
const std = @import("std");
pub const csi = "\x1b[";
/// Sequence to set foreground color using 256 colors table
pub const fg_256 = "38;5;";
/// Sequence to set foreground color using 256 colors table
pub const bg_256 = "48;5;";
/// Sequence to set foreground color using 256 colors table
pub const fg_rgb = "38;2;";... | src/utils.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const Tag = std.meta.Tag;
const Foo = union {
float: f64,
int: i32,
};
test "basic unions" {
var foo = Foo{ .int = 1 };
try expect(foo.int == 1);
foo = Foo{ .float = 12.34 };
try expect(... | test/behavior/union.zig |
const kernel = @import("../../kernel.zig");
const Physical = kernel.arch.Physical;
const TODO = kernel.TODO;
const log = kernel.log.scoped(.memory_map);
var available: BootloaderMemoryRegionGroup = undefined;
var reserved: BootloaderMemoryRegionGroup = undefined;
pub const BootloaderMemoryRegionGroup = struct {
a... | src/kernel/arch/riscv64/memory_map.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gzip = std.compress.gzip;
const Fs = @import("Fs.zig");
const DatasetAttributes = @import("dataset_attributes.zig").DatasetAttributes;
const CompressionType = @import("dataset_attributes.zig").CompressionType;
const util = @import("util.zig");
const... | src/datablock.zig |
const RuleSet = @import("./rules.zig").RuleSet;
const Rule = @import("./rules.zig").Rule;
const Attr = @import("./rules.zig").Attr;
pub const rules = RuleSet{
.rules = &[_]Rule{
Rule{
.kind = 0, // drab tan
.attrs = &[_]Attr{
Attr{ .kind = 1, .n = 4 }, // clear gold
... | day7/src/input_rules.zig |
const std = @import("std");
usingnamespace std.os.windows;
const DynLib = std.DynLib;
pub const ERROR_DEVICE_NOT_CONNECTED = 1167;
pub const XUSER_MAX_COUNT = 4;
pub const XINPUT_GAMEPAD = extern struct {
wButtons: WORD,
bLeftTrigger: BYTE,
bRightTrigger: BYTE,
sThumbLX: SHORT,
sThumbLY: SHORT,
... | src/xinput.zig |
const std = @import("std");
const mem = std.mem;
const json = std.json;
const testing = std.testing;
const assert = std.debug.assert;
const testUtil = @import("util.zig");
const log = @import("../src/md/log.zig");
const Token = @import("../src/md/token.zig").Token;
const TokenId = @import("../src/md/token.zig").Token... | test/section_tabs.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "XKEYBOARD", .global_id = 0 };
pub const Const = extern enum(c_uint) {
@"MaxLegalKeyCode" = 255,
@"PerKeyBitArraySize" = 32,
@"KeyNameLength" = 4,
};
pub const EventType = extern enum(c_uint) {
@"NewKeyboardNotify" = 1,
@"M... | src/auto/xkb.zig |
const uefi = @import("std").os.uefi;
const fmt = @import("std").fmt;
const console = @import("./console.zig");
const runtime = @import("./uefi_runtime.zig");
const load_kernel_image = @import("./loader.zig").load_kernel_image;
pub var boot_services: *uefi.tables.BootServices = undefined;
pub var runtime_services: *ru... | bootstrap/uefi_bootstrap.zig |
const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const wren = @import("./wren.zig");
const wrappers = @import("./c_wrappers.zig");
const WrenError = @import("./error.zig").WrenError;
const Handle = @import("./handle.zig").Handle;
const Receiver = @import("./call.zig").R... | src/zapata/vm.zig |
const Buffer = @import("Buffer.zig");
const Sampler = @import("Sampler.zig");
const Texture = @import("Texture.zig");
const TextureView = @import("TextureView.zig");
const StorageTextureBindingLayout = @import("structs.zig").StorageTextureBindingLayout;
const StorageTextureAccess = @import("enums.zig").StorageTextureAc... | gpu/src/BindGroupLayout.zig |
const std = @import("std");
const builtin = @import("builtin");
fn add_module(comptime module: []const u8, b: *std.build.Builder, target: std.zig.CrossTarget) !*std.build.Step {
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSma... | examples/build.zig |
const aoc = @import("../aoc.zig");
const std = @import("std");
const TileMap = struct {
range: aoc.CoordRange = aoc.CoordRange.init(),
unprocessed_tiles: std.ArrayList(Tile),
queue: std.ArrayList(aoc.Coord),
tile_map: std.AutoHashMap(aoc.Coord, Tile),
fn init(allocator: std.mem.Allocator) TileMap ... | src/main/zig/2020/day20.zig |
const builtin = @import("builtin");
const assertOrPanic = @import("std").debug.assertOrPanic;
test "@sizeOf and @typeOf" {
const y: @typeOf(x) = 120;
assertOrPanic(@sizeOf(@typeOf(y)) == 2);
}
const x: u16 = 13;
const z: @typeOf(x) = 19;
const A = struct {
a: u8,
b: u32,
c: u8,
d: u3,
e: u... | test/stage1/behavior/sizeof_and_typeof.zig |
const std = @import("std");
const testing = std.testing;
const fmt = std.fmt;
const rand = std.rand;
const mem = std.mem;
const Allocator = std.mem.Allocator;
pub fn concat(allocator: *Allocator, bufs: []const []const u8) []const u8 {
if (std.mem.concat(allocator, u8, bufs)) |concated| {
return concated;
... | src/util.zig |
pub const DIRECTDRAW_VERSION = @as(u32, 1792);
pub const _FACDD = @as(u32, 2166);
pub const CLSID_DirectDraw = Guid.initString("d7b70ee0-4340-11cf-b063-0020afc2cd35");
pub const CLSID_DirectDraw7 = Guid.initString("3c305196-50db-11d3-9cfe-00c04fd930c5");
pub const CLSID_DirectDrawClipper = Guid.initString("593817a0-7db... | win32/graphics/direct_draw.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("../config.zig");
const vsr = @import("../vsr.zig");
const Header = vsr.Header;
const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
const Message = @import("../message_pool.zig").MessagePool.Message;
con... | src/vsr/client.zig |
const std = @import("std");
const c = @cImport({
@cInclude("termios.h");
@cInclude("unistd.h");
@cInclude("stdlib.h");
@cInclude("ctype.h");
@cInclude("sys/ioctl.h");
});
var orig_termios: c.struct_termios = undefined;
fn disableRawMode() void {
if (c.tcsetattr(c.STDIN_FILENO, c.TCSAFLUSH, &o... | libterm.zig |
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// Character output devices
pub const SimpleTextOutputProtocol = extern struct {
_reset: extern fn (*const SimpleTextOutputProtocol, bool) usize,
_output_string: extern fn (*const SimpleTextOutputProtocol, [*:0]const u16) usize,
_test_string: ex... | lib/std/os/uefi/protocols/simple_text_output_protocol.zig |
const std = @import("std");
const StringHashMap = std.StringHashMap;
const Allocator = std.mem.Allocator;
const FnMeta = std.builtin.TypeInfo.Fn;
const FnDecl = std.builtin.TypeInfo.Declaration.Data.FnDecl;
const StructMeta = std.builtin.TypeInfo.Struct;
const EnumMeta = std.builtin.TypeInfo.Enum;
const UnionMeta = std... | src/generators/ordered.zig |
usingnamespace @import("bits.zig");
pub extern "NtDll" fn RtlGetVersion(
lpVersionInformation: PRTL_OSVERSIONINFOW,
) callconv(WINAPI) NTSTATUS;
pub extern "NtDll" fn RtlCaptureStackBackTrace(
FramesToSkip: DWORD,
FramesToCapture: DWORD,
BackTrace: **c_void,
BackTraceHash: ?*DWORD,
) callconv(WINAP... | lib/std/os/windows/ntdll.zig |
const std = @import("std");
const super = @import("../index.zig");
const native = @import("../native.zig");
const HGLRC = HANDLE;
const PROC = *@OpaqueType();
const GLenum = u32;
const GLboolean = bool;
const GLbitfield = u32;
const GLbyte = i8;
const GLshort = i16;
const GLint = i32;
const GLsizei = i32;
const GLu... | src/app/windows/backend/opengl.zig |
const std = @import("std");
const io = std.io;
const testing = std.testing;
// This matches std.io.bufferedReader's buffer size
pub const default_buffer_size = 4096;
pub const DefaultBufferedStreamSource = BufferedStreamSource(default_buffer_size);
/// A reader-only version of std.io.StreamSource that provides a seek... | src/buffered_stream_source.zig |
const std = @import("std");
const logger = @import("logger.zig");
const metadata = @import("metadata.zig");
const install = @import("install.zig");
const MetaStruct = metadata.MetaStruct;
pub fn do_maint(args: [][]u8, install_dir: []const u8) !void {
if (args.len < 1) {
logger.warn("No sub-command provid... | src/maintenance.zig |
const std = @import("std");
const os = @import("windows.zig");
pub const SAMPLE_DESC = extern struct {
Count: u32 = 1,
Quality: u32 = 0,
};
pub const FORMAT = extern enum {
UNKNOWN = 0,
R32G32B32A32_TYPELESS = 1,
R32G32B32A32_FLOAT = 2,
R32G32B32A32_UINT = 3,
R32G32B32A32_SINT = 4,
R32... | src/windows/dxgi.zig |
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const Event = uefi.Event;
const Status = uefi.Status;
const MacAddress = uefi.protocols.MacAddress;
const ManagedNetworkConfigData = uefi.protocols.ManagedNetworkConfigData;
const SimpleNetworkMode = uefi.protocols.SimpleNetworkMode;
pub const Ip6Protocol = ... | lib/std/os/uefi/protocols/ip6_protocol.zig |
const std = @import("std");
const assert = std.debug.assert;
const Token = @import("zig_grammar.tokens.zig").Token;
pub const TokenIndex = *Token;
pub const NodeList = std.ArrayList(*Node);
pub const TokenList = std.ArrayList(*Token);
pub const Node = struct {
id: Id,
pub const Id = enum {
// Top le... | zig/zig_grammar.types.zig |
const std = @import("std");
const common = @import("./_common.zig");
pub const default = common.Main(struct {
pub const source_url = "https://unicode.org/Public/UCD/latest/ucd/ArabicShaping.txt";
pub const dest_file = "src/arabic_shaping.zig";
pub const dest_header =
\\pub const Shaping = struct ... | scripts/arabic_shaping.zig |
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const dbgLog_ = @import("Log.zig").dbgLog;
const HTTPMessageParser = @import("HTTPMessageParser.zig");
const parse = @import("Parse.zig");
const Files = @import("Files.zig");
const TCPServer = @import("TCPServer.zig");
const TLSCo... | src/HTTPRequestHandler.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day19.txt");
pub fn main() !void {
var timer = try std.time.Timer.start();
var scanners = try calculateScanners(data);
defer { deinitScanners(scanners); }
print(... | src/day19.zig |
usingnamespace @import("psptypes.zig");
const enum_unnamed_5 = extern enum(c_int) {
PSP_HTTP_VERSION_1_0,
PSP_HTTP_VERSION_1_1,
_,
};
pub const PspHttpHttpVersion = enum_unnamed_5;
const enum_unnamed_6 = extern enum(c_int) {
PSP_HTTP_METHOD_GET,
PSP_HTTP_METHOD_POST,
PSP_HTTP_METHOD_HEAD,
... | src/psp/sdk/psphttp.zig |
const Self = @This();
const std = @import("std");
const gpa = std.heap.c_allocator;
const View = @import("View.zig");
const Output = @import("Output.zig");
const c = @import("c.zig");
const wl = @import("wayland").server.wl;
const wlr = @import("wlroots");
const default_cursor_size = 24;
const default_seat_name = ... | herb/Server.zig |
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
const c = @import("c.zig").c;
const Image = @This();
/// The width of this image, in pixels.
width: u32,
/// The height of this image, in pixels.
height: u32,
/// The pixel data of this image, arranged left-to-right, top-to-bottom.
pixel... | glfw/src/Image.zig |
const std = @import("std");
const imgui = @import("imgui");
const impl_glfw = @import("imgui_impl_glfw.zig");
const impl_gl3 = @import("imgui_impl_opengl3.zig");
const glfw = @import("include/glfw.zig");
const gl = @import("include/gl.zig");
const is_darwin = switch (std.builtin.os.tag) {
.macosx, .ios, .watchos,... | examples/example_glfw_opengl3.zig |
const std = @import("std");
const expect = std.testing.expect;
const expectError = std.testing.expectError;
const print = std.debug.print;
pub const Error = error{
NotExhaustiveEnumError,
ParseError,
};
/// Get a parser function for the exhaustive enum E.
pub fn EnumParser(comptime E: type) Error!(fn ([]const... | src/enum_parser.zig |
const Span = @import("basics.zig").Span;
const ConstantOrBuffer = @import("trigger.zig").ConstantOrBuffer;
const fc32bit: f32 = 1 << 32;
inline fn clamp01(v: f32) f32 {
return if (v < 0.0) 0.0 else if (v > 1.0) 1.0 else v;
}
// 32-bit value into float with 23 bits precision
inline fn utof23(x: u32) f32 {
re... | src/zang/mod_pulseosc.zig |
const c = @import("gl");
const std = @import("std");
const zalgebra = @import("zalgebra");
const Thread = std.Thread;
const Allocator = std.mem.Allocator;
const Window = @import("didot-window").Window;
// TODO: get rid of that
const windowContextLock = @import("didot-window").windowContextLock;
const windowContextUnl... | didot-opengl/graphics.zig |
//--------------------------------------------------------------------------------
// Section: Types (31)
//--------------------------------------------------------------------------------
pub const PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT = isize;
pub const PRJ_DIR_ENTRY_BUFFER_HANDLE = isize;
pub const PRJ_NOTIFY_TYPE... | win32/storage/projected_file_system.zig |
pub const UI_ALL_COMMANDS = @as(u32, 0);
pub const UI_COLLECTION_INVALIDINDEX = @as(u32, 4294967295);
pub const LIBID_UIRibbon = Guid.initString("942f35c2-e83b-45ef-b085-ac295dd63d5b");
//--------------------------------------------------------------------------------
// Section: Types (33)
//-------------------------... | win32/ui/ribbon.zig |
const std = @import("std");
const testing = std.testing;
pub const Encoder = struct {
const Self = @This();
buffer: []const u8,
index: ?usize,
bit_off: u3,
/// Init the encoder.
pub fn init(buffer: []const u8) Encoder {
return .{
.buffer = buffer,
.index = 0,
... | src/base32.zig |
const std = @import("std");
const mem = std.mem;
const Compare = mem.Compare;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
fn nextPowerOf2(x: usize) usize {
if (x == 0) return 1;
var result = x -% 1;
result = switch (@sizeOf(usize)) {
8 => result | (result >> 32),
4 =>... | src/index.zig |
const vk = @import("vulkan.zig");
usingnamespace @import("vez-l1.zig");
pub const struct_Swapchain_T = opaque {};
pub const Swapchain = ?*struct_Swapchain_T;
pub const struct_Pipeline_T = opaque {};
pub const Pipeline = ?*struct_Pipeline_T;
pub const struct_Framebuffer_T = opaque {};
pub const Framebuffer = ?*struct_... | src/lib/vez.zig |
const std = @import("std");
pub const Signal = enum {
/// Hangup detected on controlling terminal or death of controlling process
hup = 1,
/// Interrupt from keyboard
int = 2,
/// Quit from keyboard
quit = 3,
/// Illegal Instruction
ill = 4,
/// Trace/breakpoint trap
trap = ... | src/types.zig |
const Print = @This();
const std = @import("std");
const assert = std.debug.assert;
const bits = @import("bits.zig");
const leb128 = std.leb;
const link = @import("../../link.zig");
const log = std.log.scoped(.codegen);
const math = std.math;
const mem = std.mem;
const Air = @import("../../Air.zig");
const DebugInfo... | src/arch/x86_64/PrintMir.zig |
const build_options = @import("build_options");
const std = @import("std");
const heap = std.heap;
const io = std.io;
const log = std.log;
const mem = std.mem;
const net = std.net;
const FrameHeader = @import("frame.zig").FrameHeader;
const FrameFlags = @import("frame.zig").FrameFlags;
const RawFrame = @import("frame.... | src/connection.zig |
const std = @import("std");
const nvg = @import("nanovg");
const gui = @import("gui.zig");
const event = @import("event.zig");
const Point = @import("geometry.zig").Point;
const Window = @This();
allocator: std.mem.Allocator,
application: *gui.Application,
id: u32,
width: f32,
height: f32,
is_modal: bool = false,
... | src/gui/Window.zig |
const std = @import("std");
const Cpu = @import("cpu.zig").Cpu;
const Precision = @import("console.zig").Precision;
pub fn Addressing(comptime precision: Precision) type {
return switch (precision) {
.fast => enum {
accumulator,
absolute,
absoluteX,
absoluteY... | src/instruction.zig |
const std = @import("std");
const string = []const u8;
const input = @embedFile("../input/day12.txt");
const List = std.ArrayList(string);
const Map = std.StringHashMap(List);
pub fn main() !void {
//
// part 1
{
var iter = std.mem.split(u8, input, "\n");
var arena = std.heap.ArenaAlloc... | src/day12.zig |
const std = @import("std");
const os = std.os;
const Buffer = @import("Buffer.zig");
const WireConnection = @This();
socket: std.net.Stream,
in: Buffer,
out: Buffer,
pub fn init(socket: std.net.Stream) WireConnection {
return .{
.socket = socket,
.in = Buffer.init(),
.out = Buffer.init(),... | src/common/WireConnection.zig |
const std = @import("std");
const expect = std.testing.expect;
const test_allocator = std.testing.allocator;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = &gpa.allocator;
var file = try std.fs.cwd().openFile("input.txt", .{});
d... | day01/src/main.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = std.builtin;
const crypto = std.crypto;
const mem = std.mem;
const StringifyOptions = std.json.StringifyOptions;
pub const config = @import("config.zig");
pub const Account = packed struct {
id: u128,
custom: u128,
flags: Account... | src/tigerbeetle.zig |
const std = @import("std");
// dross-zig
const Vector2 = @import("../core/vector2.zig").Vector2;
const TextureRegion = @import("../renderer/texture_region.zig").TextureRegion;
const Frame2d = @import("frame_2d.zig").Frame2d;
const Animation2d = @import("animation_2d.zig").Animation2d;
const Renderer = @import("re... | src/animation/animator_2d.zig |
const std = @import("std");
const unicode = @import("unicode");
const mem = std.mem;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
pub const FOLD_CASE: u16 = 1; // case-insensitive match
pub const LITERAL: u16 = 2; // treat pattern as literal string
pub const CLASS_NL: u16 = 4; // allow character ... | src/regexp/syntax/syntax.zig |
const builtin = @import("builtin");
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const testing = std.testing;
const native_endian = builtin.target.cpu.arch.endian();
pub const li128 = Int(i128, .Little);
pub const li16 = Int(i16, .Little);
pub const li32 = Int(i32, .Little);
pub const li... | src/core/rom/int.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day07.txt");
pub fn main() !void {
var timer = try std.time.Timer.start();
var crabs = std.ArrayList(u16).init(gpa);
defer { crabs.deinit(); }
var iterator = s... | src/day07.zig |
const std = @import("std");
const math = std.math;
const meta = std.meta;
pub fn formatInt(value: anytype, writer: anytype) @TypeOf(writer).Error!void {
comptime std.debug.assert(meta.trait.isIntegral(@TypeOf(value)));
const Int = switch (@typeInfo(@TypeOf(value))) {
.Int => @TypeOf(value),
.... | src/ser/impl/formatter/details/fmt.zig |
const std = @import("../std.zig");
const mem = std.mem;
const testing = std.testing;
/// Compares two arrays in constant time (for a given length) and returns whether they are equal.
/// This function was designed to compare short cryptographic secrets (MACs, signatures).
/// For all other applications, use mem.eql() ... | lib/std/crypto/utils.zig |
const std = @import("../index.zig");
const math = std.math;
const assert = std.debug.assert;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typeOf(x).bit_count / 2) else @typeOf(x)) {
const T = @typeOf(x);
switch ... | std/math/sqrt.zig |
const Emit = @This();
const std = @import("std");
const Mir = @import("Mir.zig");
const link = @import("../../link.zig");
const Module = @import("../../Module.zig");
const leb128 = std.leb;
/// Contains our list of instructions
mir: Mir,
/// Reference to the file handler
bin_file: *link.File,
/// Possible error messa... | src/arch/wasm/Emit.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const ArrayListUnmanaged = std.ArrayListUnmanaged;
const File = std.fs.File;
const bufferedWriter = std.io.bufferedWriter;
const math = std.math;
const Linenoise = @import("main.zig").Linenoise;
const History = @import("h... | src/state.zig |
const std = @import("std");
const fs = std.fs;
const mem = std.mem;
const ascii = std.ascii;
const log = std.log;
const web = @import("zhp.zig");
const responses = web.responses;
const Datetime = web.datetime.Datetime;
pub var default_stylesheet = @embedFile("templates/style.css");
pub const IndexHandler = struct {
... | src/handlers.zig |
const std = @import("std");
const clap = @import("clap");
const Uuid = @import("uuid");
pub fn main() anyerror!void {
const stderr = std.io.getStdErr().writer();
const stdout = std.io.getStdOut().writer();
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer if (gpa.deinit()) std.fmt.format(stderr... | examples/bench/src/main.zig |
const sf = @import("../sfml.zig");
const VertexBuffer = @This();
pub const Usage = enum(c_uint) {
Static = 0,
Dynamic = 1,
Stream = 2
};
// Constructors/destructors
/// Creates a vertex buffer of a given size. Specify its usage and the primitive type.
pub fn createFromSlice(vertices: []const sf.graphic... | src/sfml/graphics/VertexBuffer.zig |
const std = @import("std");
const util = @import("aoc_util");
const print = std.debug.print;
const fmt = std.fmt;
const mem = std.mem;
const DiagProperties = struct{
entries: u32,
gamma: u32,
epsilon: u32,
heatmap: [12]u32 = [12]u32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
};
const SubDiag = struct{
p... | src/day-03/binary-diag.zig |
const std = @import("std");
const math = @import("std").math;
const fs = @import("std").fs;
const io = @import("std").io;
const rand = @import("std").rand;
const warn = @import("std").debug.warn;
const c_allocator = @import("std").heap.c_allocator;
//float_type ft
const ft = f64;
fn Vec(comptime T: type) type {
r... | src/main.zig |
extern "c" fn __error() *c_int;
pub const _errno = __error;
pub extern "c" fn kqueue() c_int;
pub extern "c" fn kevent(
kq: c_int,
changelist: [*]const Kevent,
nchanges: c_int,
eventlist: [*]Kevent,
nevents: c_int,
timeout: ?*const timespec,
) c_int;
pub extern "c" fn sysctl(name: [*]c_int, nam... | std/c/freebsd.zig |
const std = @import("std");
const process = std.process;
const Allocator = std.mem.Allocator;
pub fn resolveExePath(allocator: *Allocator) ![]const u8 {
const args = try std.process.argsAlloc(allocator);
defer process.argsFree(allocator, args);
// std.debug.print("args[{}]={}\n", .{0, args[0]});
const ... | src/util.zig |
const std = @import("std");
const dbg = std.debug.print;
const c = @cImport({
@cInclude("uv.h");
});
const mpack = @import("./mpack.zig");
fn zero(val: c_int) !void {
if (val != 0) {
dbg("the cow jumped over the moon: {}\n", .{val});
return error.TheCowJumpedOverTheMoon;
}
}
fn nonneg(val:... | src/io_uv.zig |
const std = @import("std");
const eq = std.mem.eql;
const print = std.fmt.bufPrint;
const util = @import("./util.zig");
const sh = @import("./sh.zig");
const ast = @import("./lang/ast.zig");
const Ast = ast.Ast;
const token = @import("./lang/token.zig");
const Token = token.Token;
const lexer = @import("./lang/lexer.zi... | src/cli.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 int = i64;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../dat... | src/day16.zig |
usingnamespace @import("root").preamble;
pub fn alignDown(comptime t: type, alignment: t, value: t) t {
return value - (value % alignment);
}
pub fn alignUp(comptime t: type, alignment: t, value: t) t {
return alignDown(t, alignment, value + alignment - 1);
}
pub fn isAligned(comptime t: type, alignment: t, ... | lib/util/libalign.zig |
pub const WSMAN_FLAG_REQUESTED_API_VERSION_1_0 = @as(u32, 0);
pub const WSMAN_FLAG_REQUESTED_API_VERSION_1_1 = @as(u32, 1);
pub const WSMAN_OPERATION_INFOV1 = @as(u32, 0);
pub const WSMAN_OPERATION_INFOV2 = @as(u32, 2864434397);
pub const WSMAN_DEFAULT_TIMEOUT_MS = @as(u32, 60000);
pub const WSMAN_FLAG_RECEIVE_RESULT_N... | deps/zigwin32/win32/system/remote_management.zig |
const format = @import("std").fmt.format;
const OutStream = @import("std").io.OutStream;
const regs = struct {
fn bit(comptime n: u32) u8 {
return 1 << n;
}
const DATA: usize = 0x00;
const STATE: usize = 0x04;
const STATE_TX_FULL: u8 = bit(0);
const STATE_RX_FULL: u8 = bit(1);
con... | examples/drivers/pl011.zig |
const std = @import("std");
const ascii = std.ascii;
pub const FieldFlagsDef = struct {
field: []const u8,
flags: []const u8,
};
pub const FieldFlagsMask = struct {
field: []const u8,
mask: u8,
};
pub const FieldFlags = struct {
/// For disambiguation in case 2 fields share a flag char
field:... | src/flags.zig |
const std = @import("std");
const input = @import("input.zig");
pub fn run(allocator: std.mem.Allocator, stdout: anytype) anyerror!void {
var input_ = try input.readFile("inputs/day12");
defer input_.deinit();
const input_parsed = try Input.init(allocator, &input_);
{
const result = try part... | src/day12.zig |
const std = @import("std");
const builtin = @import("builtin");
const Buffer = std.Buffer;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const warn = std.debug.warn;
/// Top Level
pub const Device = struct {
name: Buffer,
version: Buffer,
description: Buffer,
cpu: ?Cpu,
///... | src/svd.zig |
const std = @import("std");
const help = @import("./helpers.zig");
const EscapeCodes = struct {
const smcup = "\x1b[?1049h\x1b[22;0;0t\x1b[2J\x1b[H";
const rmcup = "\x1b[2J\x1b[H\x1b[?1049l\x1b[23;0;0t";
};
fn print(msg: []const u8) !void {
try std.io.getStdOut().writer().print("{}", .{msg});
}
/// enter... | src/cli.zig |
const std = @import("std");
const atomic = std.atomic;
const mem = std.mem;
const testing = std.testing;
/// Create a new Zighlander to manage a singleton of type T.
pub fn Zighlander(comptime T: type) type {
return struct {
const Self = @This();
const Singleton = struct {
instance: *... | src/zighlander.zig |
const std = @import("std");
usingnamespace std.os.windows;
pub extern "kernel32" fn VirtualAllocEx(
hProcess: HANDLE,
lpAddress: ?LPVOID,
dwSize: SIZE_T,
flAllocationTypew: DWORD,
flProtect: DWORD,
) callconv(WINAPI) ?LPVOID;
pub extern "kernel32" fn VirtualFreeEx(
hProcess: HANDLE,
lpAddr... | externs.zig |
const std = @import("std");
const assert = std.debug.assert;
const log = std.log;
const mem = std.mem;
const tokenizer = @import("tokenizer.zig");
const Allocator = mem.Allocator;
const TokenIndex = tokenizer.TokenIndex;
const TokenIterator = tokenizer.TokenIterator;
const Tokenizer = tokenizer.Tokenizer;
const Token ... | src/parser.zig |
const std = @import("std");
const os = std.os;
const net = std.net;
const Allocator = std.mem.Allocator;
const RESP3 = @import("./parser.zig").RESP3Parser;
const CommandSerializer = @import("./serializer.zig").CommandSerializer;
const OrErr = @import("./types/error.zig").OrErr;
pub const Buffering = union(enum) {
... | src/client.zig |
usingnamespace @import("root").preamble;
/// IPC message
pub const Message = packed struct {
/// Opaque value
opaque_val: usize,
/// Message data
data: [56]u8,
/// Encode reference to the token
fn encodeTokenToOpaque(self: *@This(), token: *Token) void {
self.opaque_val = @ptrToInt(tok... | subprojects/flork/src/kepler/ipc.zig |
const std = @import("std");
const print = std.debug.print;
const ArgParser = @import("arg_parser.zig").ArgParser;
const Strand = @import("search.zig").Strand;
const Mode = enum {
dna,
protein,
};
pub const Args = struct {
query: [std.fs.MAX_PATH_BYTES:0]u8 = undefined,
db: [std.fs.MAX_PATH_BYTES:0]u8... | src/args.zig |
const std = @import("std");
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
var global_allocator = gpa.allocator();
var buffer: [1024]u8 = undefined;
var fixed_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
var allocator = fixed_allocator.allocator();
pub fn main() !void {
const stdout = std.io... | bench/algorithm/fannkuch-redux/1.zig |
const std = @import("../../std.zig");
const maxInt = std.math.maxInt;
const linux = std.os.linux;
const SYS = linux.SYS;
const iovec = std.os.iovec;
const iovec_const = std.os.iovec_const;
const socklen_t = linux.socklen_t;
const stack_t = linux.stack_t;
const sigset_t = linux.sigset_t;
const uid_t = linux.uid_t;
const... | lib/std/os/linux/arm-eabi.zig |
const std = @import("std");
const Object = @import("value.zig").Object;
const String = @import("value.zig").String;
const Value = @import("value.zig").Value;
const vm = @import("vm.zig").vm;
const Data = union(enum) {
junked: void,
string: *String,
object: *Object,
};
pub const HeapId = usize;
pub con... | src/gc.zig |
const std = @import("std");
const print = std.debug.print;
const Op = enum {
AND,
OR,
LSHIFT,
RSHIFT,
NOT,
};
const Wire = union(enum) {
name: [2]u8,
constant: u16,
};
const Gate = struct {
operands: [2]Wire,
operand_count: u8,
op: ?Op,
};
pub fn main() anyerror!void {
co... | src/day07.zig |
usingnamespace @import("ncurses").ncurses;
const WIN_BORDER = struct {
ls: chtype,
rs: chtype,
ts: chtype,
bs: chtype,
tl: chtype,
tr: chtype,
bl: chtype,
br: chtype,
};
const WIN = struct {
startx: c_int,
starty: c_int,
height: c_int,
width: c_int,
border: WIN_BORD... | examples/borders.zig |
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const assertError = std.debug.assertError;
const mem = std.mem;
const Allocator = mem.Allocator;
const Error = Allocator.Error;
pub const Seal = struct {
allocator: Allocator,
wrapped_allocator: *Allocator,
cou... | seal.zig |
const std = @import("std");
const cop0 = @import("cop0.zig");
const MIReg = enum(u64) {
MIVersion = 0x4,
MIInterrupt = 0x8,
MIMask = 0xC,
};
pub const InterruptSource = enum(u6) {
SP = 1 << 0,
SI = 1 << 1,
AI = 1 << 2,
VI = 1 << 3,
PI = 1 << 4,
DP = 1 << 5,
};
var miVersi... | src/core/mi.zig |
const std = @import("std");
const fifo = std.fifo;
const Client = @import("../client.zig").Client;
const txrx = @import("txrx.zig");
const AutoHashMap = std.hash_map.AutoHashMap;
const LinearFifo = std.fifo.LinearFifo;
const LinearFifoBufferType = std.fifo.LinearFifoBufferType;
const FdBuffer = LinearFifo(i32, LinearFi... | src/wl/context.zig |
pub const env = @import("./env.zig");
pub const err = @import("./error.zig");
pub const http = @import("./http.zig");
pub const log = @import("./log.zig");
pub const random = @import("./random.zig");
pub const resource = @import("./resource.zig");
pub const time = @import("./time.zig");
pub const runtime = @import("./r... | zig/src/olin/olin.zig |
const windows = @import("windows.zig");
const IUnknown = windows.IUnknown;
const UINT = windows.UINT;
const WINAPI = windows.WINAPI;
const GUID = windows.GUID;
const HRESULT = windows.HRESULT;
const HINSTANCE = windows.HINSTANCE;
const SIZE_T = windows.SIZE_T;
const LPCSTR = windows.LPCSTR;
const FLOAT = windows.FLOAT;... | modules/platform/vendored/zwin32/src/d3d11.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const testing = std.testing;
const builtin = @import("builtin");
const is_debug = builtin.mode == .Debug;
const Entity = u32;
pub fn TypedEntities(comptime Archetype: type) type {
return struct {
allocator: Allocator,
... | ecs/src/main.zig |
const std = @import("std.zig");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const trait = meta.trait;
const autoHash = std.hash.autoHash;
const Wyhash = std.hash.Wyhash;
const Allocator = mem.Allocator;
const built... | lib/std/array_hash_map.zig |
const std = @import("std");
const mem = std.mem;
const OtherLetter = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 170,
hi: u21 = 201546,
pub fn init(allocator: *mem.Allocator) !OtherLetter {
var instance = OtherLetter{
.allocator = allocator,
.array = try allocator.alloc(bool, 20... | src/components/autogen/DerivedGeneralCategory/OtherLetter.zig |
const Package = @This();
const std = @import("std");
const fs = std.fs;
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const Compilation = @import("Compilation.zig");
const Module = @import("Module.zig");
pub const Table = std.StringHashMapUnmanaged(*Package);
root_src_direct... | src/Package.zig |