code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
const std = @import("std");
const Interpreter = @import("Interpreter.zig");
const utils = @import("utils.zig");
const zig_arg = @import("zig-arg");
const pga = std.heap.page_allocator;
const flag = zig_arg.flag;
const Command = zig_arg.Command;
const usage =
\\ Usage: zbfi [option]
\\
\\ Option:
\\ ... | src/main.zig |
const fun = @import("fun");
const std = @import("std");
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 scan = fun.scan.scan;
pub fn main() !void {
const stdin = &(try io.getStdIn()).inStream().stream;
const stdout = &(tr... | src/day3.zig |
const std = @import("std");
const mem = std.mem;
const warn = std.debug.warn;
const gallocator = std.heap.page_allocator;
pub fn Graph(comptime T: type) type {
return struct {
N: usize,
connected: usize,
root: ?*Node,
vertices: ?std.StringHashMap(*Node),
graph: ?std.AutoHash... | src/main.zig |
const std = @import("std");
const Arena = std.heap.ArenaAllocator;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
const yeti = @import("yeti");
const initCodebase = yeti.initCodebase;
const tokenize = yeti.tokenize;
const parse = yeti.parse;
const analyzeSemanti... | src/tests/test_strings.zig |
pub const EventType = enum(u8) {
Resize,
MouseMove,
MouseDown,
MouseUp,
MouseWheel,
TouchPan,
TouchZoom,
KeyDown,
KeyUp,
TextInput,
Focus,
Blur,
Enter,
Leave,
ClipboardUpdate,
};
pub const Event = struct {
type: EventType,
is_accepted: bool = true,
... | src/gui/event.zig |
pub const CCH_RM_SESSION_KEY = @as(u32, 32);
pub const CCH_RM_MAX_APP_NAME = @as(u32, 255);
pub const CCH_RM_MAX_SVC_NAME = @as(u32, 63);
pub const RM_INVALID_TS_SESSION = @as(i32, -1);
pub const RM_INVALID_PROCESS = @as(i32, -1);
//--------------------------------------------------------------------------------
// Se... | win32/system/restart_manager.zig |
const std = @import("std");
const alka = @import("alka");
const game = @import("game.zig");
usingnamespace alka.math;
usingnamespace alka.log;
const mlog = std.log.scoped(.app);
const gui = alka.gui;
const ecs = @import("ecs.zig");
const ButtonTextTag = enum {
score,
dash_counter,
menu,
play,
e... | examples/example_shooter_game/src/gui.zig |
const std = @import("std");
const stdx = @import("stdx");
const ds = stdx.ds;
const log = stdx.log.scoped(.work_queue);
const builtin = @import("builtin");
const uv = @import("uv");
const CsError = @import("runtime.zig").CsError;
pub const WorkQueue = struct {
const Self = @This();
alloc: std.mem.Allocator,
... | runtime/work_queue.zig |
const std = @import("std");
const stdx = @import("stdx");
const t = stdx.testing;
const log = stdx.log.scoped(.parser_manual_test);
const _parser = @import("parser.zig");
const Parser = _parser.Parser;
const DebugInfo = _parser.DebugInfo;
const ParseConfig = _parser.ParseConfig;
const _grammar = @import("grammar.zig")... | parser/parser_manual.test.zig |
const std = @import("std");
const builtin = @import("builtin");
const mem = std.mem;
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
test "call result of if else expression" {
try expect(mem.eql(u8, f2(true), "a"));
try expect(mem.eql(u8, f2(false), "b"));
}
fn f2(... | test/behavior/basic_llvm.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
pub fn build(b: *Builder) !void {
const fontconfig_cflags = try b.exec([][]const u8{ "pkg-config", "--cflags", "fontconfig" });
const freetype2_cflags = ... | build.zig |
const std = @import("std");
const kernel = @import("../../kernel.zig");
const Spinlock = kernel.arch.Spinlock;
// the UART control registers.
// some have different meanings for
// read vs write.
// http://byterunner.com/16550.html
const RHR = 0; // receive holding register (for input bytes)
const THR = 0; // transmi... | src/kernel/arch/riscv64/uart.zig |
const builtin = @import("builtin");
const std = @import("std");
const math = std.math;
const assert = std.debug.assert;
const testing = std.testing;
pub fn powci(comptime x: comptime_int, y: comptime_int) comptime_int {
return if (y == 0)
1
else switch (x) {
0 => 0,
1 => 1,
else... | src/powci.zig |
const std = @import("std");
const ArrayList = std.ArrayList;
const Builder = @import("std").build.Builder;
pub fn build(b: *Builder) !void {
const exe = b.addExecutable("BootX64", "src/kernel/main.zig");
exe.addAssemblyFile("src/kernel/arch/x86/platform.s");
exe.addAssemblyFile("src/kernel/arch/x86/vmem.s... | build.zig |
const std = @import("std");
const warn = std.debug.print;
const Allocator = std.mem.Allocator;
const config = @import("./config.zig");
const toot_lib = @import("./toot.zig");
const thread = @import("./thread.zig");
const guilib = @import("./gui/gtk.zig");
const GUIError = error{Init};
const Column = guilib.Column;
v... | src/gui.zig |
const builtin = @import("builtin");
const std = @import("std");
const Allocator = std.mem.Allocator;
const mustache = @import("mustache");
const TIMES = if (builtin.mode == .Debug) 10_000 else 1_000_000;
// Run tests on full featured mustache specs, or minimum settings for the use case
const full = true;
const feat... | benchmark/src/ramhorns_bench.zig |
const std = @import("std");
const stdx = @import("stdx");
const graphics = @import("graphics");
const Color = graphics.Color;
const log = stdx.log.scoped(.flex);
const ui = @import("../ui.zig");
const module = @import("../module.zig");
/// Lays out children vertically.
pub const Column = struct {
props: struct {... | ui/src/widgets/flex.zig |
const std = @import("std");
const mem = std.mem;
const meta = std.meta;
const c = std.c;
usingnamespace @import("c_api.zig");
const log = std.log.scoped(.zamqp);
pub const boolean_t = c_int;
pub const flags_t = u32;
pub const channel_t = u16;
pub const bytes_t = extern struct {
len: usize,
bytes: ?[*]const ... | src/zamqp.zig |
const std = @import("std");
const elf = std.elf;
pub const ds = @import("./ds.zig");
pub const funcs = @import("./funcs.zig");
const elfErrors = error{
CannotTellIfBinaryIs32or64bit,
};
pub const ELF = struct {
file: std.fs.File = undefined,
is32: bool = undefined,
address: usize = 0x400000,
ehdr: ... | src/elf.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... | win32/devices/display.zig |
const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Reactor = struct {
const BoxList = std.ArrayList(Box);
pub const Pos = struct {
x: isize,
y: isize,
z: isize,
pub fn init(x: isize, y: isize, z: isize) Pos {
... | 2021/p22/reactor.zig |
const std = @import("std");
const mem = std.mem;
const print = std.debug.print;
const render_utils = @import("render_utils.zig");
pub fn highlightZigCode(raw_src: []const u8, out: anytype) !void {
// TODO: who should be doing this cleanup?
const src = mem.trim(u8, raw_src, " \n");
try out.writeAll("<pre><c... | src/doctest/syntax.zig |
const std = @import( "std" );
const min = std.math.min;
const max = std.math.max;
const sqrt = std.math.sqrt;
const minInt = std.math.minInt;
const Atomic = std.atomic.Atomic;
const milliTimestamp = std.time.milliTimestamp;
usingnamespace @import( "core/util.zig" );
pub fn SimConfig( comptime N: usize, comptime P: usi... | src/sim.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Vec2 = tools.Vec2;
fn powerOfCell(p: Vec2, SN: u32) i32 {
const rackId = @intCast(u32, p.x + 10);
var pow = @intCast(u32, p.y) * rackId;
pow += SN;
pow *= rackId;
pow /= 100;
pow = pow % 10;
... | 2018/day11.zig |
const std = @import("std");
const testing = std.testing;
const meta = std.meta;
const trait = std.meta.trait;
const log = std.log.scoped(.wasmtime_zig);
pub const c = @import("c.zig");
var CALLBACK: usize = undefined;
// @TODO: Split these up into own error sets
pub const Error = error{
/// Failed to initialize ... | src/main.zig |
const std = @import("std");
const fs = std.fs;
const Answer = struct { gamma_rate: u32 = 0, epsilon_rate: u32 = 0, oxygen_rating: u32 = 0, co2_rating: u32 = 0 };
fn count_bits_in_line(counts: []u32, entry: u32, nbits: usize) !void {
var i: u5 = 0;
while (i < nbits) {
// FIXME: how to get i-th bit?
... | day3/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const testing = std.testing;
const input_file = "input03.txt";
const Square = enum {
open,
tree,
};
fn parseMap(allocator: *Allocator, map: []const u8) ![]const []const Square {
var result = std.ArrayList([]const Square).init(allocator);
... | src/03.zig |
const std = @import("std");
const util = @import("util.zig");
const testing = std.testing;
const mem = std.mem;
const net = std.net;
const LF = "\n";
const CRLF = "\r" ++ LF;
const WS = CRLF ++ " ";
const BUFFER_SIZE = 4 * 1024;
const DEFAULT_HEADERS = &[_]Header{};
const DEFAULT_BODY = "";
const DEFAULT_STATUS = 404;... | zepo.zig |
const std = @import("std");
const os = std.os;
const net = std.net;
const print = std.debug.print;
const builtin = std.builtin;
const Address = net.Address;
const router = @import("./router.zig");
const Error = error{UnknownPacket};
/// The definition on an IP packet header.
pub const IP4Hdr = packed struct {
v... | src/l3tun.zig |
usingnamespace @import("c.zig");
const Mutex = @import("std").Mutex;
const vertex_shader_source = @embedFile("shaders/vertex.glsl");
const fragment_shader_source = @embedFile("shaders/fragment.glsl");
/// Our texture quad
const vertices = &[_]GLfloat{
1, -1, 0.0, 1.0, 0.0, // bottom right
1, 1, 0.0, 1.0, 1... | src/texture.zig |
const std = @import("std");
const Location = @This();
source: ?[]const u8 = null,
line: u32,
column: u32,
pub fn min(a: Location, b: Location) Location {
if (a.source != null and b.source != null) {
if (!std.mem.eql(u8, a.source.?, b.source.?))
@panic("a and b must be from the same source fil... | src/Location.zig |
const std = @import("std");
const mem = std.mem;
const heap = std.heap;
const fmt = std.fmt;
const Allocator = std.mem.Allocator;
const fe310 = @import("target/soc/fe310-g002.zig");
const prci = fe310.prci;
const gpio = fe310.gpio;
const uart = fe310.uart;
const kmain = @import("main.zig").kmain;
extern var __data_s... | src/start.zig |
const std = @import("std");
const core = @import("../index.zig");
const Coord = core.geometry.Coord;
const Matrix = core.matrix.Matrix;
pub const Floor = enum {
unknown,
dirt,
marble,
lava,
hatch,
stairs_down,
};
pub const Wall = enum {
unknown,
air,
dirt,
stone,
centaur_tr... | src/core/protocol.zig |
const c = @cImport({
@cInclude("cfl_window.h");
});
const widget = @import("widget.zig");
const group = @import("group.zig");
const enums = @import("enums.zig");
pub const Window = struct {
inner: ?*c.Fl_Double_Window,
pub fn new(x: i32, y: i32, w: i32, h: i32, title: [*c]const u8) Window {
const p... | src/window.zig |
const getty = @import("getty");
const std = @import("std");
const escape = @import("impl/formatter/details/escape.zig").escape;
pub fn Serializer(comptime Writer: type, comptime Formatter: type) type {
return struct {
writer: Writer,
formatter: Formatter,
const Self = @This();
con... | src/ser/serializer.zig |
usingnamespace @import("bits.zig");
// PM
pub const PM_REMOVE = 0x0001;
pub const PM_NOREMOVE = 0x0000;
pub const PM_NOYIELD = 0x0002;
// WM
pub const WM_NULL = 0x0000;
pub const WM_CREATE = 0x0001;
pub const WM_DESTROY = 0x0002;
pub const WM_MOVE = 0x0003;
pub const WM_SIZE = 0x0005;
pub const WM_ACTIVATE = 0x0006;... | lib/std/os/windows/user32.zig |
const std = @import("../std.zig");
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
const WriteFileStep = build.WriteFileStep;
const LibExeObjStep = build.LibExeObjStep;
const CheckFileStep = build.CheckFileStep;
const fs = std.fs;
const mem = std.mem;
const CrossTarget = std.zig.CrossTa... | lib/std/build/translate_c.zig |
const Emit = @This();
const std = @import("std");
const assert = std.debug.assert;
const bits = @import("bits.zig");
const abi = @import("abi.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 testing = std.tes... | src/arch/x86_64/Emit.zig |
const std = @import("../std.zig");
const builtin = @import("builtin");
const root = @import("root");
const mem = std.mem;
pub const default_stack_size = 1 * 1024 * 1024;
pub const stack_size: usize = if (@hasDecl(root, "stack_size_std_io_OutStream"))
root.stack_size_std_io_OutStream
else
default_stack_size;
/... | lib/std/io/out_stream.zig |
usingnamespace @import("bits.zig");
pub const SOCKET = *@OpaqueType();
pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0));
pub const SOCKET_ERROR = -1;
pub const WSADESCRIPTION_LEN = 256;
pub const WSASYS_STATUS_LEN = 128;
pub const WSADATA = if (usize.bit_count == u64.bit_count)
extern struct {
... | lib/std/os/windows/ws2_32.zig |
const std = @import("std");
const assert = std.debug.assert;
const Sha256 = std.crypto.hash.sha2.Sha256;
const zephyr = @import("zephyr.zig");
const sys = @import("src/sys.zig");
const FlashArea = sys.flash.FlashArea;
// An open image.
pub const Image = struct {
const Self = @This();
id: u8,
header: Im... | image.zig |
const Window = @This();
const std = @import("std");
const xcb = @import("bindings.zig");
const Core = @import("Core.zig");
const types = @import("../main.zig");
core: *Core,
window: u32 = undefined,
width: u16,
height: u16,
pub fn init(core: *Core, info: types.WindowInfo) !*Window {
var self = try core.allocator... | src/xcb/Window.zig |
const Buffer = @import("Buffer.zig");
const Sampler = @import("Sampler.zig");
const Texture = @import("Texture.zig");
const TextureView = @import("TextureView.zig");
const ShaderModule = @import("ShaderModule.zig");
const QuerySet = @import("QuerySet.zig");
const StencilFaceState = @import("data.zig").StencilFaceState;... | gpu/src/structs.zig |
const std = @import("std");
const mem = std.mem;
const ChangesWhenUppercased = @This();
allocator: *mem.Allocator,
array: []bool,
lo: u21 = 97,
hi: u21 = 125251,
pub fn init(allocator: *mem.Allocator) !ChangesWhenUppercased {
var instance = ChangesWhenUppercased{
.allocator = allocator,
.array =... | src/components/autogen/DerivedCoreProperties/ChangesWhenUppercased.zig |
pub const WM_CONTEXTMENU = @as(u32, 123);
pub const WM_UNICHAR = @as(u32, 265);
pub const WM_PRINTCLIENT = @as(u32, 792);
pub const EM_CANPASTE = @as(u32, 1074);
pub const EM_DISPLAYBAND = @as(u32, 1075);
pub const EM_EXGETSEL = @as(u32, 1076);
pub const EM_EXLIMITTEXT = @as(u32, 1077);
pub const EM_EXLINEFROMCHAR = @a... | win32/ui/controls/rich_edit.zig |
pub const WTS_DOMAIN_LENGTH = @as(u32, 255);
pub const WTS_USERNAME_LENGTH = @as(u32, 255);
pub const WTS_PASSWORD_LENGTH = @as(u32, 255);
pub const WTS_DIRECTORY_LENGTH = @as(u32, 256);
pub const WTS_INITIALPROGRAM_LENGTH = @as(u32, 256);
pub const WTS_PROTOCOL_NAME_LENGTH = @as(u32, 8);
pub const WTS_DRIVER_NAME_LENG... | win32/system/remote_desktop.zig |
pub const EXTENDED_BIT = @as(u32, 16777216);
pub const DONTCARE_BIT = @as(u32, 33554432);
pub const FAKE_KEYSTROKE = @as(u32, 33554432);
pub const KBDBASE = @as(u32, 0);
pub const KBDSHIFT = @as(u32, 1);
pub const KBDCTRL = @as(u32, 2);
pub const KBDALT = @as(u32, 4);
pub const KBDKANA = @as(u32, 8);
pub const KBDROYA ... | win32/ui/input/keyboard_and_mouse.zig |
const std = @import("std");
const utils = @import("utils.zig");
const position_is_valid = utils.position_is_valid;
pub const PieceMove = struct {
score: i32, // 32 bits
action: Action,
pub fn move(from: Piece, x: i32, y: i32) @This() {
const action = Action{ .move = .{ .from = from, .to = from.mov... | src/board.zig |
const ImageReader = zigimg.ImageReader;
const ImageSeekStream = zigimg.ImageSeekStream;
const PixelFormat = zigimg.PixelFormat;
const assert = std.debug.assert;
const color = zigimg.color;
const errors = zigimg.errors;
const png = zigimg.png;
const std = @import("std");
const testing = std.testing;
const zigimg = @impo... | tests/formats/png_bkgd_test.zig |
const print = @import("std").debug.print;
pub fn main() void {
// The main() function can not be async. But we know
// getBeef() will not suspend with this particular
// invocation. Please make this okay:
var my_beef = nosuspend getBeef(0xDEAD);
print("beef? {X}!\n", .{my_beef});
}
fn getBeef(in... | exercises/090_async7.zig |
const std = @import("std");
const sdl = @import("sdl");
const gk = @import("gamekit.zig");
const math = gk.math;
pub const input_types = @import("input_types.zig");
pub usingnamespace input_types;
const FixedList = gk.utils.FixedList;
const released: u3 = 1; // true only the frame the key is released
const down: u3 =... | gamekit/input.zig |
const clap = @import("clap");
const format = @import("format");
const std = @import("std");
const ston = @import("ston");
const util = @import("util");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const os = std.o... | src/other/tm35-no-trade-evolutions.zig |
const utils = @import("utils");
const georgios = @import("georgios.zig");
const ErrorCode = enum(u32) {
Unknown = 1,
OutOfBounds = 2,
NotEnoughSource = 3,
NotEnoughDestination = 4,
OutOfMemory = 5,
ZeroSizedAlloc = 6,
InvalidFree = 7,
FileNotFound = 8,
NotADirectory = 9,
NotAFil... | libs/georgios/system_calls.zig |
const std = @import("std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const Order = std.math.Order;
pub fn Treap(comptime Key: type, comptime compareFn: anytype) type {
return struct {
const Self = @This();
// Allow for compareFn to be fn(anytype, anytype) anytype
/... | lib/std/treap.zig |
const std = @import("std");
const Endian = std.builtin.Endian;
const assert = std.debug.assert;
const link = @import("../../link.zig");
const Module = @import("../../Module.zig");
const ErrorMsg = Module.ErrorMsg;
const Liveness = @import("../../Liveness.zig");
const log = std.log.scoped(.sparcv9_emit);
const DebugInf... | src/arch/sparc64/Emit.zig |
const fmt = @import("std").fmt;
const GBA = @import("core.zig").GBA;
const OAM = @import("oam.zig").OAM;
pub const BIOS = struct {
pub const RamResetFlags = packed struct {
clearEwRam: bool = false,
clearIwram: bool = false,
clearPalette: bool = false,
clearVRAM: bool = false,
... | GBA/bios.zig |
const std = @import("std");
const builtin = @import("builtin");
const Builder = std.build.Builder;
pub fn createPackage(comptime root: []const u8) std.build.Pkg {
return std.build.Pkg{
.name = "lola",
.path = .{ .path = root ++ "/src/library/main.zig" },
.dependencies = &[_]std.build.Pkg{
... | build.zig |
const __muloti4 = @import("muloti4.zig").__muloti4;
const testing = @import("std").testing;
fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void {
var overflow: c_int = undefined;
const x = __muloti4(a, b, &overflow);
testing.expect(overflow == expected_overflow and (expected_o... | lib/std/special/compiler_rt/muloti4_test.zig |
const page_table = @import("page_table.zig");
pub const PAGE_TABLE_ENTRY_COUNT = page_table.PAGE_TABLE_ENTRY_COUNT;
pub const FrameError = page_table.FrameError;
pub const PageTableEntry = page_table.PageTableEntry;
pub const PageTableFlags = page_table.PageTableFlags;
pub const PageTable = page_table.PageTable;
pub co... | src/structures/paging/paging.zig |
const crc = @import("crc");
const it = @import("ziter");
const std = @import("std");
const util = @import("util");
const int = @import("../int.zig");
const nds = @import("../nds.zig");
const ascii = std.ascii;
const debug = std.debug;
const io = std.io;
const mem = std.mem;
const lu16 = int.lu16;
const lu32 = int.lu... | src/core/rom/nds/header.zig |
const std = @import("std");
usingnamespace @import("wren.zig");
/// Sets the basic Wren default configuration with the basic handlers
/// defined in this library
pub fn initDefaultConfig (configuration:[*c]Configuration) void {
initConfiguration(configuration);
configuration.*.writeFn = bindings.writeFn;
... | src/util.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const meta = std.meta;
const trait = meta.trait;
const assert = std.debug.assert;
const testing = std.testing;
const mustache = @import("../mustache.zig");
const RenderOptions = mustache.options.RenderOptions;
const Delimiters = mustache.Delimiters;
co... | src/rendering/lambda.zig |
const std = @import("std");
const Endian = std.builtin.Endian;
const assert = std.debug.assert;
const link = @import("../../link.zig");
const Module = @import("../../Module.zig");
const ErrorMsg = Module.ErrorMsg;
const Liveness = @import("../../Liveness.zig");
const DebugInfoOutput = @import("../../codegen.zig").Debu... | src/arch/sparcv9/Emit.zig |
const std = @import("std");
const gc = @import("gc.zig");
const Rational = std.math.big.Rational;
const Allocator = std.mem.Allocator;
// TODO: maybe something that allows plugging your own irrational numbers as Multiple:
// it could be defined with a representation (e.g. Ο) and a function to approximate the result
... | src/Real.zig |
const std = @import("std");
const builtin = @import("builtin");
const T = std.testing;
const date = @import("gregorianDate.zig");
const warn = std.debug.warn;
test "Date coarse range check" {
const R = enum {
inRange,
outOfRange,
};
const RangeCheckElem = struct {
y: i32,
m:... | src/gregorianDate_test.zig |
const std = @import("std");
const ztBuild = @import("ZT/build.zig");
const Builder = std.build.Builder;
const LibExeObjStep = std.build.LibExeObjStep;
const Pkg = std.build.Pkg;
pub const EngineConfig = struct {
/// Path to where didot is relative to the game's build.zig file. Must end with a slash or be empty.
... | build.zig |
const util = @import("../sdf_util.zig");
pub const info: util.SdfInfo = .{
.name = "Transform",
.data_size = @sizeOf(Data),
.function_definition = "",
.enter_command_fn = enterCommand,
.exit_command_fn = exitCommand,
.sphere_bound_fn = sphereBound,
};
pub const Data = struct {
rotation: u... | src/sdf/modifiers/transform.zig |
const std = @import("std");
const generate = @import("generator.zig").generate;
const path = std.fs.path;
const Builder = std.build.Builder;
const Step = std.build.Step;
/// build.zig integration for Vulkan binding generation. This step can be used to generate
/// Vulkan bindings at compiletime from vk.xml, by providi... | generator/vulkan/build_integration.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
const Vec2 = tools.Vec2;
pub fn run(input_text: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const param: struct {
... | 2020/day17.zig |
const std = @import("std");
const assert = std.debug.assert;
const spec = @import("spec.zig");
pub const Type = extern union {
tag_if_small_enough: Tag,
ptr_otherwise: *Payload,
/// A reference to another SPIR-V type.
pub const Ref = usize;
pub fn initTag(comptime small_tag: Tag) Type {
... | src/codegen/spirv/type.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const String = std.ArrayList(u8);
const StringMap = std.StringHashMap(u8);
const Bags = std.ArrayList([]const u8);
const Backward = std.StringHashMap(Bags);
const NBag = struct { n: usize, bag: []const u8 };
const NBags = std.ArrayList(NBag);
const Forwar... | 2020/zig/src/7.zig |
const script = @import("main.zig").script;
const types = @import("types.zig");
const Atom = types.Atom;
const AtomList = types.AtomList;
const SyntaxErrors = types.SyntaxErrors;
const parseFloat = @import("std").fmt.parseFloat;
// I'd prefer this all to be in a function, but I couldn't figure out how to give the tok... | parse.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const windows = std.os.windows;
const WAVE_FORMAT_PCM = 0x01;
const WHDR_INQUEUE = 0x10;
const WAVE_MAPPER = 0xffffffff;
const CALLBACK_NULL = 0x0;
const HWAVEOUT = windows.HANDLE;
const UINT_PTR = usize;
const MMError = error{
Error,
BadDevic... | src/audio/backend/winnm.zig |
const std = @import("std");
const FileSystemDescription = @This();
allocator: std.mem.Allocator,
/// Do not modify directly
entries: std.ArrayListUnmanaged(*EntryDescription) = .{},
/// Do not modify directly
root: *EntryDescription,
/// Do not modify directly
cwd: *EntryDescription,
pub fn init(allocator: std.mem... | src/config/FileSystemDescription.zig |
const std = @import("std");
const platform = @import("platform.zig");
const util = @import("util.zig");
const c = @cImport({
@cInclude("ucontext.h");
});
const Cookie = util.Cookie;
pub const Error = error{NoSuchTask};
fn nop(task: *Task) void {}
pub const Task = struct {
pub const Id = i24;
pub const... | kernel/task.zig |
const std = @import("std");
const image = @import("image.zig");
const scene = @import("scene.zig");
const camera = @import("camera.zig");
const config = @import("config.zig");
const sphere = @import("sphere.zig");
const tracer = @import("tracer.zig");
const vector = @import("vector.zig");
const worker = @import("worker... | src/main.zig |
const std = @import("std");
const kernel = @import("root");
const arch = kernel.arch;
const mm = kernel.mm;
pub var logger = kernel.logging.logger("task"){};
pub const Task = struct {
regs: arch.TaskRegs,
stack: []u8,
next: NextNode,
const Self = @This();
pub const NextNode = std.TailQueue(void).... | kernel/task.zig |
const std = @import("std");
const util = @import("util.zig");
const uv_util = @import("uv_util.zig");
const c = uv_util.c;
pub const log = util.log;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const alloc = &gpa.allocator;
const DEFAULT_PORT = 3000;
const data = "HELLO FROM CLIENT!";
pub fn main() !void {
... | src/uv_examples/uvclient.zig |
const sf = struct {
pub usingnamespace @import("../sfml.zig");
pub usingnamespace sf.network;
};
const TcpListener = @This();
// Constructor/destructor
/// Creates a new tcp listener socket
pub fn create() !TcpListener {
var sock = sf.c.sfTcpListener_create();
if (sock) |s| {
return TcpListe... | src/sfml/network/TcpListener.zig |
const std = @import("std");
const ft = @import("freetype");
const zigimg = @import("zigimg");
const Atlas = @import("atlas.zig").Atlas;
const AtlasErr = @import("atlas.zig").Error;
const UVData = @import("atlas.zig").UVData;
const App = @import("main.zig").App;
const draw = @import("draw.zig");
const Vertex = draw.Ver... | examples/gkurve/resizable_label.zig |
const std = @import("std");
const Fundude = @import("main.zig");
const Cpu = @import("Cpu.zig");
const joypad = @import("joypad.zig");
const serial = @import("serial.zig");
const timer = @import("timer.zig");
const audio = @import("audio.zig");
const video = @import("video.zig");
const BEYOND_CART = 0x8000;
const BA... | src/Mmu.zig |
pub const struct_SceNetMallocStat = extern struct {
pool: c_int,
maximum: c_int,
free: c_int,
};
pub const SceNetMallocStat = struct_SceNetMallocStat;
pub extern fn sceNetInit(poolsize: c_int, calloutprio: c_int, calloutstack: c_int, netintrprio: c_int, netintrstack: c_int) c_int;
pub extern fn sceNetTerm()... | src/psp/sdk/pspnet.zig |
const std = @import("std");
const upaya = @import("upaya");
usingnamespace upaya.imgui;
pub const SlideList = std.ArrayList(*Slide);
pub const SlideShow = struct {
slides: SlideList = undefined,
// defaults that can be overridden while parsing
default_font: []const u8 = "assets/Calibri Regular.ttf",
... | src/slides.zig |
const std = @import("std");
const vk = @import("vulkan");
const c = @import("c.zig");
const Allocator = std.mem.Allocator;
const required_device_extensions = [_][]const u8{
vk.extension_info.khr_swapchain.name
};
const BaseDispatch = struct {
vkCreateInstance: vk.PfnCreateInstance,
usingnamespace vk.BaseW... | examples/graphics-context.zig |
pub const va_list = __builtin_va_list;
pub const __gnuc_va_list = __builtin_va_list;
pub const __u_char = u8;
pub const __u_short = c_ushort;
pub const __u_int = c_uint;
pub const __u_long = c_ulong;
pub const __int8_t = i8;
pub const __uint8_t = u8;
pub const __int16_t = c_short;
pub const __uint16_t = c_ushort;
pub c... | mqtt_paho.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/day15.txt", run);
fn computeLowestExitLevel(alloc:... | 2021/day15.zig |
const w4 = @import("../wasm4.zig");
const sprites = @import("../assets/sprites.zig");
const gamepad = @import("../gamepad.zig");
const statemachine = @import("../state-machine.zig");
var start_ticks: u32 = 0;
pub fn handleInput(state: *statemachine.StateMachine, pl: *const gamepad.GamePad) void {
if (pl.isPressed(... | src/screens/start-screen.zig |
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
const sort = std.sort;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const bu = @import("bits_utils.zig");
const deflate_const = @import("deflate_const.zig");
const max_bits_limit = 16;
const... | lib/std/compress/deflate/huffman_code.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const print = std.debug.print;
const data = @embedFile("data/day24.txt");
const EntriesList = std.ArrayList(Record);
const Map = std.AutoHashMap(Record, void);
const Record = extern struct {
x: i32 = 0,
y: i32 =... | src/day24.zig |
const std = @import("std");
const smithy = @import("smithy");
const snake = @import("snake.zig");
const json_zig = @embedFile("json.zig");
pub fn main() anyerror!void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const a... | codegen/src/main.zig |
const assert = @import("std").debug.assert;
const Memory = @This();
/// the CPU visible memory pages resolved from the optionally mapped memory banks
pages: [num_pages]Page = [_]Page{.{}} ** num_pages,
/// optionally mapped memory bank mapping to host memory
banks: [num_banks][num_pages]BankPage = [_][num_pages]BankPa... | src/emu/Memory.zig |
const VTE = @import("vte");
const c = VTE.c;
const gtk = VTE.gtk;
const vte = VTE.vte;
const std = @import("std");
const config = @import("config.zig");
const prefs = @import("prefs.zig");
const version = @import("version.zig").version;
const menus = @import("menus.zig");
const Menu = menus.Menu;
const Nav = menus.Nav;... | src/keys.zig |
const std = @import("std");
const FormatOptions = std.fmt.FormatOptions;
const value = @import("value.zig");
const Value = value.Value;
const Lexer = struct {
offset: ?usize = null,
src: []const u8,
fn advance(self: *Lexer) ?u8 {
if (self.offset) |*offset| {
offset.* += 1;
... | src/fmt.zig |
const std = @import("std");
const log = std.log.scoped(.uv);
const c = @cImport({
// Make sure to pull the repo's uv.h. On macos, /usr/local/include/uv.h has precedence.
@cInclude("vendor/include/uv.h");
});
pub const sockaddr = c.sockaddr;
pub const sockaddr_in = c.sockaddr_in;
pub const uv_loop_t = c.uv_lo... | lib/uv/uv.zig |
const std = @import("std");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const log = std.log.scoped(.tapi);
const Allocator = mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
pub const Tokenizer = @import("Tokenizer.zig");
pub const parse = @i... | src/link/tapi/yaml.zig |
const std = @import("std");
const link = @import("../link.zig");
const Module = @import("../Module.zig");
const Compilation = @import("../Compilation.zig");
const Inst = @import("../ir.zig").Inst;
const Value = @import("../value.zig").Value;
const Type = @import("../type.zig").Type;
const C = link.File.C;
const Decl... | src/codegen/c.zig |
const std = @import("../std.zig");
const __rem_pio2_large = @import("__rem_pio2_large.zig").__rem_pio2_large;
const math = std.math;
const toint = 1.5 / math.floatEps(f64);
// pi/4
const pio4 = 0x1.921fb54442d18p-1;
// invpio2: 53 bits of 2/pi
const invpio2 = 6.36619772367581382433e-01; // 0x3FE45F30, 0x6DC9C883
// ... | lib/std/math/__rem_pio2.zig |
const std = @import("std");
const BigInt = std.math.big.int.Const;
const mem = std.mem;
const Allocator = mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
// zig fmt: off
pub const Tag = enum(u8) {
bool = 0x01,
int = 0x02,
bit_string = 0x03,
octet_string ... | src/asn1.zig |
const std = @import("std");
usingnamespace @import("imgui");
const colors = @import("../colors.zig");
const Tilemap = @import("tilemap.zig").Tilemap;
const Tileset = @import("tileset.zig").Tileset;
pub const TilemapEditor = struct {
map: Tilemap,
tileset: Tileset,
shift_dragged: bool = false,
dragged:... | src/tilemaps/editor.zig |
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const c = @cImport({
@cInclude("pcre.h");
});
pub const Options = struct {
Anchored: bool = false,
AutoCallout: bool = false,
BsrAnycrlf: bool = false,
BsrUnicode: bool = false,
Caseless: bool = false,
... | src/main.zig |