code stringlengths 38 801k | repo_path stringlengths 6 263 |
|---|---|
// Altered source. Added: toArray. Altered: lookAt, perspective. Made column major. Removed Vec2/Vec4. Only kept necessary methods for examples. removed tests
const std = @import("std");
pub const Vec3 = extern struct {
const Self = @This();
x: f32,
y: f32,
z: f32,
pub fn length2(a: Self) f32 {
... | src/math3d.zig |
const std = @import("std");
const c = @import("main.zig").c;
// Description of a glyph on the atlas i.e. a rectangle on the atlas which
// contains pixels of a glyph that can be found at the 'idx' in the atlas dict.
const AtlasGlyph = struct {
idx: u8,
rect: c.mu_Rect,
};
pub const dict: [256]c.mu_Rect = atl... | src/atlas.zig |
const std = @import("std");
const testing = std.testing;
/// Provides a set of renderers for gemtext documents.
pub const renderer = struct {
pub const gemtext = @import("renderers/gemtext.zig").render;
pub const html = @import("renderers/html.zig").render;
pub const markdown = @import("renderers/markdown.... | src/gemtext.zig |
const std = @import("std");
const iup = @import("iup.zig");
const MainLoop = iup.MainLoop;
const Dialog = iup.Dialog;
const Button = iup.Button;
const MessageDlg = iup.MessageDlg;
const Multiline = iup.Multiline;
const Label = iup.Label;
const Text = iup.Text;
const VBox = iup.VBox;
const HBox = iup.HBox;
const Menu =... | src/notepad_example.zig |
pub const PspGeContext = extern struct {
context: [512]c_uint,
};
pub const SceGeStack = extern struct {
stack: [8]c_uint,
};
pub const PspGeCallback = ?fn (c_int, ?*c_void) callconv(.C) void;
pub const PspGeCallbackData = extern struct {
signal_func: PspGeCallback,
signal_arg: ?*c_void,
finish_fu... | src/psp/sdk/pspge.zig |
pub const CERT_COMPARE_SHIFT = @as(i32, 16);
pub const BCRYPT_OBJECT_ALIGNMENT = @as(u32, 16);
pub const KDF_HASH_ALGORITHM = @as(u32, 0);
pub const KDF_SECRET_PREPEND = @as(u32, 1);
pub const KDF_SECRET_APPEND = @as(u32, 2);
pub const KDF_HMAC_KEY = @as(u32, 3);
pub const KDF_TLS_PRF_LABEL = @as(u32, 4);
pub const KDF... | deps/zigwin32/win32/security/cryptography/core.zig |
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
const kernel = @import("__trig.zig");
const __rem_pio2 = @import("__rem_pio2.zig").__rem_pio2;
const __rem_pio2f = @import("__rem_pio2f.zig").__rem_pio2f;
/// Returns the sine of the radian value x.
///
/// Special Cases:
///... | lib/std/math/sin.zig |
const std = @import("std");
const log = std.debug.warn;
const stdout = &std.io.getStdOut().outStream();
const assert = @import("std").debug.assert;
const fmt = @import("std").fmt;
const c = @import("c.zig");
const gw = c.gw;
const gmp = c.gmp;
const glue = @import("glue.zig");
const helper = @import("helper.zig");
co... | fermat.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const bog = @import("bog.zig");
const Value = bog.Value;
const expect = std.testing.expect;
//! A non-moving garbage collector.
//! Inspired by https://www.pllab.riec.tohoku.ac.jp/papers/icfp2011UenoOhori... | src/Gc.zig |
const std = @import("std");
const lexer = @import("tokenizer.zig");
const ast = @import("ast.zig");
const diag = @import("diagnostics.zig");
const Location = @import("location.zig").Location;
const EscapedStringIterator = @import("string-escaping.zig").EscapedStringIterator;
/// Parses a sequence of tokens into an a... | src/library/compiler/parser.zig |
const testing = @import("std").testing;
const math = @import("std").math;
const v4 = @import("vector4.zig").v4;
const v3 = @import("vector3.zig").v3;
const warn = @import("std").debug.warn;
pub const m4 = struct {
v: [4][4]f32,
/// returns a new identity matrix
pub fn init() m4 {
const ident = [4]... | src/matrix4.zig |
const base = @import("../base.zig");
const gen = @import("../gen.zig");
const cal_454 = @import("symmetry454.zig");
const COMMON = [_:null]?base.Segment{
.{ .offset = 30 * 0 + 31 * 0, .month = 1, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 1 + 31 * 0, .month = 2, .day_start = 1, .day_end = 31 },
.{ ... | src/cal/symmetry010.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const vr = @import("vr.zig");
const Header = vr.Header;
const MessageBus = @import("message_bus.zig").MessageBusClient;
const Message = @import("message_bus.zig").Message;
const StateMachine = @impo... | src/client.zig |
const messageNs = @import("message.zig");
const MessageHeader = messageNs.MessageHeader;
const messageQueueNs = @import("message_queue.zig");
const MessageQueue = messageQueueNs.MessageQueue;
const std = @import("std");
const warn = std.debug.warn;
/// ActorInterface is a member of all Actor's and
/// every Actor mu... | actor.zig |
const clap = @import("zig-clap");
const std = @import("std");
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const unicode = std.unicode;
const Names = clap.Names;
const Param = clap.Param(clap.Help);
const params = [_]Param{
... | src/main.zig |
const std = @import("std");
usingnamespace @import("kiragine").kira.log;
const engine = @import("kiragine");
const ComponentList = struct {
rect: engine.Rectangle = undefined,
motion: engine.Vec2f = undefined,
is_alive: bool = false,
};
const ComponentTags = enum {
rectangle,
motion,
isAlive,
... | examples/ecs.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const util = @import("./util.zig");
const data = @embedFile("../data/day03.txt");
//Calculate the amount of lines in comptime.
const lineCount = comptime {
@setEvalBranchQuota(28000);
return util.countScalar(u8, da... | src/day03.zig |
const std = @import("std");
const Node = struct {
x: i32,
y: i32,
r: i8,
g: i32,
h: i32,
f: i32,
s: i64,
updated: bool,
closed: bool
};
const Grid = struct {
width: i32,
height: i32,
nodes: std.ArrayList(Node)
};
pub fn newNode(x: i32, y: i32, r: i8) Node {
return ... | 2021/day15/part2.zig |
const std = @import("std");
const kernel = @import("root");
const mm = kernel.mm;
const lib = kernel.lib;
const x86 = kernel.arch.x86;
const BIT = kernel.lib.BIT;
const bit_set = kernel.lib.bit_set;
const PhysicalAddress = mm.PhysicalAddress;
const VirtualAddress = mm.VirtualAddress;
const mask: u64 = ~@as(u64, 0xff... | kernel/arch/x86/paging.zig |
const std = @import("std");
const string = []const u8;
const base32 = @import("./base32.zig");
const extras = @import("extras");
pub const Factory = struct {
epoch: i64,
rand: std.rand.Random,
pub fn init(epoch: i64, rand: std.rand.Random) Factory {
return Factory{
.epoch = epoch,
... | ulid.zig |
const std = @import("std");
const Data = @import("../events/events.zig").Data;
const Event = @import("../events/events.zig").Event;
pub const Error = error{
BodyTooshort,
BodyTooLarge,
};
pub const ContentLengthReader = struct {
expected_length: usize,
read_bytes: usize = 0,
pub fn read(self: *Co... | src/readers/content_length_reader.zig |
const std = @import("std");
const nacl = std.crypto.nacl;
const ed25519 = std.crypto.sign.Ed25519;
const allocator = std.heap.page_allocator;
var buffer_len: u32 = 0;
export fn wlen() u32 { return buffer_len; }
export fn wfree(ptr: u32, len: usize) void { allocator.free(@intToPtr([*]u8, ptr)[0..len]); }
export fn wall... | src/nacl/nacl.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Str = []const u8;
const BitSet = std.DynamicBitSet;
const StrMap = std.StringHashMap;
const HashMap = std.HashMap;
const Map = std.AutoHashMap;
const PriorityQueue = std.PriorityQueue;
const assert = std.debug.assert;
con... | fortune.zig |
const GBA = @import("core.zig").GBA;
pub const Bitmap16 = struct {
pub fn line(x1: i32, y1: i32, x2: i32, y2: i32, color: u16, destinationBase: [*]volatile u16, rawPitch: i32) void {
var ii: i32 = 0;
var dx: i32 = 0;
var dy: i32 = 0;
var xstep: i32 = 0;
var ystep: i32 = 0;
... | GBA/bitmap.zig |
const std = @import("std");
const warn = std.debug.warn;
const os = std.os;
pub const c = @cImport({
@cInclude("time.h");
@cInclude("curl/curl.h");
});
pub fn get_socket(host: [*:0]const u8, port: [*:0]const u8) !c_int {
var s: c_int = undefined;
var hints: os.addrinfo = undefined;
var res: *os.ad... | src/c.zig |
pub const segsize_t = u32;
pub const segaddr_t = u32;
pub const segflag_t = u8;
pub const segtype_t = u4;
/// Segment Descriptor and their structures.
pub const SegmentDescriptor = packed struct {
// const values
pub const CS_TYPE: segflag_t = 0x9A;
pub const DS_TYPE: segflag_t = 0x92;
// internal con... | kernel/segment_descriptor.zig |
const std = @import("std");
const strings = @import("../strings/strings.zig");
const warn = std.debug.warn;
pub const Builder = struct {
buf: *std.Buffer,
replacer: strings.StringReplacer,
choice_replacer: strings.StringReplacer,
a: *std.mem.Allocator,
current_tab_stop: usize,
pub fn init(a: *... | src/lsp/snippet/snippet.zig |
const std = @import("std");
const Buffer = @import("../main.zig").Buffer;
const Rect = @import("../main.zig").Rect;
const Widget = @import("Widget.zig");
const TextStyle = @import("../style.zig").TextStyle;
const chars = @import("chars.zig");
const Self = @This();
widget: Widget = .{ .drawFn = draw, .sizeFn = size... | src/widget/Box.zig |
usingnamespace @import("bits.zig");
usingnamespace @import("fdman.zig");
usingnamespace @import("cwd.zig");
pub var errno: u32 = 0;
fn pspErrToErrno(code: u64) i32 {
if ((code & 0x80010000) == 0x80010000) {
errno = @truncate(u32, code & 0xFFFF);
return -1;
}
return @bitCast(i32, @truncate(u... | src/psp/os/system.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const math = std.math;
const print = std.debug.print;
pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
/// This should only be used in temporary test programs.
pub const allocator = allocator_instance.allocator... | lib/std/testing.zig |
const std = @import("std");
const hzzp = @import("hzzp");
const wz = @import("wz");
const Heartbeat = @import("Client/Heartbeat.zig");
const https = @import("https.zig");
const discord = @import("discord.zig");
const json = @import("json.zig");
const util = @import("util.zig");
const log = std.log.scoped(.zCord);
con... | src/Client.zig |
const std = @import("std");
const err = std.log.err;
const debug = std.log.debug;
const machine = @import("machine.zig");
const sdl = @import("sdl.zig");
// Fonts taken from https://tobiasvl.github.io/blog/write-a-chip-8-emulator/
const Fonts = [_]u8{
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
0x20, 0x60, 0x20, 0x20, ... | src/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const builtin = @import("builtin");
const glfw = @import("glfw");
const gpu = @import("gpu");
const platform = @import("platform.zig");
const structs = @import("structs.zig");
const enums = @import("enums.zig");
const Timer = @import("Timer.zig");
const ... | src/Engine.zig |
const std = @import("std");
const gpa = std.heap.c_allocator;
const zfetch = @import("zfetch");
const json = @import("json");
const range = @import("range").range;
const u = @import("./../../util/index.zig");
const zpm = @import("./../zpm.zig");
//
//
pub fn execute(args: [][]u8) !void {
_ = args;
const ou... | src/cmd/zpm/search.zig |
pub const MCAST_CLIENT_ID_LEN = @as(u32, 17);
pub const MCAST_API_CURRENT_VERSION = @as(i32, 1);
pub const MCAST_API_VERSION_0 = @as(i32, 0);
pub const MCAST_API_VERSION_1 = @as(i32, 1);
//--------------------------------------------------------------------------------
// Section: Types (6)
//-------------------------... | win32/network_management/multicast.zig |
pub const D2D1_DEFAULT_FLATTENING_TOLERANCE = @as(f32, 2.5e-01);
pub const CLSID_D2D12DAffineTransform = Guid.initString("6aa97485-6354-4cfc-908c-e4a74f62c96c");
pub const CLSID_D2D13DPerspectiveTransform = Guid.initString("c2844d0b-3d86-46e7-85ba-526c9240f3fb");
pub const CLSID_D2D13DTransform = Guid.initString("e8467... | win32/graphics/direct2d.zig |
const std = @import("std");
const testing = @import("testing.zig");
pub const Map = struct {
const Self = @This();
const MapType = std.StringHashMap([]const u8);
const MapEntry = MapType.Entry;
const Iterator = MapType.Iterator;
allocator: *std.mem.Allocator,
map: MapType,
pub fn init(a... | src/string_map.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const Token = @import("json_grammar.tokens.zig").Token;
pub const TokenIndex = *Token;
const FlatHash = @import("../zig-flat-hash/flat_hash.zig");
usingnamespace FlatHash;
pub const VariantList = std.ArrayList(*Variant);
pub c... | json/json_grammar.types.zig |
const c_cast = @import("std").meta.cast;
const os_tag = @import("std").builtin.os.tag;
pub usingnamespace @cImport({
@cInclude("stdlib.h");
@cInclude("fcntl.h");
@cInclude("locale.h");
@cInclude("errno.h");
@cInclude("time.h");
@cInclude("unistd.h");
@cInclude("signal.h");
@cInclude("pw... | src/c.zig |
const std = @import("std");
const lib = @import("lib.zig");
const mem = std.mem;
const testing = std.testing;
const assert = std.debug.assert;
const Tokenizer = lib.Tokenizer;
const Linker = lib.Linker;
const Allocator = std.mem.Allocator;
const Instruction = lib.Instruction;
const Location = Tokenizer.Location;
const... | lib/Parser.zig |
const std = @import("std");
const math = std.math;
const trait = std.meta.trait;
const assert = std.debug.assert;
const vec = @import("vec.zig");
const Vec2 = vec.Vec2;
const Vec3 = vec.Vec3;
const Vec4 = vec.Vec4;
fn MatMixin(comptime Self: type, comptime VecType: type, comptime T: type) type {
return struct {
... | math/src/mat.zig |
pub const GuPixelMode = extern enum(c_int) {
Psm5650 = 0,
Psm5551 = 1,
Psm4444 = 2,
Psm8888 = 3,
PsmT4 = 4,
PsmT8 = 5,
PsmT16 = 6,
PsmT32 = 7,
PsmDXT1 = 8,
PsmDXT3 = 9,
PsmDXT5 = 10,
};
pub const GuPrimitive = extern enum(c_int) {
Points = 0,
Lines = 1,
LineStrip... | src/psp/sdk/pspgutypes.zig |
pub const JS_SOURCE_CONTEXT_NONE = @as(u64, 18446744073709551615);
//--------------------------------------------------------------------------------
// Section: Types (11)
//--------------------------------------------------------------------------------
pub const JsRuntimeVersion = enum(i32) {
@"10" = 0,
@"1... | deps/zigwin32/win32/system/js.zig |
const std = @import("std");
const ascii = std.ascii;
const mem = std.mem;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const util = @import("util.zig");
const Bytes = util.Bytes;
const IOStream = util.IOStream;
fn isColonValidateToken(ch: u8) !bool {
if (ch == ':') return true;
if (!util.... | src/headers.zig |
const std = @import("std");
const Window = @import("Window.zig");
const Monitor = @import("Monitor.zig");
const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
const internal_debug = @import("internal_debug.zig");
pub const BackendOptions = struct {
win32: bool = false,
... | glfw/src/native.zig |
const std = @import("std");
const Color = @This();
alpha: ?u8 = null,
red: u8 = 0,
green: u8 = 0,
blue: u8 = 0,
pub fn write(this: Color, writer: anytype) !void {
if (this.alpha) |a_value| {
try writer.print("#{x:0>2}{x:0>2}{x:0>2}{x:0>2}", .{ this.alpha, this.red, this.green, this.blue });
} else {
... | src/Formatter/Color.zig |
const modf = @import("std").math.modf;
var CVTBUF: [80]u8 = undefined;
export fn cvt(_arg_arg: f64, _arg_ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int, buf: [*c]u8, eflag: c_int) [*c]u8 {
var arg = _arg_arg;
var ndigits = _arg_ndigits;
var r2: c_int = undefined;
var fi: f64 = undefined;
var fj:... | examples/nonsecure-bench-coremark/cvt.zig |
const std = @import("std");
const os = std.os;
pub const Segments = std.ArrayList(Segment);
/// A segment of readable memory.
const Segment = struct {
start: usize,
len: usize,
name: ?[]u8 = null,
};
/// Reads /proc/pid/maps file for a given pid.
/// Translates the addresses in that file into Segment stru... | src/read_map.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
// Parse flags from an ArgIterator according to the provided Flags struct. Skips the first arg
pub fn parse(allocator: Allocator, comptime Flags: type, args: *std.process.ArgIterator) !Flags {
std.debug.assert(args.skip());
return parseRaw(alloca... | optz.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/day16.txt");
c... | src/day16.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/day02.txt");
c... | src/day02.zig |
pub const CLSID_VERSION_DEPENDENT_MSIME_JAPANESE = Guid.initString("6a91029e-aa49-471b-aee7-7d332785660d");
pub const IFEC_S_ALREADY_DEFAULT = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291840));
pub const FELANG_REQ_CONV = @as(u32, 65536);
pub const FELANG_REQ_RECONV = @as(u32, 131072);
pub const FELANG_REQ... | win32/ui/input/ime.zig |
const std = @import("std");
const math = std.math;
usingnamespace @import("vec.zig");
usingnamespace @import("rotor.zig");
usingnamespace @import("xform.zig");
/// A 3x3 matrix. When required to choose, this library uses
/// the column-major convention.
pub const Mat3 = extern struct {
x: Vec3,
y: Vec3,
... | src/geo/mat.zig |
const std = @import("std");
const Allocator = mem.Allocator;
const event = std.event;
const fifo = std.fifo;
const fmt = std.fmt;
const io = std.io;
const json = std.json;
const mem = std.mem;
const meta = std.meta;
const net = std.net;
const nkeys = @import("nkeys");
const nuid = @import("nuid.zig");
const testing = s... | src/main.zig |
export fn _LIB_VERSION() void {}
export fn __acos_finite() void {}
export fn __acosf128_finite() void {}
export fn __acosf_finite() void {}
export fn __acosh_finite() void {}
export fn __acoshf128_finite() void {}
export fn __acoshf_finite() void {}
export fn __acoshl_finite() void {}
export fn __acosl_finite() void {... | libc/dummy/m.zig |
const std = @import("std");
const token = @import("./token.zig");
const Token = token.Token;
const Cursor = token.Cursor;
pub const Block = @import("./token/block.zig").Block;
pub const @"Type" = @import("./token/type.zig").Type;
pub const Kw = @import("./token/kw.zig").Kw;
pub const Op = @import("./token/op.zig").Op;
... | src/lang/expr.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/day4.zig |
// TODO: Use atomicRmw?
// https://reddit.com/comments/u4kc0j/comment/i4wycmb?context=3
const assert = @import("std").debug.assert;
pub fn Register(comptime Inner: type, comptime ReadWrite: type) type {
return AsymmetricRegister(Inner, ReadWrite, ReadWrite);
}
pub fn AsymmetricRegister(comptime Inner: type, com... | src/mmio_register.zig |
const std = @import("std");
const pike = @import("pike.zig");
const Waker = @import("waker.zig").Waker;
const os = std.os;
pub const Event = struct {
const Self = @This();
handle: pike.Handle = .{
.inner = -1,
.wake_fn = wake,
},
waker: Waker = .{},
inner: os.Kevent,
notifier... | event_kqueue.zig |
const std = @import("std");
pub const OptionType = enum {
long,
short,
};
pub const OptionInterpretation = struct {
option_type: OptionType,
name: []const u8,
value: ?[]const u8 = null,
};
pub const ArgumentInterpretation = union(enum) {
option: OptionInterpretation,
double_dash: void,
... | src/arg.zig |
const std = @import("std");
const zupnp = @import("../../lib.zig");
const ActionError = zupnp.upnp.definition.ActionError;
const ActionRequest = zupnp.upnp.device.ActionRequest;
const ActionResult = zupnp.upnp.device.ActionResult;
const EventSubscriptionRequest = zupnp.upnp.device.EventSubscriptionRequest;
const Event... | src/upnp/device/abstract.zig |
const c = @import("c.zig").c;
// Input focus window hint and attribute
/// Input focus window hit or window attribute.
pub const focused = c.GLFW_FOCUSED;
/// Window iconification window attribute.
pub const iconified = c.GLFW_ICONIFIED;
// Window resize-ability window hint and attribute
pub const resizable = c.GL... | glfw/src/consts.zig |
const std = @import("../index.zig");
const assert = std.debug.assert;
const ArrayList = std.ArrayList;
const mem = std.mem;
const ast = std.zig.ast;
const Tokenizer = std.zig.Tokenizer;
const Token = std.zig.Token;
const builtin = @import("builtin");
const io = std.io;
// TODO when we make parse errors into error type... | std/zig/parser.zig |
const std = @import("std");
const eql = std.mem.eql;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
const test_allocator = std.testing.allocator;
const trimLeft = std.mem.trimLeft;
const ESCAPE_1 = '\u{001b}';
const ESCAPE_2 =... | begrudge.zig |
const std = @import("std");
const minInt = std.math.minInt;
const maxInt = std.math.maxInt;
const add = std.math.add;
const sub = std.math.sub;
const mul = std.math.mul;
const base = @import("base.zig");
const gen = @import("gen.zig");
const UNIX_EPOCH_IN_MJD: i32 = 40587;
const RD_EPOCH_IN_MJD: i32 = -678576;
fn clo... | src/logic.zig |
const std = @import("std");
pub const c = @import("pdpanel.zig");
pub const chars = @import("chars.zig");
pub const colors = @import("color.zig");
pub const mouse = @import("mouse.zig");
pub const keys = @import("keys.zig");
pub const attrib = @import("attrib.zig");
pub const AttrChar = c.chtype;
pub const char_size =... | src/zig-pdcurses.zig |
const std = @import("std");
const lib = @import("lib.zig");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const types = lib.types;
const Session = @This();
pub const Setup = extern struct {
release: u32,
resource_id_base: u32,
resource_id_mask: u32,
motion_buffer_size: u32,
length_of_v... | src/Session.zig |
const std = @import("std");
const zp = @import("zplay");
const dig = zp.deps.dig;
fn init(ctx: *zp.Context) anyerror!void {
std.log.info("game init", .{});
// init imgui
try dig.init(ctx.window);
}
fn loop(ctx: *zp.Context) void {
while (ctx.pollEvent()) |e| {
_ = dig.processEvent(e);
... | examples/imgui_demo.zig |
const std = @import("std");
const os = std.os;
const fmt = std.fmt;
const io = std.io;
const dns = @import("dns");
const rdata = dns.rdata;
pub const DNSPacket = dns.Packet;
pub const DNSPacketRCode = dns.ResponseCode;
pub const DNSClass = dns.DNSClass;
const Allocator = std.mem.Allocator;
const mainlib = @import("ma... | src/main_stdin.zig |
const c = @cImport({
@cInclude("cfl_table.h");
});
const widget = @import("widget.zig");
pub const Table = struct {
inner: ?*c.Fl_Table,
pub fn new(x: i32, y: i32, w: i32, h: i32, title: [*c]const u8) Table {
const ptr = c.Fl_Table_new(x, y, w, h, title);
if (ptr == null) unreachable;
... | src/table.zig |
const std = @import("std");
const vertex_shader_source = @embedFile("shaders/vertex.glsl");
const fragment_shader_source = @embedFile("shaders/fragment.glsl");
const windows = @import("window.zig");
const Window = @import("window.zig").Window;
const CompositorOutput = @import("output.zig").CompositorOutput;
const main ... | src/renderer.zig |
const std = @import("std");
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
pub fn asTypeId(comptime typeInfo: std.builtin.Type) std.builtin.TypeId {
return @as(std.builtin.TypeId, typeInfo);
}
pub fn typeIdOf(comptime T: type) std.builtin.TypeId {
return asTypeId(@typeInfo(T... | libs/zpool/src/utils.zig |
/// Do not compare directly to .True, use toBool() instead.
pub const Bool = enum(c_int) {
False,
True,
_,
pub fn fromBool(b: bool) Bool {
return @intToEnum(Bool, @boolToInt(b));
}
pub fn toBool(b: Bool) bool {
return b != .False;
}
};
pub const AttributeIndex = c_uint;
/... | src/codegen/llvm/bindings.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");
/// Contains constants for the C0 control codes of the ASCII encoding.
/// https://en.wikipedia.org/wiki/C0_and_C1_control_codes
pub const control_code = struct {
pub const NUL = 0x00;
pub const SOH = 0x01;
pub const STX = 0x02;
pub const ETX = 0x03;
pub const EOT = 0x0... | lib/std/ascii.zig |
const std = @import("std");
const expect = std.testing.expect;
const mem = std.mem;
const maxInt = std.math.maxInt;
const Vector = std.meta.Vector;
const native_endian = @import("builtin").target.cpu.arch.endian();
test "int to ptr cast" {
const x = @as(usize, 13);
const y = @intToPtr(*u8, x);
const z = @p... | test/behavior/cast.zig |
const expectEqual = @import("std").testing.expectEqual;
const std = @import("std");
const expect = std.testing.expect;
test "@byteSwap integers" {
const ByteSwapIntTest = struct {
fn run() !void {
try t(u0, 0, 0);
try t(u8, 0x12, 0x12);
try t(u16, 0x1234, 0x3412);
... | test/behavior/byteswap.zig |
const builtin = @import("builtin");
const std = @import("std");
const Mode = builtin.Mode;
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const test_all_step = b.step("test", "Run all tests in all m... | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Str = []const u8;
const BitSet = std.DynamicBitSet;
const StrMap = std.StringHashMap;
const HashMap = std.HashMap;
const Map = std.AutoHashMap;
const PriorityQueue = std.PriorityQueue;
const assert = std.debug.assert;
con... | chunkFortunes.zig |
const std = @import("std");
const os = std.os;
const common = @import("common.zig");
pub const Object = common.Object;
pub const Message = common.Message;
pub const Interface = common.Interface;
pub const Array = common.Array;
pub const Fixed = common.Fixed;
pub const Argument = common.Argument;
/// This is wayland-s... | src/wayland_server_core.zig |
const std = @import( "std" );
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
pub usingnamespace @import( "c.zig" );
pub const GtkzError = error {
GenericFailure,
};
pub const GtkzHandlerConnection = struct {
instance: gpointer,
handlerId: gulong,
};
pub fn gtkzInit( allocator: *All... | src/core/gtkz.zig |
const basename = @import("basename.zig");
const dirname = @import("dirname.zig");
const fls = @import("false.zig");
const ls = @import("ls.zig");
const mkdir = @import("mkdir.zig");
const rm = @import("rm.zig");
const sleep = @import("sleep.zig");
const tail = @import("tail.zig");
const tru = @import("true.zig");
const... | src/main.zig |
const c = @import("../../c_global.zig").c_imp;
const std = @import("std");
// dross-zig
const OpenGlError = @import("renderer_opengl.zig").OpenGlError;
const FileLoader = @import("../../utils/file_loader.zig");
const ShaderGl = @import("shader_opengl.zig").ShaderGl;
const Matrix4 = @import("../../core/matrix4.z... | src/renderer/backend/shader_program_opengl.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const AutoHashMap = std.AutoHashMap;
const StringHashMap = std.StringHashMap;
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const trim = std.mem.trim;
const parseInt = std.fmt.... | src/day20.zig |
pub const MI_FLAG_ANY = @as(u32, 127);
pub const MI_FLAG_VERSION = @as(u32, 469762048);
pub const MI_FLAG_ADOPT = @as(u32, 2147483648);
pub const MI_FLAG_CLASS = @as(u32, 1);
pub const MI_FLAG_METHOD = @as(u32, 2);
pub const MI_FLAG_PROPERTY = @as(u32, 4);
pub const MI_FLAG_PARAMETER = @as(u32, 8);
pub const MI_FLAG_AS... | win32/system/wmi.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/04.txt", .{});
defer input_file.close();
var buffe... | src/04.zig |
const std = @import("std");
const w4 = @import("wasm4.zig");
const world = @import("world.zig");
const Player = @import("Player.zig");
const Obstacle = @import("Obstacle.zig");
const GameState = enum { title, running, game_over };
//Allocator for printing score
var buffer: [5]u8 = undefined;
var fba = std.heap.FixedB... | src/main.zig |
const std = @import("std");
const deps = @import("./deps.zig");
const Benchmark = struct {
name: []const u8,
path: []const u8,
};
const BENCHMARKS = [_]Benchmark{
.{ .name = "insert_random_check_balance", .path = "./benchmark/insert_random_check_balance.zig" },
};
const tracy_dummy = std.build.Pkg{
.... | build.zig |
const std = @import("std");
const sliceAsBytes = std.mem.sliceAsBytes;
const utils = @import("utils");
const kernel = @import("root").kernel;
const memory = kernel.memory;
const RealMemoryMap = memory.RealMemoryMap;
const AllocError = memory.AllocError;
const FreeError = memory.FreeError;
const Range = memory.Range;
... | kernel/platform/memory.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const window = @import("Window.zig");
const c = @import("c.zig").c;
const files = @import("../Files.zig");
const expect = std.testing.expect;
const ReferenceCounter = @import("../RefCount.zig").ReferenceCounter;
// Base internal formats
... | src/WindowGraphicsInput/Image.zig |
pub const tlds: []const []const u8 = &.{
"aaa",
"aarp",
"abarth",
"abb",
"abbott",
"abbvie",
"abc",
"able",
"abogado",
"abudhabi",
"ac",
"academy",
"accenture",
"accountant",
"accountants",
"aco",
"actor",
"ad",
"adac",
"ads",
"adult",... | src/lib.zig |
const std = @import("std");
const os = @import("root").os;
const apic = @import("apic.zig");
const ports = @import("ports.zig");
const kb = os.drivers.hid.keyboard;
const eoi = @import("apic.zig").eoi;
const Extendedness = enum {
Extended,
NotExtended,
};
pub var kb_interrupt_vector: u8 = undefined;
pub var kb_i... | src/platform/x86_64/ps2.zig |
const std = @import("std");
const math = std.math;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const mat = @import("zalgebra");
const mat4 = mat.mat4;
const vec = mat.vec3;
const log = std.log;
var c_allocator = std.heap.c_allocator;
const roundUp = @import("main.z... | src/model.zig |
const std = @import("std");
const msgpack = @import("msgpack.zig");
const Value = msgpack.Value;
const deserialize = msgpack.deserialize;
const toVal = msgpack.toVal;
const serializeList = msgpack.serializeList;
test "serializes and deserializes f32, and f64" {
// Serializing
const expected = &[_]u8{
1... | src/msgpack_test.zig |
const std = @import("std");
const bottom = @import("bottom");
const args = @import("zig-args");
const builtin = @import("builtin");
const build_options = @import("build_options");
const help_text = @embedFile("help.txt");
const bufferSize = 128 * 1024;
const newline = if(builtin.os.tag == .windows) "\r\n" else "\n";
//... | src/main.zig |
const std = @import("std");
pub const CBaseEntity = opaque {};
pub const IServerUnknown = opaque {};
pub const IHandleEntity = opaque {};
pub const PVSInfo = opaque {};
pub const CreateInterfaceFn = fn (name: [*:0]const u8, ret: ?*c_int) callconv(.C) ?*align(@alignOf(*anyopaque)) anyopaque;
pub const ServerClass = opa... | sdk/misc.zig |
const std = @import("std");
const print = std.debug.print;
const testing = std.testing;
const assert = std.debug.assert;
//assume base >= 0
fn isValidNumber(comptime UT: type, cust_nr: []UT, base: UT) bool {
for (cust_nr) |m_el| {
if (m_el >= base)
return false;
}
return true;
}
fn isN... | src/customNumberSystem.zig |
const std = @import("std");
const builtin = @import("builtin");
const minInt = std.math.minInt;
const maxInt = std.math.maxInt;
const expect = std.testing.expect;
test "saturating add" {
const S = struct {
fn doTheTest() !void {
try testSatAdd(i8, -3, 10, 7);
try testSatAdd(i8, 3, -... | test/behavior/saturating_arithmetic.zig |
const std = @import("std");
const pike = @import("pike.zig");
const posix = @import("os/posix.zig");
const os = std.os;
const net = std.net;
const mem = std.mem;
pub inline fn init() !void {}
pub inline fn deinit() void {}
pub const Handle = struct {
inner: os.fd_t,
wake_fn: fn (self: *Handle, batch: *pike.B... | notifier_epoll.zig |
const std = @import("std");
const prot = @import("protocols.zig");
const Focus = @import("focus.zig").Focus;
const CompositorOutput = @import("output.zig").CompositorOutput;
const Window = @import("window.zig").Window;
const compositor = @import("compositor.zig");
pub var CURRENT_VIEW: *View = undefined;
pub const Vi... | src/view.zig |