code
stringlengths 38
801k
| repo_path
stringlengths 6
263
|
|---|---|
const magic = 0xeb9f;
const version = 1;
pub const ext = @import("btf_ext.zig");
/// All offsets are in bytes relative to the end of this header
pub const Header = packed struct {
magic: u16,
version: u8,
flags: u8,
hdr_len: u32,
/// offset of type section
type_off: u32,
/// length of type section
type_len: u32,
/// offset of string section
str_off: u32,
/// length of string section
str_len: u32,
};
/// Max number of type identifiers
pub const max_type = 0xfffff;
/// Max offset into string section
pub const max_name_offset = 0xffffff;
/// Max number of struct/union/enum member of func args
pub const max_vlen = 0xffff;
pub const Type = packed struct {
name_off: u32,
info: packed struct {
/// number of struct's members
vlen: u16,
unused_1: u8,
kind: Kind,
unused_2: u3,
/// used by Struct, Union, and Fwd
kind_flag: bool,
},
/// size is used by Int, Enum, Struct, Union, and DataSec, it tells the size
/// of the type it is describing
///
/// type is used by Ptr, Typedef, Volatile, Const, Restrict, Func,
/// FuncProto, and Var. It is a type_id referring to another type
size_type: union { size: u32, typ: u32 },
};
/// For some kinds, Type is immediately followed by extra data
pub const Kind = enum(u4) {
unknown,
int,
ptr,
array,
structure,
kind_union,
enumeration,
fwd,
typedef,
kind_volatile,
constant,
restrict,
func,
funcProto,
variable,
dataSec,
};
/// Int kind is followed by this struct
pub const IntInfo = packed struct {
bits: u8,
unused: u8,
offset: u8,
encoding: enum(u4) {
signed = 1 << 0,
char = 1 << 1,
boolean = 1 << 2,
},
};
test "IntInfo is 32 bits" {
std.testing.expectEqual(@bitSizeOf(IntInfo), 32);
}
/// Enum kind is followed by this struct
pub const Enum = packed struct {
name_off: u32,
val: i32,
};
/// Array kind is followd by this struct
pub const Array = packed struct {
typ: u32,
index_type: u32,
nelems: u32,
};
/// Struct and Union kinds are followed by multiple Member structs. The exact
/// number is stored in vlen
pub const Member = packed struct {
name_off: u32,
typ: u32,
/// if the kind_flag is set, offset contains both member bitfield size and
/// bit offset, the bitfield size is set for bitfield members. If the type
/// info kind_flag is not set, the offset contains only bit offset
offset: packed struct {
bit: u24,
bitfield_size: u8,
},
};
/// FuncProto is followed by multiple Params, the exact number is stored in vlen
pub const Param = packed struct {
name_off: u32,
typ: u32,
};
pub const VarLinkage = enum {
static,
global_allocated,
global_extern,
};
pub const FuncLinkage = enum {
static,
global,
external,
};
/// Var kind is followd by a single Var struct to describe additional
/// information related to the variable such as its linkage
pub const Var = packed struct {
linkage: u32,
};
/// Datasec kind is followed by multible VarSecInfo to describe all Var kind
/// types it contains along with it's in-section offset as well as size.
pub const VarSecInfo = packed struct {
typ: u32,
offset: u32,
size: u32,
}; | lib/std/os/linux/bpf/btf.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const c = @import("../c.zig");
const zupnp = @import("../lib.zig");
const request = @import("request.zig");
const Server = @This();
const logger = std.log.scoped(.@"zupnp.web.Server");
arena: ArenaAllocator,
base_url: ?[:0]const u8 = null,
endpoints: std.ArrayList(request.Endpoint),
static_root_dir: ?[:0]const u8 = null,
pub fn init(allocator: Allocator) Server {
logger.debug("Callback init: GetInfo {d}; Open {d}; Read {d}; Seek {d}; Write {d}; Close {d}", .{
c.UpnpVirtualDir_set_GetInfoCallback(getInfo),
c.UpnpVirtualDir_set_OpenCallback(open),
c.UpnpVirtualDir_set_ReadCallback(read),
c.UpnpVirtualDir_set_SeekCallback(seek),
c.UpnpVirtualDir_set_WriteCallback(write),
c.UpnpVirtualDir_set_CloseCallback(close),
});
return Server {
.arena = ArenaAllocator.init(allocator),
.endpoints = std.ArrayList(request.Endpoint).init(allocator),
};
}
pub fn deinit(self: *Server) void {
for (self.endpoints.items) |endpoint| {
switch (endpoint.callbacks) {
.WithInstance => |cb| if (cb.deinitFn) |deinitFn| deinitFn(cb.instance),
.WithoutInstance => |cb| if (cb.deinitFn) |deinitFn| deinitFn(),
}
}
self.base_url = null;
self.endpoints.deinit();
self.arena.deinit();
}
/// FIXME if endpoint is created and Server (or ZUPnP) object's address is changed, a crash is guaranteed when making a request to that endpoint.
pub fn createEndpoint(self: *Server, comptime T: type, config: anytype, destination: [:0]const u8) !*T {
var instance = try self.arena.allocator().create(T);
errdefer self.arena.allocator().destroy(instance);
if (@hasDecl(T, "prepare")) {
try instance.prepare(config);
}
// TODO clean up this nuclear spill
try self.endpoints.append(.{
.allocator = self.arena.allocator(),
.callbacks =
if (@bitSizeOf(T) == 0) .{ .WithoutInstance = .{
.deinitFn = c.mutateCallback(T, "deinit", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithoutInstance), .deinitFn).field_type)),
.getFn = c.mutateCallback(T, "get", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithoutInstance), .getFn).field_type)),
.postFn = c.mutateCallback(T, "post", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithoutInstance), .postFn).field_type)),
}}
else .{ .WithInstance = .{
.instance = instance,
.deinitFn = c.mutateCallback(T, "deinit", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithInstance), .deinitFn).field_type)),
.getFn = c.mutateCallback(T, "get", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithInstance), .getFn).field_type)),
.postFn = c.mutateCallback(T, "post", std.meta.Child(std.meta.fieldInfo(std.meta.TagPayload(request.Endpoint.Callbacks, .WithInstance), .postFn).field_type)),
}}
,
});
errdefer { _ = self.endpoints.pop(); }
var old_cookie: ?*anyopaque = undefined;
if (c.is_error(c.UpnpAddVirtualDir(
destination,
@ptrCast(*const anyopaque, &self.endpoints.items[self.endpoints.items.len - 1]),
&old_cookie
))) |err| {
logger.err("Failed to add endpoint: {s}", .{err});
return zupnp.Error;
}
if (old_cookie != null) {
return zupnp.Error;
}
logger.info("Added endpoint {s}", .{destination});
return instance;
}
pub fn start(self: *Server) !void {
const err_code = if (self.static_root_dir) |srd|
c.UpnpSetWebServerRootDir(srd)
else
c.UpnpEnableWebserver(1)
;
if (c.is_error(err_code)) |err| {
logger.err("Failed to start server: {s}", .{err});
return zupnp.Error;
}
self.base_url = try std.fmt.allocPrintZ(self.arena.allocator(), "http://{s}:{d}", .{
c.UpnpGetServerIpAddress(),
c.UpnpGetServerPort()
});
logger.info("Started listening on {s}", .{self.base_url});
}
pub fn stop(self: *Server) void {
if (self.base_url != null) {
self.base_url = null;
}
c.UpnpSetWebServerRootDir(null);
logger.info("Stopped listening", .{});
}
/// Only used for GET and HEAD requests.
/// TODO optimize for HEAD requests.
fn getInfo(filename_c: [*c]const u8, info: ?*c.UpnpFileInfo, cookie: ?*const anyopaque, request_cookie: [*c]?*const anyopaque) callconv(.C) c_int {
const filename = std.mem.sliceTo(filename_c, 0);
const client_address = zupnp.util.ClientAddress.fromSockaddStorage(c.UpnpFileInfo_get_CtrlPtIPAddr(info));
logger.debug("GET {s} from {s}", .{filename, client_address.toString()});
const endpoint = request.Endpoint.fromCookie(cookie);
if (switch (endpoint.callbacks) {
.WithInstance => |cb| cb.getFn == null,
.WithoutInstance => |cb| cb.getFn == null,
}) {
logger.debug("No GET endpoint defined", .{});
return -1;
}
var req_cookie = request.RequestCookie.create(endpoint.allocator) catch |err| {
logger.err("Failed to create request cookie: {s}", .{err});
// TODO return early here
return -1;
};
const req = zupnp.web.ServerGetRequest {
.allocator = req_cookie.arena.allocator(),
.filename = filename,
.client_address = &client_address,
};
const response = switch (endpoint.callbacks) {
.WithInstance => |cb| (cb.getFn.?)(cb.instance, &req),
.WithoutInstance => |cb| (cb.getFn.?)(&req),
};
var return_code: c_int = 0;
var is_readable = true;
switch (response) {
.NotFound => return_code = -1,
.Forbidden => is_readable = false,
.Contents => |cnt| {
req_cookie.request = .{ .Get = request.GetRequest.init(cnt.contents) };
logger.debug("ContentType err {d} FileLength err {d}", .{
c.UpnpFileInfo_set_ContentType(info, cnt.content_type),
c.UpnpFileInfo_set_FileLength(info, @intCast(c_long, cnt.contents.len))
});
if (cnt.headers) |*headers| {
headers.addHeadersToList(c.UpnpFileInfo_get_ExtraHeadersList(info)) catch |err| {
logger.err("Failed to add headers: {s}", .{err});
return -1;
};
}
},
.Chunked => |chk| {
req_cookie.request = .{ .Chunked = request.ChunkedRequest.init(chk.handler) };
logger.debug("ContentType err {d} FileLength err {d}", .{
c.UpnpFileInfo_set_ContentType(info, chk.content_type),
c.UpnpFileInfo_set_FileLength(info, c.UPNP_USING_CHUNKED)
});
if (chk.headers) |*headers| {
headers.addHeadersToList(c.UpnpFileInfo_get_ExtraHeadersList(info)) catch |err| {
logger.err("Failed to add headers: {s}", .{err});
return -1;
};
}
},
}
logger.debug("IsReadable err {d}", .{c.UpnpFileInfo_set_IsReadable(info, @boolToInt(is_readable))});
if (return_code == 0 and is_readable) {
request_cookie.* = req_cookie;
}
else {
req_cookie.deinit();
}
return return_code;
}
fn open(filename_c: [*c]const u8, mode: c.enum_UpnpOpenFileMode, cookie: ?*const anyopaque, request_cookie: ?*const anyopaque) callconv(.C) c.UpnpWebFileHandle {
// UPNP_READ (i.e. GET) was already handled under get_info
if (mode == c.UPNP_WRITE) {
const filename = std.mem.sliceTo(filename_c, 0);
logger.debug("POST {s}", .{filename});
const endpoint = request.Endpoint.fromCookie(cookie);
if (switch (endpoint.callbacks) {
.WithInstance => |cb| cb.postFn == null,
.WithoutInstance => |cb| cb.postFn == null,
}) {
logger.debug("No POST endpoint defined", .{});
return null;
}
var req = request.PostRequest.createRequest(endpoint, filename) catch |err| {
logger.err("Failed to create POST request object: {s}", .{err});
return null;
};
return req.toFileHandle();
}
var req_cookie = request.RequestCookie.fromVoidPointer(request_cookie);
const req = req_cookie.toRequest() catch |err| {
logger.err("Failed to create GET request object: {s}", .{err});
return null;
};
return req.toFileHandle();
}
fn read(file_handle: c.UpnpWebFileHandle, buf: [*c]u8, buflen: usize, _: ?*const anyopaque, _: ?*const anyopaque) callconv(.C) c_int {
return dispatch(c_int, file_handle, "read", .{buf, buflen});
}
fn seek(file_handle: c.UpnpWebFileHandle, offset: c.off_t, origin: c_int, _: ?*const anyopaque, _: ?*const anyopaque) callconv(.C) c_int {
return dispatch(c_int, file_handle, "seek", .{offset, origin});
}
fn write(file_handle: c.UpnpWebFileHandle, buf: [*c]u8, buflen: usize, _: ?*const anyopaque, _: ?*const anyopaque) callconv(.C) c_int {
return dispatch(c_int, file_handle, "write", .{buf, buflen});
}
fn close(file_handle: c.UpnpWebFileHandle, _: ?*const anyopaque, request_cookie: ?*const anyopaque) callconv(.C) c_int {
const res = dispatch(c_int, file_handle, "close", .{});
dispatch(void, file_handle, "deinit", .{});
if (request_cookie) |rc| {
request.RequestCookie.fromVoidPointer(rc).deinit();
}
logger.debug("A connection has been closed", .{});
return res;
}
// TODO https://github.com/ziglang/zig/issues/7224
fn dispatch(comptime T: type, file_handle: c.UpnpWebFileHandle, comptime fnName: [:0]const u8, params: anytype) T {
const req = request.Request.fromFileHandle(file_handle);
return switch (req.*) {
.Get => |get| @call(.{}, @field(get, fnName), params),
.Post => |*post| @call(.{}, @field(post, fnName), params),
.Chunked => |chunked| @call(.{}, @field(chunked, fnName), params),
};
} | src/web/server.zig |
const std = @import("../index.zig");
const builtin = @import("builtin");
const assert = std.debug.assert;
const event = std.event;
const mem = std.mem;
const posix = std.os.posix;
const windows = std.os.windows;
const Loop = std.event.Loop;
pub const Server = struct {
handleRequestFn: async<*mem.Allocator> fn (*Server, *const std.net.Address, *const std.os.File) void,
loop: *Loop,
sockfd: ?i32,
accept_coro: ?promise,
listen_address: std.net.Address,
waiting_for_emfile_node: PromiseNode,
listen_resume_node: event.Loop.ResumeNode,
const PromiseNode = std.LinkedList(promise).Node;
pub fn init(loop: *Loop) Server {
// TODO can't initialize handler coroutine here because we need well defined copy elision
return Server{
.loop = loop,
.sockfd = null,
.accept_coro = null,
.handleRequestFn = undefined,
.waiting_for_emfile_node = undefined,
.listen_address = undefined,
.listen_resume_node = event.Loop.ResumeNode{
.id = event.Loop.ResumeNode.Id.Basic,
.handle = undefined,
},
};
}
pub fn listen(
self: *Server,
address: *const std.net.Address,
handleRequestFn: async<*mem.Allocator> fn (*Server, *const std.net.Address, *const std.os.File) void,
) !void {
self.handleRequestFn = handleRequestFn;
const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
errdefer std.os.close(sockfd);
self.sockfd = sockfd;
try std.os.posixBind(sockfd, &address.os_addr);
try std.os.posixListen(sockfd, posix.SOMAXCONN);
self.listen_address = std.net.Address.initPosix(try std.os.posixGetSockName(sockfd));
self.accept_coro = try async<self.loop.allocator> Server.handler(self);
errdefer cancel self.accept_coro.?;
self.listen_resume_node.handle = self.accept_coro.?;
try self.loop.linuxAddFd(sockfd, &self.listen_resume_node, posix.EPOLLIN | posix.EPOLLOUT | posix.EPOLLET);
errdefer self.loop.removeFd(sockfd);
}
/// Stop listening
pub fn close(self: *Server) void {
self.loop.linuxRemoveFd(self.sockfd.?);
std.os.close(self.sockfd.?);
}
pub fn deinit(self: *Server) void {
if (self.accept_coro) |accept_coro| cancel accept_coro;
if (self.sockfd) |sockfd| std.os.close(sockfd);
}
pub async fn handler(self: *Server) void {
while (true) {
var accepted_addr: std.net.Address = undefined;
if (std.os.posixAccept(self.sockfd.?, &accepted_addr.os_addr, posix.SOCK_NONBLOCK | posix.SOCK_CLOEXEC)) |accepted_fd| {
var socket = std.os.File.openHandle(accepted_fd);
_ = async<self.loop.allocator> self.handleRequestFn(self, accepted_addr, socket) catch |err| switch (err) {
error.OutOfMemory => {
socket.close();
continue;
},
};
} else |err| switch (err) {
error.WouldBlock => {
suspend; // we will get resumed by epoll_wait in the event loop
continue;
},
error.ProcessFdQuotaExceeded => {
errdefer std.os.emfile_promise_queue.remove(&self.waiting_for_emfile_node);
suspend {
self.waiting_for_emfile_node = PromiseNode.init(@handle());
std.os.emfile_promise_queue.append(&self.waiting_for_emfile_node);
}
continue;
},
error.ConnectionAborted, error.FileDescriptorClosed => continue,
error.PageFault => unreachable,
error.InvalidSyscall => unreachable,
error.FileDescriptorNotASocket => unreachable,
error.OperationNotSupported => unreachable,
error.SystemFdQuotaExceeded, error.SystemResources, error.ProtocolFailure, error.BlockedByFirewall, error.Unexpected => {
@panic("TODO handle this error");
},
}
}
}
};
pub async fn connect(loop: *Loop, _address: *const std.net.Address) !std.os.File {
var address = _address.*; // TODO https://github.com/ziglang/zig/issues/733
const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
errdefer std.os.close(sockfd);
try std.os.posixConnectAsync(sockfd, &address.os_addr);
try await try async loop.linuxWaitFd(sockfd, posix.EPOLLIN | posix.EPOLLOUT | posix.EPOLLET);
try std.os.posixGetSockOptConnectError(sockfd);
return std.os.File.openHandle(sockfd);
}
test "listen on a port, send bytes, receive bytes" {
if (builtin.os != builtin.Os.linux) {
// TODO build abstractions for other operating systems
return error.SkipZigTest;
}
const MyServer = struct {
tcp_server: Server,
const Self = this;
async<*mem.Allocator> fn handler(tcp_server: *Server, _addr: *const std.net.Address, _socket: *const std.os.File) void {
const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
defer socket.close();
// TODO guarantee elision of this allocation
const next_handler = async errorableHandler(self, _addr, socket) catch unreachable;
(await next_handler) catch |err| {
std.debug.panic("unable to handle connection: {}\n", err);
};
suspend {
cancel @handle();
}
}
async fn errorableHandler(self: *Self, _addr: *const std.net.Address, _socket: *const std.os.File) !void {
const addr = _addr.*; // TODO https://github.com/ziglang/zig/issues/733
var socket = _socket.*; // TODO https://github.com/ziglang/zig/issues/733
var adapter = std.io.FileOutStream.init(&socket);
var stream = &adapter.stream;
try stream.print("hello from server\n");
}
};
const ip4addr = std.net.parseIp4("127.0.0.1") catch unreachable;
const addr = std.net.Address.initIp4(ip4addr, 0);
var loop: Loop = undefined;
try loop.initSingleThreaded(std.debug.global_allocator);
var server = MyServer{ .tcp_server = Server.init(&loop) };
defer server.tcp_server.deinit();
try server.tcp_server.listen(addr, MyServer.handler);
const p = try async<std.debug.global_allocator> doAsyncTest(&loop, server.tcp_server.listen_address, &server.tcp_server);
defer cancel p;
loop.run();
}
async fn doAsyncTest(loop: *Loop, address: *const std.net.Address, server: *Server) void {
errdefer @panic("test failure");
var socket_file = try await try async connect(loop, address);
defer socket_file.close();
var buf: [512]u8 = undefined;
const amt_read = try socket_file.read(buf[0..]);
const msg = buf[0..amt_read];
assert(mem.eql(u8, msg, "hello from server\n"));
server.close();
} | std/event/tcp.zig |
const std = @import("std");
const tls = @import("iguanaTLS");
const network = @import("network");
pub const Backend = enum {
network,
std,
experimental,
};
const backend: Backend = std.meta.globalOption("zfetch_backend", Backend) orelse .network;
const Socket = switch (backend) {
.network => network.Socket,
.std => std.net.Stream,
.experimental => std.x.net.tcp.Client,
};
// std.x.net.tcp.Client's "Reader" decl is not a std.io.Reader.
const SocketReader = @typeInfo(@TypeOf(Socket.reader)).Fn.return_type.?;
const SocketWriter = @typeInfo(@TypeOf(Socket.writer)).Fn.return_type.?;
const SecureContext = tls.Client(SocketReader, SocketWriter, tls.ciphersuites.all, true);
/// The protocol which a connection should use. This dictates the default port and whether or not a TLS connection
/// should be established.
pub const Protocol = enum {
http,
https,
pub fn defaultPort(self: Protocol) u16 {
return switch (self) {
.http => 80,
.https => 443,
};
}
};
pub const init = network.init;
pub const deinit = network.deinit;
/// A wrapper around TCP + TLS and raw TCP streams that provides a connection agnostic interface.
pub const Connection = struct {
allocator: *std.mem.Allocator,
/// The hostname that this connection was initiated with.
hostname: []const u8,
/// The protocol that this connection was initiated with.
protocol: Protocol,
/// The port that this connection was initiated with.
port: u16,
/// The underlying network socket.
socket: Socket,
/// The TLS context if the connection is using TLS.
context: SecureContext = undefined,
/// The TLS context's trust chain.
trust_chain: ?tls.x509.CertificateChain = null,
/// Form a connection to the requested hostname and port.
pub fn connect(allocator: *std.mem.Allocator, hostname: []const u8, port: ?u16, protocol: Protocol, trust_chain: ?tls.x509.CertificateChain) !Connection {
const host_dupe = try allocator.dupe(u8, hostname);
errdefer allocator.free(host_dupe);
const real_port = port orelse protocol.defaultPort();
const socket = switch (backend) {
.network => try network.connectToHost(allocator, host_dupe, real_port, .tcp),
.std => try std.net.tcpConnectToHost(allocator, host_dupe, real_port),
.experimental => @compileError("backend not yet supported, std.x.net does not support hostname resolution, connect will not work"),
};
var conn = Connection{
.allocator = allocator,
.hostname = host_dupe,
.protocol = protocol,
.port = real_port,
.socket = socket,
.trust_chain = trust_chain,
};
errdefer conn.socket.close();
try conn.setupTlsContext(trust_chain);
return conn;
}
pub fn reconnect(self: *Connection) !void {
self.socket.close();
if (self.protocol == .https) {
self.context.close_notify() catch {};
}
self.socket = switch (backend) {
.network => try network.connectToHost(self.allocator, self.host_dupe, self.port, .tcp),
.std => try std.net.tcpConnectToHost(self.allocator, self.host_dupe, self.port),
.experimental => @compileError("backend not yet supported, std.x.net does not support hostname resolution"),
};
if (self.protocol == .https) {
try self.setupTlsContext(self.trust_chain);
}
}
fn setupTlsContext(self: *Connection, trust: ?tls.x509.CertificateChain) !void {
switch (self.protocol) {
.http => {
self.context = undefined;
},
.https => {
if (trust) |trust_chain| {
self.context = try tls.client_connect(.{
.reader = self.socket.reader(),
.writer = self.socket.writer(),
.cert_verifier = .default,
.trusted_certificates = trust_chain.data.items,
.temp_allocator = self.allocator,
.ciphersuites = tls.ciphersuites.all,
.protocols = &[_][]const u8{"http/1.1"},
}, self.hostname);
} else {
self.context = try tls.client_connect(.{
.reader = self.socket.reader(),
.writer = self.socket.writer(),
.cert_verifier = .none,
.temp_allocator = self.allocator,
.ciphersuites = tls.ciphersuites.all,
.protocols = &[_][]const u8{"http/1.1"},
}, self.hostname);
}
},
}
}
/// Close this connection.
pub fn close(self: *Connection) void {
if (self.protocol == .https) {
self.context.close_notify() catch {};
}
self.socket.close();
self.allocator.free(self.hostname);
}
pub const ReadError = SecureContext.Reader.Error;
pub const Reader = std.io.Reader(*Connection, ReadError, read);
pub fn read(self: *Connection, buffer: []u8) ReadError!usize {
return switch (self.protocol) {
.http => switch (backend) {
.network => self.socket.receive(buffer),
.std => self.socket.read(buffer),
.experimental => @compileError("backend not yet supported, std.x.net does not support hostname resolution"),
},
.https => self.context.read(buffer),
};
}
pub fn reader(self: *Connection) Reader {
return .{ .context = self };
}
pub const WriteError = SecureContext.Writer.Error;
pub const Writer = std.io.Writer(*Connection, WriteError, write);
pub fn write(self: *Connection, buffer: []const u8) WriteError!usize {
return switch (self.protocol) {
.http => switch (backend) {
.network => self.socket.send(buffer),
.std => self.socket.write(buffer),
.experimental => @compileError("backend not yet supported, std.x.net does not support hostname resolution"),
},
.https => self.context.write(buffer),
};
}
pub fn writer(self: *Connection) Writer {
return .{ .context = self };
}
};
test "can http?" {
try network.init();
var conn = try Connection.connect(std.testing.allocator, "en.wikipedia.org", null, .http, null);
defer conn.close();
try conn.writer().writeAll("GET / HTTP/1.1\r\nHost: en.wikipedia.org\r\nAccept: */*\r\n\r\n");
var buf = try conn.reader().readUntilDelimiterAlloc(std.testing.allocator, '\r', std.math.maxInt(usize));
defer std.testing.allocator.free(buf);
try std.testing.expectEqualStrings("HTTP/1.1 301 TLS Redirect", buf);
}
test "can https?" {
try network.init();
var conn = try Connection.connect(std.testing.allocator, "en.wikipedia.org", null, .https, null);
defer conn.close();
try conn.writer().writeAll("GET / HTTP/1.1\r\nHost: en.wikipedia.org\r\nAccept: */*\r\n\r\n");
var buf = try conn.reader().readUntilDelimiterAlloc(std.testing.allocator, '\r', std.math.maxInt(usize));
defer std.testing.allocator.free(buf);
try std.testing.expectEqualStrings("HTTP/1.1 301 Moved Permanently", buf);
}
comptime {
std.testing.refAllDecls(@This());
} | src/connection.zig |
const std = @import("std");
const os = std.os;
const mem = std.mem;
const elf = std.elf;
const builtin = @import("builtin");
const assert = std.debug.assert;
// This file implements the two TLS variants [1] used by ELF-based systems.
//
// The variant I has the following layout in memory:
// -------------------------------------------------------
// | DTV | Zig | DTV | Alignment | TLS |
// | storage | thread data | pointer | | block |
// ------------------------^------------------------------
// `-- The thread pointer register points here
//
// In this case we allocate additional space for our control structure that's
// placed _before_ the DTV pointer together with the DTV.
//
// NOTE: Some systems such as power64 or mips use this variant with a twist: the
// alignment is not present and the tp and DTV addresses are offset by a
// constant.
//
// On the other hand the variant II has the following layout in memory:
// ---------------------------------------
// | TLS | TCB | Zig | DTV |
// | block | | thread data | storage |
// --------^------------------------------
// `-- The thread pointer register points here
//
// The structure of the TCB is not defined by the ABI so we reserve enough space
// for a single pointer as some architectures such as i386 and x86_64 need a
// pointer to the TCB block itself at the address pointed by the tp.
//
// In this case the control structure and DTV are placed one after another right
// after the TLS block data.
//
// At the moment the DTV is very simple since we only support static TLS, all we
// need is a two word vector to hold the number of entries (1) and the address
// of the first TLS block.
//
// [1] https://www.akkadia.org/drepper/tls.pdf
const TLSVariant = enum {
VariantI,
VariantII,
};
const tls_variant = switch (builtin.arch) {
.arm, .armeb, .aarch64, .aarch64_be, .riscv32, .riscv64, .mipsel => TLSVariant.VariantI,
.x86_64, .i386 => TLSVariant.VariantII,
else => @compileError("undefined tls_variant for this architecture"),
};
// Controls how many bytes are reserved for the Thread Control Block
const tls_tcb_size = switch (builtin.arch) {
// ARM EABI mandates enough space for two pointers: the first one points to
// the DTV while the second one is unspecified but reserved
.arm, .armeb, .aarch64, .aarch64_be => 2 * @sizeOf(usize),
else => @sizeOf(usize),
};
// Controls if the TCB should be aligned according to the TLS segment p_align
const tls_tcb_align_size = switch (builtin.arch) {
.arm, .armeb, .aarch64, .aarch64_be => true,
else => false,
};
// Controls if the TP points to the end of the TCB instead of its beginning
const tls_tp_points_past_tcb = switch (builtin.arch) {
.riscv32, .riscv64, .mipsel, .powerpc64, .powerpc64le => true,
else => false,
};
// Check if the architecture-specific parameters look correct
comptime {
if (tls_tcb_align_size and tls_variant != TLSVariant.VariantI) {
@compileError("tls_tcb_align_size is only meaningful for variant I TLS");
}
}
// Some architectures add some offset to the tp and dtv addresses in order to
// make the generated code more efficient
const tls_tp_offset = switch (builtin.arch) {
.mipsel => 0x7000,
else => 0,
};
const tls_dtv_offset = switch (builtin.arch) {
.mipsel => 0x8000,
.riscv32, .riscv64 => 0x800,
else => 0,
};
// Per-thread storage for Zig's use
const CustomData = packed struct {};
// Dynamic Thread Vector
const DTV = packed struct {
entries: usize,
tls_block: [1]usize,
};
// Holds all the information about the process TLS image
const TLSImage = struct {
data_src: []u8,
alloc_size: usize,
tcb_offset: usize,
dtv_offset: usize,
data_offset: usize,
// Only used on the i386 architecture
gdt_entry_number: usize,
};
pub var tls_image: ?TLSImage = null;
pub fn setThreadPointer(addr: usize) void {
switch (builtin.arch) {
.i386 => {
var user_desc = std.os.linux.user_desc{
.entry_number = tls_image.?.gdt_entry_number,
.base_addr = addr,
.limit = 0xfffff,
.seg_32bit = 1,
.contents = 0, // Data
.read_exec_only = 0,
.limit_in_pages = 1,
.seg_not_present = 0,
.useable = 1,
};
const rc = std.os.linux.syscall1(std.os.linux.SYS_set_thread_area, @ptrToInt(&user_desc));
assert(rc == 0);
const gdt_entry_number = user_desc.entry_number;
// We have to keep track of our slot as it's also needed for clone()
tls_image.?.gdt_entry_number = gdt_entry_number;
// Update the %gs selector
asm volatile ("movl %[gs_val], %%gs"
:
: [gs_val] "r" (gdt_entry_number << 3 | 3)
);
},
.x86_64 => {
const rc = std.os.linux.syscall2(std.os.linux.SYS_arch_prctl, std.os.linux.ARCH_SET_FS, addr);
assert(rc == 0);
},
.aarch64 => {
asm volatile (
\\ msr tpidr_el0, %[addr]
:
: [addr] "r" (addr)
);
},
.arm => |arm| {
const rc = std.os.linux.syscall1(std.os.linux.SYS_set_tls, addr);
assert(rc == 0);
},
.riscv64 => {
asm volatile (
\\ mv tp, %[addr]
:
: [addr] "r" (addr)
);
},
.mipsel => {
const rc = std.os.linux.syscall1(std.os.linux.SYS_set_thread_area, addr);
assert(rc == 0);
},
else => @compileError("Unsupported architecture"),
}
}
pub fn initTLS() ?*elf.Phdr {
var tls_phdr: ?*elf.Phdr = null;
var img_base: usize = 0;
const auxv = std.os.linux.elf_aux_maybe.?;
var at_phent: usize = undefined;
var at_phnum: usize = undefined;
var at_phdr: usize = undefined;
var at_hwcap: usize = undefined;
var i: usize = 0;
while (auxv[i].a_type != std.elf.AT_NULL) : (i += 1) {
switch (auxv[i].a_type) {
elf.AT_PHENT => at_phent = auxv[i].a_un.a_val,
elf.AT_PHNUM => at_phnum = auxv[i].a_un.a_val,
elf.AT_PHDR => at_phdr = auxv[i].a_un.a_val,
elf.AT_HWCAP => at_hwcap = auxv[i].a_un.a_val,
else => continue,
}
}
// Sanity check
assert(at_phent == @sizeOf(elf.Phdr));
// Search the TLS section
const phdrs = (@intToPtr([*]elf.Phdr, at_phdr))[0..at_phnum];
var gnu_stack: ?*elf.Phdr = null;
for (phdrs) |*phdr| {
switch (phdr.p_type) {
elf.PT_PHDR => img_base = at_phdr - phdr.p_vaddr,
elf.PT_TLS => tls_phdr = phdr,
elf.PT_GNU_STACK => gnu_stack = phdr,
else => continue,
}
}
if (tls_phdr) |phdr| {
// If the cpu is arm-based, check if it supports the TLS register
if (builtin.arch == builtin.Arch.arm and at_hwcap & std.os.linux.HWCAP_TLS == 0) {
// If the CPU does not support TLS via a coprocessor register,
// a kernel helper function can be used instead on certain linux kernels.
// See linux/arch/arm/include/asm/tls.h and musl/src/thread/arm/__set_thread_area.c.
@panic("TODO: Implement ARM fallback TLS functionality");
}
// Offsets into the allocated TLS area
var tcb_offset: usize = undefined;
var dtv_offset: usize = undefined;
var data_offset: usize = undefined;
var thread_data_offset: usize = undefined;
// Compute the total size of the ABI-specific data plus our own control
// structures
const alloc_size = switch (tls_variant) {
.VariantI => blk: {
var l: usize = 0;
dtv_offset = l;
l += @sizeOf(DTV);
thread_data_offset = l;
l += @sizeOf(CustomData);
l = mem.alignForward(l, phdr.p_align);
tcb_offset = l;
if (tls_tcb_align_size) {
l += mem.alignForward(tls_tcb_size, phdr.p_align);
} else {
l += tls_tcb_size;
}
data_offset = l;
l += phdr.p_memsz;
break :blk l;
},
.VariantII => blk: {
var l: usize = 0;
data_offset = l;
l += phdr.p_memsz;
l = mem.alignForward(l, phdr.p_align);
tcb_offset = l;
l += tls_tcb_size;
thread_data_offset = l;
l += @sizeOf(CustomData);
dtv_offset = l;
l += @sizeOf(DTV);
break :blk l;
},
};
tls_image = TLSImage{
.data_src = @intToPtr([*]u8, phdr.p_vaddr + img_base)[0..phdr.p_filesz],
.alloc_size = alloc_size,
.tcb_offset = tcb_offset,
.dtv_offset = dtv_offset,
.data_offset = data_offset,
.gdt_entry_number = @bitCast(usize, @as(isize, -1)),
};
}
return gnu_stack;
}
pub fn copyTLS(addr: usize) usize {
const tls_img = tls_image.?;
// Be paranoid, clear the area we're going to use
@memset(@intToPtr([*]u8, addr), 0, tls_img.alloc_size);
// Prepare the DTV
const dtv = @intToPtr(*DTV, addr + tls_img.dtv_offset);
dtv.entries = 1;
dtv.tls_block[0] = addr + tls_img.data_offset + tls_dtv_offset;
// Set-up the TCB
// Force the alignment to 1 byte as the TCB may start from a non-aligned
// address under the variant II model
const tcb_ptr = @intToPtr(*align(1) usize, addr + tls_img.tcb_offset);
if (tls_variant == TLSVariant.VariantI) {
tcb_ptr.* = addr + tls_img.dtv_offset;
} else {
tcb_ptr.* = addr + tls_img.tcb_offset;
}
// Copy the data
@memcpy(@intToPtr([*]u8, addr + tls_img.data_offset), tls_img.data_src.ptr, tls_img.data_src.len);
// Return the corrected (if needed) value for the tp register
return addr + tls_tp_offset +
if (tls_tp_points_past_tcb) tls_img.data_offset else tls_img.tcb_offset;
}
var main_thread_tls_buffer: [256]u8 align(32) = undefined;
pub fn allocateTLS(size: usize) usize {
// Small TLS allocation, use our local buffer
if (size < main_thread_tls_buffer.len) {
return @ptrToInt(&main_thread_tls_buffer);
}
const slice = os.mmap(
null,
size,
os.PROT_READ | os.PROT_WRITE,
os.MAP_PRIVATE | os.MAP_ANONYMOUS,
-1,
0,
) catch @panic("out of memory");
return @ptrToInt(slice.ptr);
} | lib/std/os/linux/tls.zig |
const std = @import("std");
const Builder = std.build.Builder;
const glfw = @import("libs/mach-glfw/build.zig");
const system_sdk = @import("libs/mach-glfw/system_sdk.zig");
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const options = Options{
.from_source = b.option(bool, "dawn-from-source", "Build Dawn from source") orelse false,
};
const lib = b.addStaticLibrary("gpu", "src/main.zig");
lib.setBuildMode(mode);
lib.setTarget(target);
lib.install();
link(b, lib, options);
const main_tests = b.addTest("src/main.zig");
main_tests.setBuildMode(mode);
const test_step = b.step("test", "Run library tests");
test_step.dependOn(&main_tests.step);
const dawn_example = b.addExecutable("dawn-example", "src/dawn/hello_triangle.zig");
dawn_example.setBuildMode(mode);
dawn_example.setTarget(target);
link(b, dawn_example, options);
glfw.link(b, dawn_example, .{ .system_sdk = .{ .set_sysroot = false } });
dawn_example.addPackagePath("glfw", "libs/mach-glfw/src/main.zig");
dawn_example.install();
const dawn_example_run_cmd = dawn_example.run();
dawn_example_run_cmd.step.dependOn(b.getInstallStep());
const dawn_example_run_step = b.step("run-dawn-example", "Run the dawn example");
dawn_example_run_step.dependOn(&dawn_example_run_cmd.step);
}
pub const LinuxWindowManager = enum {
X11,
Wayland,
};
pub const Options = struct {
/// Defaults to X11 on Linux.
linux_window_manager: ?LinuxWindowManager = null,
/// Defaults to true on Windows
d3d12: ?bool = null,
/// Defaults to true on Darwin
metal: ?bool = null,
/// Defaults to true on Linux, Fuchsia
// TODO(build-system): enable on Windows if we can cross compile Vulkan
vulkan: ?bool = null,
/// Defaults to true on Linux
desktop_gl: ?bool = null,
/// Defaults to true on Android, Linux, Windows, Emscripten
// TODO(build-system): not respected at all currently
opengl_es: ?bool = null,
/// Whether or not minimal debug symbols should be emitted. This is -g1 in most cases, enough to
/// produce stack traces but omitting debug symbols for locals. For spirv-tools and tint in
/// specific, -g0 will be used (no debug symbols at all) to save an additional ~39M.
///
/// When enabled, a debug build of the static library goes from ~947M to just ~53M.
minimal_debug_symbols: bool = true,
/// Whether or not to produce separate static libraries for each component of Dawn (reduces
/// iteration times when building from source / testing changes to Dawn source code.)
separate_libs: bool = false,
/// Whether to build Dawn from source or not.
from_source: bool = false,
/// The binary release version to use from https://github.com/hexops/mach-gpu-dawn/releases
binary_version: []const u8 = "release-5fe08ee",
/// Detects the default options to use for the given target.
pub fn detectDefaults(self: Options, target: std.Target) Options {
const tag = target.os.tag;
const linux_desktop_like = isLinuxDesktopLike(target);
var options = self;
if (options.linux_window_manager == null and linux_desktop_like) options.linux_window_manager = .X11;
if (options.d3d12 == null) options.d3d12 = tag == .windows;
if (options.metal == null) options.metal = tag.isDarwin();
if (options.vulkan == null) options.vulkan = tag == .fuchsia or linux_desktop_like;
// TODO(build-system): technically Dawn itself defaults desktop_gl to true on Windows.
if (options.desktop_gl == null) options.desktop_gl = linux_desktop_like;
options.opengl_es = false; // TODO(build-system): OpenGL ES
// if (options.opengl_es == null) options.opengl_es = tag == .windows or tag == .emscripten or target.isAndroid() or linux_desktop_like;
return options;
}
pub fn appendFlags(self: Options, flags: *std.ArrayList([]const u8), zero_debug_symbols: bool, is_cpp: bool) !void {
if (self.minimal_debug_symbols) {
if (zero_debug_symbols) try flags.append("-g0") else try flags.append("-g1");
}
if (is_cpp) try flags.append("-std=c++17");
if (self.linux_window_manager != null and self.linux_window_manager.? == .X11) try flags.append("-DDAWN_USE_X11");
}
};
pub fn link(b: *Builder, step: *std.build.LibExeObjStep, options: Options) void {
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
const opt = options.detectDefaults(target);
if (options.from_source) linkFromSource(b, step, opt) else linkFromBinary(b, step, opt);
}
fn linkFromSource(b: *Builder, step: *std.build.LibExeObjStep, options: Options) void {
ensureSubmodules(b.allocator) catch |err| @panic(@errorName(err));
step.addIncludeDir(thisDir() ++ "/libs/dawn/out/Debug/gen/include");
step.addIncludeDir(thisDir() ++ "/libs/dawn/include");
step.addIncludeDir(thisDir() ++ "/src/dawn");
if (options.separate_libs) {
const lib_mach_dawn_native = buildLibMachDawnNative(b, step, options);
step.linkLibrary(lib_mach_dawn_native);
const lib_dawn_common = buildLibDawnCommon(b, step, options);
step.linkLibrary(lib_dawn_common);
const lib_dawn_platform = buildLibDawnPlatform(b, step, options);
step.linkLibrary(lib_dawn_platform);
// dawn-native
const lib_abseil_cpp = buildLibAbseilCpp(b, step, options);
step.linkLibrary(lib_abseil_cpp);
const lib_dawn_native = buildLibDawnNative(b, step, options);
step.linkLibrary(lib_dawn_native);
if (options.d3d12.?) {
const lib_dxcompiler = buildLibDxcompiler(b, step, options);
step.linkLibrary(lib_dxcompiler);
}
const lib_dawn_wire = buildLibDawnWire(b, step, options);
step.linkLibrary(lib_dawn_wire);
const lib_dawn_utils = buildLibDawnUtils(b, step, options);
step.linkLibrary(lib_dawn_utils);
const lib_spirv_tools = buildLibSPIRVTools(b, step, options);
step.linkLibrary(lib_spirv_tools);
const lib_tint = buildLibTint(b, step, options);
step.linkLibrary(lib_tint);
return;
}
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const lib_dawn = b.addStaticLibrary("dawn", main_abs);
lib_dawn.install();
lib_dawn.setBuildMode(step.build_mode);
lib_dawn.setTarget(step.target);
lib_dawn.linkLibCpp();
step.linkLibrary(lib_dawn);
_ = buildLibMachDawnNative(b, lib_dawn, options);
_ = buildLibDawnCommon(b, lib_dawn, options);
_ = buildLibDawnPlatform(b, lib_dawn, options);
_ = buildLibAbseilCpp(b, lib_dawn, options);
_ = buildLibDawnNative(b, lib_dawn, options);
_ = buildLibDawnWire(b, lib_dawn, options);
_ = buildLibDawnUtils(b, lib_dawn, options);
_ = buildLibSPIRVTools(b, lib_dawn, options);
_ = buildLibTint(b, lib_dawn, options);
if (options.d3d12.?) _ = buildLibDxcompiler(b, lib_dawn, options);
}
fn ensureSubmodules(allocator: std.mem.Allocator) !void {
if (std.process.getEnvVarOwned(allocator, "NO_ENSURE_SUBMODULES")) |no_ensure_submodules| {
if (std.mem.eql(u8, no_ensure_submodules, "true")) return;
} else |_| {}
const child = try std.ChildProcess.init(&.{ "git", "submodule", "update", "--init", "--recursive" }, allocator);
child.cwd = thisDir();
child.stderr = std.io.getStdErr();
child.stdout = std.io.getStdOut();
_ = try child.spawnAndWait();
}
pub fn linkFromBinary(b: *Builder, step: *std.build.LibExeObjStep, options: Options) void {
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
const binaries_available = switch (target.os.tag) {
.windows => target.abi.isGnu(),
.linux => target.cpu.arch.isX86() and (target.abi.isGnu() or target.abi.isMusl()),
.macos => blk: {
if (!target.cpu.arch.isX86() and !target.cpu.arch.isAARCH64()) break :blk false;
if (!target.abi.isGnu()) break :blk false;
// If min. target macOS version is lesser than the min version we have available, then
// our binary is incompatible with the target.
const min_available = std.builtin.Version{ .major = 12, .minor = 0 };
if (target.os.version_range.semver.min.order(min_available) == .lt) break :blk false;
break :blk true;
},
else => false,
};
if (!binaries_available) {
const zig_triple = target.zigTriple(b.allocator) catch unreachable;
std.log.err("gpu-dawn binaries for {s} not available.", .{zig_triple});
std.log.err("-> open an issue: https://github.com/hexops/mach/issues", .{});
std.log.err("-> build from source (takes 5-15 minutes):", .{});
std.log.err(" use -Ddawn-from-source=true or set `Options.from_source = true`\n", .{});
if (target.os.tag == .macos) {
std.log.err("", .{});
if (target.cpu.arch.isX86()) std.log.err("-> Did you mean to use -Dtarget=x86_64-macos.12 ?", .{});
if (target.cpu.arch.isAARCH64()) std.log.err("-> Did you mean to use -Dtarget=aarch64-macos.12 ?", .{});
}
std.process.exit(1);
}
// Remove OS version range / glibc version from triple (we do not include that in our download
// URLs.)
var binary_target = std.zig.CrossTarget.fromTarget(target);
binary_target.os_version_min = .{ .none = .{} };
binary_target.os_version_max = .{ .none = .{} };
binary_target.glibc_version = null;
const zig_triple = binary_target.zigTriple(b.allocator) catch unreachable;
ensureBinaryDownloaded(b.allocator, zig_triple, b.is_release, target.os.tag == .windows, options.binary_version);
const base_cache_dir_rel = std.fs.path.join(b.allocator, &.{ "zig-cache", "mach", "gpu-dawn" }) catch unreachable;
std.fs.cwd().makePath(base_cache_dir_rel) catch unreachable;
const base_cache_dir = std.fs.cwd().realpathAlloc(b.allocator, base_cache_dir_rel) catch unreachable;
const commit_cache_dir = std.fs.path.join(b.allocator, &.{ base_cache_dir, options.binary_version }) catch unreachable;
const release_tag = if (b.is_release) "release-fast" else "debug";
const target_cache_dir = std.fs.path.join(b.allocator, &.{ commit_cache_dir, zig_triple, release_tag }) catch unreachable;
const include_dir = std.fs.path.join(b.allocator, &.{ commit_cache_dir, "include" }) catch unreachable;
step.addLibraryPath(target_cache_dir);
step.linkSystemLibrary("dawn");
step.linkLibCpp();
step.addIncludeDir(include_dir);
step.addIncludeDir(thisDir() ++ "/src/dawn");
if (options.linux_window_manager != null and options.linux_window_manager.? == .X11) {
step.linkSystemLibrary("X11");
}
if (options.metal.?) {
step.linkFramework("Metal");
step.linkFramework("CoreGraphics");
step.linkFramework("Foundation");
step.linkFramework("IOKit");
step.linkFramework("IOSurface");
step.linkFramework("QuartzCore");
}
if (options.d3d12.?) {
step.linkSystemLibrary("ole32");
step.linkSystemLibrary("dxguid");
}
}
pub fn ensureBinaryDownloaded(
allocator: std.mem.Allocator,
zig_triple: []const u8,
is_release: bool,
is_windows: bool,
version: []const u8,
) void {
// If zig-cache/mach/gpu-dawn/<git revision> does not exist:
// If on a commit in the main branch => rm -r zig-cache/mach/gpu-dawn/
// else => noop
// If zig-cache/mach/gpu-dawn/<git revision>/<target> exists:
// noop
// else:
// Download archive to zig-cache/mach/gpu-dawn/download/macos-aarch64
// Extract to zig-cache/mach/gpu-dawn/<git revision>/macos-aarch64/libgpu.a
// Remove zig-cache/mach/gpu-dawn/download
const base_cache_dir_rel = std.fs.path.join(allocator, &.{ "zig-cache", "mach", "gpu-dawn" }) catch unreachable;
std.fs.cwd().makePath(base_cache_dir_rel) catch unreachable;
const base_cache_dir = std.fs.cwd().realpathAlloc(allocator, base_cache_dir_rel) catch unreachable;
const commit_cache_dir = std.fs.path.join(allocator, &.{ base_cache_dir, version }) catch unreachable;
if (!dirExists(commit_cache_dir)) {
// Commit cache dir does not exist. If the commit we're on is in the main branch, we're
// probably moving to a newer commit and so we should cleanup older cached binaries.
const current_git_commit = getCurrentGitCommit(allocator) catch unreachable;
if (gitBranchContainsCommit(allocator, "main", current_git_commit) catch false) {
std.fs.deleteTreeAbsolute(base_cache_dir) catch {};
}
}
const release_tag = if (is_release) "release-fast" else "debug";
const target_cache_dir = std.fs.path.join(allocator, &.{ commit_cache_dir, zig_triple, release_tag }) catch unreachable;
if (dirExists(target_cache_dir)) {
return; // nothing to do, already have the binary
}
downloadBinary(allocator, commit_cache_dir, release_tag, target_cache_dir, zig_triple, is_windows, version) catch |err| {
// A download failed, or extraction failed, so wipe out the directory to ensure we correctly
// try again next time.
std.fs.deleteTreeAbsolute(base_cache_dir) catch {};
std.log.err("mach/gpu-dawn: prebuilt binary download failed: {s}", .{@errorName(err)});
std.process.exit(1);
};
}
fn downloadBinary(
allocator: std.mem.Allocator,
commit_cache_dir: []const u8,
release_tag: []const u8,
target_cache_dir: []const u8,
zig_triple: []const u8,
is_windows: bool,
version: []const u8,
) !void {
try ensureCanDownloadFiles(allocator);
const download_dir = try std.fs.path.join(allocator, &.{ target_cache_dir, "download" });
try std.fs.cwd().makePath(download_dir);
// Replace "..." with "---" because GitHub releases has very weird restrictions on file names.
// https://twitter.com/slimsag/status/1498025997987315713
const github_triple = try std.mem.replaceOwned(u8, allocator, zig_triple, "...", "---");
// Compose the download URL, e.g.:
// https://github.com/hexops/mach-gpu-dawn/releases/download/release-6b59025/libdawn_x86_64-macos-gnu_debug.a.gz
const lib_prefix = if (is_windows) "dawn_" else "libdawn_";
const lib_ext = if (is_windows) ".lib" else ".a";
const lib_file_name = if (is_windows) "dawn.lib" else "libdawn.a";
const download_url = try std.mem.concat(allocator, u8, &.{
"https://github.com/hexops/mach-gpu-dawn/releases/download/",
version,
"/",
lib_prefix,
github_triple,
"_",
release_tag,
lib_ext,
".gz",
});
// Download and decompress libdawn
const gz_target_file = try std.fs.path.join(allocator, &.{ download_dir, "compressed.gz" });
try downloadFile(allocator, gz_target_file, download_url);
const target_file = try std.fs.path.join(allocator, &.{ target_cache_dir, lib_file_name });
try gzipDecompress(allocator, gz_target_file, target_file);
// If we don't yet have the headers (these are shared across architectures), download them.
const include_dir = try std.fs.path.join(allocator, &.{ commit_cache_dir, "include" });
if (!dirExists(include_dir)) {
// Compose the headers download URL, e.g.:
// https://github.com/hexops/mach-gpu-dawn/releases/download/release-6b59025/headers.json.gz
const headers_download_url = try std.mem.concat(allocator, u8, &.{
"https://github.com/hexops/mach-gpu-dawn/releases/download/",
version,
"/headers.json.gz",
});
// Download and decompress headers.json.gz
const headers_gz_target_file = try std.fs.path.join(allocator, &.{ download_dir, "headers.json.gz" });
try downloadFile(allocator, headers_gz_target_file, headers_download_url);
const headers_target_file = try std.fs.path.join(allocator, &.{ target_cache_dir, "headers.json" });
try gzipDecompress(allocator, headers_gz_target_file, headers_target_file);
// Extract headers JSON archive.
try extractHeaders(allocator, headers_target_file, commit_cache_dir);
}
try std.fs.deleteTreeAbsolute(download_dir);
}
fn extractHeaders(allocator: std.mem.Allocator, json_file: []const u8, out_dir: []const u8) !void {
const contents = try std.fs.cwd().readFileAlloc(allocator, json_file, std.math.maxInt(usize));
var parser = std.json.Parser.init(allocator, false);
defer parser.deinit();
var tree = try parser.parse(contents);
defer tree.deinit();
var iter = tree.root.Object.iterator();
while (iter.next()) |f| {
const out_path = try std.fs.path.join(allocator, &.{ out_dir, f.key_ptr.* });
try std.fs.cwd().makePath(std.fs.path.dirname(out_path).?);
var new_file = try std.fs.createFileAbsolute(out_path, .{});
defer new_file.close();
try new_file.writeAll(f.value_ptr.*.String);
}
}
fn dirExists(path: []const u8) bool {
var dir = std.fs.openDirAbsolute(path, .{}) catch return false;
dir.close();
return true;
}
fn gzipDecompress(allocator: std.mem.Allocator, src_absolute_path: []const u8, dst_absolute_path: []const u8) !void {
var file = try std.fs.openFileAbsolute(src_absolute_path, .{ .mode = .read_only });
defer file.close();
var gzip_stream = try std.compress.gzip.gzipStream(allocator, file.reader());
defer gzip_stream.deinit();
// Read and decompress the whole file
const buf = try gzip_stream.reader().readAllAlloc(allocator, std.math.maxInt(usize));
defer allocator.free(buf);
var new_file = try std.fs.createFileAbsolute(dst_absolute_path, .{});
defer new_file.close();
try new_file.writeAll(buf);
}
fn gitBranchContainsCommit(allocator: std.mem.Allocator, branch: []const u8, commit: []const u8) !bool {
const result = try std.ChildProcess.exec(.{
.allocator = allocator,
.argv = &.{ "git", "branch", branch, "--contains", commit },
.cwd = thisDir(),
});
return result.term.Exited == 0;
}
fn getCurrentGitCommit(allocator: std.mem.Allocator) ![]const u8 {
const result = try std.ChildProcess.exec(.{
.allocator = allocator,
.argv = &.{ "git", "rev-parse", "HEAD" },
.cwd = thisDir(),
});
if (result.stdout.len > 0) return result.stdout[0 .. result.stdout.len - 1]; // trim newline
return result.stdout;
}
fn gitClone(allocator: std.mem.Allocator, repository: []const u8, dir: []const u8) !bool {
const result = try std.ChildProcess.exec(.{
.allocator = allocator,
.argv = &.{ "git", "clone", repository, dir },
.cwd = thisDir(),
});
return result.term.Exited == 0;
}
fn downloadFile(allocator: std.mem.Allocator, target_file: []const u8, url: []const u8) !void {
std.debug.print("downloading {s}..\n", .{url});
const child = try std.ChildProcess.init(&.{ "curl", "-L", "-o", target_file, url }, allocator);
child.cwd = thisDir();
child.stderr = std.io.getStdErr();
child.stdout = std.io.getStdOut();
_ = try child.spawnAndWait();
}
fn ensureCanDownloadFiles(allocator: std.mem.Allocator) !void {
const argv = &[_][]const u8{ "curl", "--version" };
const result = try std.ChildProcess.exec(.{
.allocator = allocator,
.argv = argv,
.cwd = thisDir(),
});
defer {
allocator.free(result.stderr);
allocator.free(result.stdout);
}
if (result.term.Exited != 0) {
std.log.err("mach: error: 'curl --version' failed. Is curl not installed?", .{});
std.process.exit(1);
}
}
fn isLinuxDesktopLike(target: std.Target) bool {
const tag = target.os.tag;
return !tag.isDarwin() and tag != .windows and tag != .fuchsia and tag != .emscripten and !target.isAndroid();
}
fn buildLibMachDawnNative(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-native-mach", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
// TODO(build-system): pass system SDK options through
glfw.link(b, lib, .{ .system_sdk = .{ .set_sysroot = false } });
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
options.appendFlags(&cpp_flags, false, true) catch unreachable;
appendDawnEnableBackendTypeFlags(&cpp_flags, options) catch unreachable;
cpp_flags.appendSlice(&.{
include("libs/mach-glfw/upstream/glfw/include"),
include("libs/dawn/out/Debug/gen/include"),
include("libs/dawn/out/Debug/gen/src"),
include("libs/dawn/include"),
include("libs/dawn/src"),
}) catch unreachable;
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
if (target.os.tag == .windows) {
cpp_flags.appendSlice(&.{
"-D_DEBUG",
"-D_MT",
"-D_DLL",
}) catch unreachable;
}
lib.addCSourceFile("src/dawn/dawn_native_mach.cpp", cpp_flags.items);
return lib;
}
// Builds common sources; derived from src/common/BUILD.gn
fn buildLibDawnCommon(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-common", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.append(include("libs/dawn/src")) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{"libs/dawn/src/dawn/common/"},
.flags = flags.items,
.excluding_contains = &.{
"test",
"benchmark",
"mock",
"WindowsUtils.cpp",
},
}) catch unreachable;
var cpp_sources = std.ArrayList([]const u8).init(b.allocator);
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
if (target.os.tag == .macos) {
// TODO(build-system): pass system SDK options through
system_sdk.include(b, lib, .{});
lib.linkFramework("Foundation");
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn/src/dawn/common/SystemUtils_mac.mm" }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
if (target.os.tag == .windows) {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn/src/dawn/common/WindowsUtils.cpp" }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
cpp_flags.appendSlice(flags.items) catch unreachable;
options.appendFlags(&cpp_flags, false, true) catch unreachable;
lib.addCSourceFiles(cpp_sources.items, cpp_flags.items);
return lib;
}
// Build dawn platform sources; derived from src/dawn/platform/BUILD.gn
fn buildLibDawnPlatform(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-platform", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
options.appendFlags(&cpp_flags, false, true) catch unreachable;
cpp_flags.appendSlice(&.{
include("libs/dawn/src"),
include("libs/dawn/include"),
include("libs/dawn/out/Debug/gen/include"),
}) catch unreachable;
var cpp_sources = std.ArrayList([]const u8).init(b.allocator);
for ([_][]const u8{
"src/dawn/platform/DawnPlatform.cpp",
"src/dawn/platform/WorkerThread.cpp",
"src/dawn/platform/tracing/EventTracer.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
lib.addCSourceFiles(cpp_sources.items, cpp_flags.items);
return lib;
}
fn appendDawnEnableBackendTypeFlags(flags: *std.ArrayList([]const u8), options: Options) !void {
const d3d12 = "-DDAWN_ENABLE_BACKEND_D3D12";
const metal = "-DDAWN_ENABLE_BACKEND_METAL";
const vulkan = "-DDAWN_ENABLE_BACKEND_VULKAN";
const opengl = "-DDAWN_ENABLE_BACKEND_OPENGL";
const desktop_gl = "-DDAWN_ENABLE_BACKEND_DESKTOP_GL";
const opengl_es = "-DDAWN_ENABLE_BACKEND_OPENGLES";
const backend_null = "-DDAWN_ENABLE_BACKEND_NULL";
try flags.append(backend_null);
if (options.d3d12.?) try flags.append(d3d12);
if (options.metal.?) try flags.append(metal);
if (options.vulkan.?) try flags.append(vulkan);
if (options.desktop_gl.?) try flags.appendSlice(&.{ opengl, desktop_gl });
if (options.opengl_es.?) try flags.appendSlice(&.{ opengl, opengl_es });
}
const dawn_d3d12_flags = &[_][]const u8{
"-DDAWN_NO_WINDOWS_UI",
"-D__EMULATE_UUID=1",
"-Wno-nonportable-include-path",
"-Wno-extern-c-compat",
"-Wno-invalid-noreturn",
"-Wno-pragma-pack",
"-Wno-microsoft-template-shadow",
"-Wno-unused-command-line-argument",
"-Wno-microsoft-exception-spec",
"-Wno-implicit-exception-spec-mismatch",
"-Wno-unknown-attributes",
"-Wno-c++20-extensions",
"-D_CRT_SECURE_NO_WARNINGS",
"-DWIN32_LEAN_AND_MEAN",
"-DD3D10_ARBITRARY_HEADER_ORDERING",
"-DNOMINMAX",
};
// Builds dawn native sources; derived from src/dawn/native/BUILD.gn
fn buildLibDawnNative(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-native", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
system_sdk.include(b, lib, .{});
var flags = std.ArrayList([]const u8).init(b.allocator);
appendDawnEnableBackendTypeFlags(&flags, options) catch unreachable;
flags.appendSlice(&.{
include("libs/dawn"),
include("libs/dawn/src"),
include("libs/dawn/include"),
include("libs/dawn/third_party/vulkan-deps/spirv-tools/src/include"),
include("libs/dawn/third_party/abseil-cpp"),
include("libs/dawn/third_party/khronos"),
// TODO(build-system): make these optional
"-DTINT_BUILD_SPV_READER=1",
"-DTINT_BUILD_SPV_WRITER=1",
"-DTINT_BUILD_WGSL_READER=1",
"-DTINT_BUILD_WGSL_WRITER=1",
"-DTINT_BUILD_MSL_WRITER=1",
"-DTINT_BUILD_HLSL_WRITER=1",
"-DTINT_BUILD_GLSL_WRITER=1",
include("libs/dawn/third_party/tint"),
include("libs/dawn/third_party/tint/include"),
include("libs/dawn/out/Debug/gen/include"),
include("libs/dawn/out/Debug/gen/src"),
}) catch unreachable;
if (options.d3d12.?) flags.appendSlice(dawn_d3d12_flags) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/out/Debug/gen/src/dawn/",
"libs/dawn/src/dawn/native/",
"libs/dawn/src/dawn/native/utils/",
},
.flags = flags.items,
.excluding_contains = &.{
"test",
"benchmark",
"mock",
"SpirvValidation.cpp",
"XlibXcbFunctions.cpp",
},
}) catch unreachable;
// dawn_native_gen
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/out/Debug/gen/src/dawn/native/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
// TODO(build-system): could allow enable_vulkan_validation_layers here. See src/dawn/native/BUILD.gn
// TODO(build-system): allow use_angle here. See src/dawn/native/BUILD.gn
// TODO(build-system): could allow use_swiftshader here. See src/dawn/native/BUILD.gn
var cpp_sources = std.ArrayList([]const u8).init(b.allocator);
if (options.d3d12.?) {
lib.linkSystemLibrary("dxgi");
lib.linkSystemLibrary("dxguid");
for ([_][]const u8{
"src/dawn/mingw_helpers.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/src/dawn/native/d3d12/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
}
if (options.metal.?) {
lib.linkFramework("Metal");
lib.linkFramework("CoreGraphics");
lib.linkFramework("Foundation");
lib.linkFramework("IOKit");
lib.linkFramework("IOSurface");
lib.linkFramework("QuartzCore");
appendLangScannedSources(b, lib, options, .{
.objc = true,
.rel_dirs = &.{
"libs/dawn/src/dawn/native/metal/",
"libs/dawn/src/dawn/native/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
}
if (options.linux_window_manager != null and options.linux_window_manager.? == .X11) {
lib.linkSystemLibrary("X11");
for ([_][]const u8{
"src/dawn/native/XlibXcbFunctions.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
for ([_][]const u8{
"src/dawn/native/null/DeviceNull.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
if (options.desktop_gl.? or options.vulkan.?) {
for ([_][]const u8{
"src/dawn/native/SpirvValidation.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
if (options.desktop_gl.?) {
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/out/Debug/gen/src/dawn/native/opengl/",
"libs/dawn/src/dawn/native/opengl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
}
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
if (options.vulkan.?) {
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/src/dawn/native/vulkan/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
if (isLinuxDesktopLike(target)) {
for ([_][]const u8{
"src/dawn/native/vulkan/external_memory/MemoryServiceOpaqueFD.cpp",
"src/dawn/native/vulkan/external_semaphore/SemaphoreServiceFD.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
} else if (target.os.tag == .fuchsia) {
for ([_][]const u8{
"src/dawn/native/vulkan/external_memory/MemoryServiceZirconHandle.cpp",
"src/dawn/native/vulkan/external_semaphore/SemaphoreServiceZirconHandle.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
} else {
for ([_][]const u8{
"src/dawn/native/vulkan/external_memory/MemoryServiceNull.cpp",
"src/dawn/native/vulkan/external_semaphore/SemaphoreServiceNull.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
}
// TODO(build-system): fuchsia: add is_fuchsia here from upstream source file
if (options.vulkan.?) {
// TODO(build-system): vulkan
// if (enable_vulkan_validation_layers) {
// defines += [
// "DAWN_ENABLE_VULKAN_VALIDATION_LAYERS",
// "DAWN_VK_DATA_DIR=\"$vulkan_data_subdir\"",
// ]
// }
// if (enable_vulkan_loader) {
// data_deps += [ "${dawn_vulkan_loader_dir}:libvulkan" ]
// defines += [ "DAWN_ENABLE_VULKAN_LOADER" ]
// }
}
// TODO(build-system): swiftshader
// if (use_swiftshader) {
// data_deps += [
// "${dawn_swiftshader_dir}/src/Vulkan:icd_file",
// "${dawn_swiftshader_dir}/src/Vulkan:swiftshader_libvulkan",
// ]
// defines += [
// "DAWN_ENABLE_SWIFTSHADER",
// "DAWN_SWIFTSHADER_VK_ICD_JSON=\"${swiftshader_icd_file_name}\"",
// ]
// }
// }
if (options.opengl_es.?) {
// TODO(build-system): gles
// if (use_angle) {
// data_deps += [
// "${dawn_angle_dir}:libEGL",
// "${dawn_angle_dir}:libGLESv2",
// ]
// }
// }
}
for ([_][]const u8{
"src/dawn/native/null/NullBackend.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
if (options.d3d12.?) {
for ([_][]const u8{
"src/dawn/native/d3d12/D3D12Backend.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
if (options.desktop_gl.?) {
for ([_][]const u8{
"src/dawn/native/opengl/OpenGLBackend.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
if (options.vulkan.?) {
for ([_][]const u8{
"src/dawn/native/vulkan/VulkanBackend.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
// TODO(build-system): vulkan
// if (enable_vulkan_validation_layers) {
// data_deps =
// [ "${dawn_vulkan_validation_layers_dir}:vulkan_validation_layers" ]
// if (!is_android) {
// data_deps +=
// [ "${dawn_vulkan_validation_layers_dir}:vulkan_gen_json_files" ]
// }
// }
}
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
cpp_flags.appendSlice(flags.items) catch unreachable;
options.appendFlags(&cpp_flags, false, true) catch unreachable;
lib.addCSourceFiles(cpp_sources.items, cpp_flags.items);
return lib;
}
// Builds third party tint sources; derived from third_party/tint/src/tint/BUILD.gn
fn buildLibTint(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("tint", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.appendSlice(&.{
// TODO(build-system): make these optional
"-DTINT_BUILD_SPV_READER=1",
"-DTINT_BUILD_SPV_WRITER=1",
"-DTINT_BUILD_WGSL_READER=1",
"-DTINT_BUILD_WGSL_WRITER=1",
"-DTINT_BUILD_MSL_WRITER=1",
"-DTINT_BUILD_HLSL_WRITER=1",
"-DTINT_BUILD_GLSL_WRITER=1",
include("libs/dawn"),
include("libs/dawn/third_party/tint"),
include("libs/dawn/third_party/tint/include"),
// Required for TINT_BUILD_SPV_READER=1 and TINT_BUILD_SPV_WRITER=1, if specified
include("libs/dawn/third_party/vulkan-deps"),
include("libs/dawn/third_party/vulkan-deps/spirv-tools/src"),
include("libs/dawn/third_party/vulkan-deps/spirv-tools/src/include"),
include("libs/dawn/third_party/vulkan-deps/spirv-headers/src/include"),
include("libs/dawn/out/Debug/gen/third_party/vulkan-deps/spirv-tools/src"),
include("libs/dawn/out/Debug/gen/third_party/vulkan-deps/spirv-tools/src/include"),
}) catch unreachable;
// libtint_core_all_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/ast/",
"libs/dawn/third_party/tint/src/tint/",
"libs/dawn/third_party/tint/src/tint/diagnostic/",
"libs/dawn/third_party/tint/src/tint/inspector/",
"libs/dawn/third_party/tint/src/tint/reader/",
"libs/dawn/third_party/tint/src/tint/resolver/",
"libs/dawn/third_party/tint/src/tint/utils",
"libs/dawn/third_party/tint/src/tint/text/",
"libs/dawn/third_party/tint/src/tint/transform/",
"libs/dawn/third_party/tint/src/tint/transform/utils",
"libs/dawn/third_party/tint/src/tint/writer/",
"libs/dawn/third_party/tint/src/tint/ast/",
"libs/dawn/third_party/tint/src/tint/val/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench", "printer_windows", "printer_linux", "printer_other", "glsl.cc" },
}) catch unreachable;
var cpp_sources = std.ArrayList([]const u8).init(b.allocator);
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
switch (target.os.tag) {
.windows => cpp_sources.append(thisDir() ++ "/libs/dawn/third_party/tint/src/tint/diagnostic/printer_windows.cc") catch unreachable,
.linux => cpp_sources.append(thisDir() ++ "/libs/dawn/third_party/tint/src/tint/diagnostic/printer_linux.cc") catch unreachable,
else => cpp_sources.append(thisDir() ++ "/libs/dawn/third_party/tint/src/tint/diagnostic/printer_other.cc") catch unreachable,
}
// libtint_sem_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/sem/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
// libtint_spv_reader_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/reader/spirv/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
// libtint_spv_writer_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/writer/spirv/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
// TODO(build-system): make optional
// libtint_wgsl_reader_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/reader/wgsl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
// TODO(build-system): make optional
// libtint_wgsl_writer_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/writer/wgsl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
// TODO(build-system): make optional
// libtint_msl_writer_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/writer/msl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
// TODO(build-system): make optional
// libtint_hlsl_writer_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/writer/hlsl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
// TODO(build-system): make optional
// libtint_glsl_writer_src
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/tint/src/tint/writer/glsl/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "bench" },
}) catch unreachable;
for ([_][]const u8{
"third_party/tint/src/tint/transform/glsl.cc",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
cpp_flags.appendSlice(flags.items) catch unreachable;
options.appendFlags(&cpp_flags, false, true) catch unreachable;
lib.addCSourceFiles(cpp_sources.items, cpp_flags.items);
return lib;
}
// Builds third_party/vulkan-deps/spirv-tools sources; derived from third_party/vulkan-deps/spirv-tools/src/BUILD.gn
fn buildLibSPIRVTools(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("spirv-tools", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.appendSlice(&.{
include("libs/dawn"),
include("libs/dawn/third_party/vulkan-deps/spirv-tools/src"),
include("libs/dawn/third_party/vulkan-deps/spirv-tools/src/include"),
include("libs/dawn/third_party/vulkan-deps/spirv-headers/src/include"),
include("libs/dawn/out/Debug/gen/third_party/vulkan-deps/spirv-tools/src"),
include("libs/dawn/out/Debug/gen/third_party/vulkan-deps/spirv-tools/src/include"),
include("libs/dawn/third_party/vulkan-deps/spirv-headers/src/include/spirv/unified1"),
}) catch unreachable;
// spvtools
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/vulkan-deps/spirv-tools/src/source/",
"libs/dawn/third_party/vulkan-deps/spirv-tools/src/source/util/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
// spvtools_val
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/vulkan-deps/spirv-tools/src/source/val/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
// spvtools_opt
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/vulkan-deps/spirv-tools/src/source/opt/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
// spvtools_link
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/vulkan-deps/spirv-tools/src/source/link/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark" },
}) catch unreachable;
return lib;
}
// Builds third_party/abseil sources; derived from:
//
// ```
// $ find third_party/abseil-cpp/absl | grep '\.cc' | grep -v 'test' | grep -v 'benchmark' | grep -v gaussian_distribution_gentables | grep -v print_hash_of | grep -v chi_square
// ```
//
fn buildLibAbseilCpp(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("abseil-cpp-common", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
system_sdk.include(b, lib, .{});
const target = (std.zig.system.NativeTargetInfo.detect(b.allocator, step.target) catch unreachable).target;
if (target.os.tag == .macos) lib.linkFramework("CoreFoundation");
if (target.os.tag == .windows) lib.linkSystemLibrary("bcrypt");
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.appendSlice(&.{
include("libs/dawn"),
include("libs/dawn/third_party/abseil-cpp"),
}) catch unreachable;
if (target.os.tag == .windows) flags.appendSlice(&.{
"-DABSL_FORCE_THREAD_IDENTITY_MODE=2",
"-DWIN32_LEAN_AND_MEAN",
"-DD3D10_ARBITRARY_HEADER_ORDERING",
"-D_CRT_SECURE_NO_WARNINGS",
"-DNOMINMAX",
}) catch unreachable;
// absl
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/third_party/abseil-cpp/absl/strings/",
"libs/dawn/third_party/abseil-cpp/absl/strings/internal/",
"libs/dawn/third_party/abseil-cpp/absl/strings/internal/str_format/",
"libs/dawn/third_party/abseil-cpp/absl/types/",
"libs/dawn/third_party/abseil-cpp/absl/flags/internal/",
"libs/dawn/third_party/abseil-cpp/absl/flags/",
"libs/dawn/third_party/abseil-cpp/absl/synchronization/",
"libs/dawn/third_party/abseil-cpp/absl/synchronization/internal/",
"libs/dawn/third_party/abseil-cpp/absl/hash/internal/",
"libs/dawn/third_party/abseil-cpp/absl/debugging/",
"libs/dawn/third_party/abseil-cpp/absl/debugging/internal/",
"libs/dawn/third_party/abseil-cpp/absl/status/",
"libs/dawn/third_party/abseil-cpp/absl/time/internal/cctz/src/",
"libs/dawn/third_party/abseil-cpp/absl/time/",
"libs/dawn/third_party/abseil-cpp/absl/container/internal/",
"libs/dawn/third_party/abseil-cpp/absl/numeric/",
"libs/dawn/third_party/abseil-cpp/absl/random/",
"libs/dawn/third_party/abseil-cpp/absl/random/internal/",
"libs/dawn/third_party/abseil-cpp/absl/base/internal/",
"libs/dawn/third_party/abseil-cpp/absl/base/",
},
.flags = flags.items,
.excluding_contains = &.{ "_test", "_testing", "benchmark", "print_hash_of.cc", "gaussian_distribution_gentables.cc" },
}) catch unreachable;
return lib;
}
// Buids dawn wire sources; derived from src/dawn/wire/BUILD.gn
fn buildLibDawnWire(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-wire", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.appendSlice(&.{
include("libs/dawn"),
include("libs/dawn/src"),
include("libs/dawn/include"),
include("libs/dawn/out/Debug/gen/include"),
include("libs/dawn/out/Debug/gen/src"),
}) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.rel_dirs = &.{
"libs/dawn/out/Debug/gen/src/dawn/wire/",
"libs/dawn/out/Debug/gen/src/dawn/wire/client/",
"libs/dawn/out/Debug/gen/src/dawn/wire/server/",
"libs/dawn/src/dawn/wire/",
"libs/dawn/src/dawn/wire/client/",
"libs/dawn/src/dawn/wire/server/",
},
.flags = flags.items,
.excluding_contains = &.{ "test", "benchmark", "mock" },
}) catch unreachable;
return lib;
}
// Builds dawn utils sources; derived from src/dawn/utils/BUILD.gn
fn buildLibDawnUtils(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dawn-utils", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
glfw.link(b, lib, .{ .system_sdk = .{ .set_sysroot = false } });
var flags = std.ArrayList([]const u8).init(b.allocator);
appendDawnEnableBackendTypeFlags(&flags, options) catch unreachable;
flags.appendSlice(&.{
include("libs/mach-glfw/upstream/glfw/include"),
include("libs/dawn/src"),
include("libs/dawn/include"),
include("libs/dawn/out/Debug/gen/include"),
}) catch unreachable;
var cpp_sources = std.ArrayList([]const u8).init(b.allocator);
for ([_][]const u8{
"src/dawn/utils/BackendBinding.cpp",
"src/dawn/utils/NullBinding.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
if (options.d3d12.?) {
for ([_][]const u8{
"src/dawn/utils/D3D12Binding.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
flags.appendSlice(dawn_d3d12_flags) catch unreachable;
}
if (options.metal.?) {
for ([_][]const u8{
"src/dawn/utils/MetalBinding.mm",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
if (options.desktop_gl.?) {
for ([_][]const u8{
"src/dawn/utils/OpenGLBinding.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
if (options.vulkan.?) {
for ([_][]const u8{
"src/dawn/utils/VulkanBinding.cpp",
}) |path| {
var abs_path = std.fs.path.join(b.allocator, &.{ thisDir(), "libs/dawn", path }) catch unreachable;
cpp_sources.append(abs_path) catch unreachable;
}
}
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
cpp_flags.appendSlice(flags.items) catch unreachable;
options.appendFlags(&cpp_flags, false, true) catch unreachable;
lib.addCSourceFiles(cpp_sources.items, cpp_flags.items);
return lib;
}
// Buids dxcompiler sources; derived from libs/DirectXShaderCompiler/CMakeLists.txt
fn buildLibDxcompiler(b: *Builder, step: *std.build.LibExeObjStep, options: Options) *std.build.LibExeObjStep {
const lib = if (!options.separate_libs) step else blk: {
var main_abs = std.fs.path.join(b.allocator, &.{ thisDir(), "src/dawn/dummy.zig" }) catch unreachable;
const separate_lib = b.addStaticLibrary("dxcompiler", main_abs);
separate_lib.install();
separate_lib.setBuildMode(step.build_mode);
separate_lib.setTarget(step.target);
separate_lib.linkLibCpp();
break :blk separate_lib;
};
system_sdk.include(b, lib, .{});
lib.linkSystemLibrary("oleaut32");
lib.linkSystemLibrary("ole32");
lib.linkSystemLibrary("dbghelp");
lib.linkSystemLibrary("dxguid");
lib.linkLibCpp();
var flags = std.ArrayList([]const u8).init(b.allocator);
flags.appendSlice(&.{
include("libs/"),
include("libs/DirectXShaderCompiler/include/llvm/llvm_assert"),
include("libs/DirectXShaderCompiler/include"),
include("libs/DirectXShaderCompiler/build/include"),
include("libs/DirectXShaderCompiler/build/lib/HLSL"),
include("libs/DirectXShaderCompiler/build/lib/DxilPIXPasses"),
include("libs/DirectXShaderCompiler/build/include"),
"-DUNREFERENCED_PARAMETER(x)=",
"-Wno-inconsistent-missing-override",
"-Wno-missing-exception-spec",
"-Wno-switch",
"-Wno-deprecated-declarations",
"-Wno-macro-redefined", // regex2.h and regcomp.c requires this for OUT redefinition
"-DMSFT_SUPPORTS_CHILD_PROCESSES=1",
"-DHAVE_LIBPSAPI=1",
"-DHAVE_LIBSHELL32=1",
"-DLLVM_ON_WIN32=1",
}) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.zero_debug_symbols = true,
.rel_dirs = &.{
"libs/DirectXShaderCompiler/lib/Analysis/IPA",
"libs/DirectXShaderCompiler/lib/Analysis",
"libs/DirectXShaderCompiler/lib/AsmParser",
"libs/DirectXShaderCompiler/lib/Bitcode/Writer",
"libs/DirectXShaderCompiler/lib/DxcBindingTable",
"libs/DirectXShaderCompiler/lib/DxcSupport",
"libs/DirectXShaderCompiler/lib/DxilContainer",
"libs/DirectXShaderCompiler/lib/DxilPIXPasses",
"libs/DirectXShaderCompiler/lib/DxilRootSignature",
"libs/DirectXShaderCompiler/lib/DXIL",
"libs/DirectXShaderCompiler/lib/DxrFallback",
"libs/DirectXShaderCompiler/lib/HLSL",
"libs/DirectXShaderCompiler/lib/IRReader",
"libs/DirectXShaderCompiler/lib/IR",
"libs/DirectXShaderCompiler/lib/Linker",
"libs/DirectXShaderCompiler/lib/miniz",
"libs/DirectXShaderCompiler/lib/Option",
"libs/DirectXShaderCompiler/lib/PassPrinters",
"libs/DirectXShaderCompiler/lib/Passes",
"libs/DirectXShaderCompiler/lib/ProfileData",
"libs/DirectXShaderCompiler/lib/Target",
"libs/DirectXShaderCompiler/lib/Transforms/InstCombine",
"libs/DirectXShaderCompiler/lib/Transforms/IPO",
"libs/DirectXShaderCompiler/lib/Transforms/Scalar",
"libs/DirectXShaderCompiler/lib/Transforms/Utils",
"libs/DirectXShaderCompiler/lib/Transforms/Vectorize",
},
.flags = flags.items,
}) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.zero_debug_symbols = true,
.rel_dirs = &.{
"libs/DirectXShaderCompiler/lib/Support",
},
.flags = flags.items,
.excluding_contains = &.{
"DynamicLibrary.cpp", // ignore, HLSL_IGNORE_SOURCES
"PluginLoader.cpp", // ignore, HLSL_IGNORE_SOURCES
"Path.cpp", // ignore, LLVM_INCLUDE_TESTS
"DynamicLibrary.cpp", // ignore
},
}) catch unreachable;
appendLangScannedSources(b, lib, options, .{
.zero_debug_symbols = true,
.rel_dirs = &.{
"libs/DirectXShaderCompiler/lib/Bitcode/Reader",
},
.flags = flags.items,
.excluding_contains = &.{
"BitReader.cpp", // ignore
},
}) catch unreachable;
return lib;
}
fn include(comptime rel: []const u8) []const u8 {
return "-I" ++ thisDir() ++ "/" ++ rel;
}
fn thisDir() []const u8 {
return std.fs.path.dirname(@src().file) orelse ".";
}
fn appendLangScannedSources(
b: *Builder,
step: *std.build.LibExeObjStep,
options: Options,
args: struct {
zero_debug_symbols: bool = false,
flags: []const []const u8,
rel_dirs: []const []const u8 = &.{},
objc: bool = false,
excluding: []const []const u8 = &.{},
excluding_contains: []const []const u8 = &.{},
},
) !void {
var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
try cpp_flags.appendSlice(args.flags);
options.appendFlags(&cpp_flags, args.zero_debug_symbols, true) catch unreachable;
const cpp_extensions: []const []const u8 = if (args.objc) &.{".mm"} else &.{ ".cpp", ".cc" };
try appendScannedSources(b, step, .{
.flags = cpp_flags.items,
.rel_dirs = args.rel_dirs,
.extensions = cpp_extensions,
.excluding = args.excluding,
.excluding_contains = args.excluding_contains,
});
var flags = std.ArrayList([]const u8).init(b.allocator);
try flags.appendSlice(args.flags);
options.appendFlags(&flags, args.zero_debug_symbols, false) catch unreachable;
const c_extensions: []const []const u8 = if (args.objc) &.{".m"} else &.{".c"};
try appendScannedSources(b, step, .{
.flags = flags.items,
.rel_dirs = args.rel_dirs,
.extensions = c_extensions,
.excluding = args.excluding,
.excluding_contains = args.excluding_contains,
});
}
fn appendScannedSources(b: *Builder, step: *std.build.LibExeObjStep, args: struct {
flags: []const []const u8,
rel_dirs: []const []const u8 = &.{},
extensions: []const []const u8,
excluding: []const []const u8 = &.{},
excluding_contains: []const []const u8 = &.{},
}) !void {
var sources = std.ArrayList([]const u8).init(b.allocator);
for (args.rel_dirs) |rel_dir| {
try scanSources(b, &sources, rel_dir, args.extensions, args.excluding, args.excluding_contains);
}
step.addCSourceFiles(sources.items, args.flags);
}
/// Scans rel_dir for sources ending with one of the provided extensions, excluding relative paths
/// listed in the excluded list.
/// Results are appended to the dst ArrayList.
fn scanSources(
b: *Builder,
dst: *std.ArrayList([]const u8),
rel_dir: []const u8,
extensions: []const []const u8,
excluding: []const []const u8,
excluding_contains: []const []const u8,
) !void {
const abs_dir = try std.mem.concat(b.allocator, u8, &.{ thisDir(), "/", rel_dir });
var dir = try std.fs.openDirAbsolute(abs_dir, .{ .iterate = true });
defer dir.close();
var dir_it = dir.iterate();
while (try dir_it.next()) |entry| {
if (entry.kind != .File) continue;
var abs_path = try std.fs.path.join(b.allocator, &.{ abs_dir, entry.name });
abs_path = try std.fs.realpathAlloc(b.allocator, abs_path);
const allowed_extension = blk: {
const ours = std.fs.path.extension(entry.name);
for (extensions) |ext| {
if (std.mem.eql(u8, ours, ext)) break :blk true;
}
break :blk false;
};
if (!allowed_extension) continue;
const excluded = blk: {
for (excluding) |excluded| {
if (std.mem.eql(u8, entry.name, excluded)) break :blk true;
}
break :blk false;
};
if (excluded) continue;
const excluded_contains = blk: {
for (excluding_contains) |contains| {
if (std.mem.containsAtLeast(u8, entry.name, 1, contains)) break :blk true;
}
break :blk false;
};
if (excluded_contains) continue;
try dst.append(abs_path);
}
} | gpu-dawn/build.zig |
const utils = @import("utils.zig");
const std = @import("std");
const math = std.math;
const mem = std.mem;
const isApproxEq = utils.isApproxEq;
const isAnyNan = utils.isAnyNan;
const expect = std.testing.expect;
const assert = std.debug.assert;
const panic = std.debug.panic;
pub const Vec2 = extern struct {
pub const neg_inf = splat(-math.inf(f32));
pub const pos_inf = splat(math.inf(f32));
pub const unit_x = init(1, 0);
pub const unit_y = init(0, 1);
pub const zero = splat(0);
pub const one = splat(1);
x: f32,
y: f32,
pub inline fn init(x: f32, y: f32) Vec2 {
const v = Vec2{ .x = x, .y = y };
assert(!v.isNan());
return v;
}
pub inline fn splat(a: f32) Vec2 {
return init(a, a);
}
pub inline fn add(a: Vec2, b: Vec2) Vec2 {
return init(a.x + b.x, a.y + b.y);
}
pub inline fn sub(a: Vec2, b: Vec2) Vec2 {
return init(a.x - b.x, a.y - b.y);
}
pub inline fn mulAdd(a: Vec2, b: Vec2, c: Vec2) Vec2 {
return init(@mulAdd(f32, a.x, b.x, c.x), @mulAdd(f32, a.y, b.y, c.y));
}
pub inline fn scale(a: Vec2, b: f32) Vec2 {
return init(a.x * b, a.y * b);
}
pub inline fn hadamard(a: Vec2, b: Vec2) Vec2 {
return init(a.x * b.x, a.y * b.y);
}
pub inline fn cross(a: Vec2, b: Vec2) f32 {
return (a.x * b.y) - (a.y * b.x);
}
pub inline fn dot(a: Vec2, b: Vec2) f32 {
return (a.x * b.x) + (a.y * b.y);
}
pub inline fn lengthSquared(a: Vec2) f32 {
return dot(a, a);
}
pub inline fn length(a: Vec2) f32 {
return math.sqrt(dot(a, a));
}
pub inline fn unit(a: Vec2) Vec2 {
const len = length(a);
assert(!math.approxEqAbs(f32, len, 0, math.epsilon(f32)));
return scale(a, 1.0 / len);
}
pub inline fn clamp(a: Vec2, lower: Vec2, upper: Vec2) Vec2 {
return init(math.clamp(a.x, lower.x, upper.x), math.clamp(a.y, lower.y, upper.y));
}
pub inline fn lerp(a: Vec2, b: Vec2, t: f32) Vec2 {
return add(a, scale(sub(b, a), t));
}
pub inline fn absolute(a: Vec2) Vec2 {
return init(math.absFloat(a.x), math.absFloat(a.y));
}
pub inline fn minComponent(a: Vec2) f32 {
return math.min(a.x, a.y);
}
pub inline fn maxComponent(a: Vec2) f32 {
return math.max(a.x, a.y);
}
pub inline fn min(a: Vec2, b: Vec2) Vec2 {
return init(math.min(a.x, b.x), math.min(a.y, b.y));
}
pub inline fn max(a: Vec2, b: Vec2) Vec2 {
return init(math.max(a.x, b.x), math.max(a.y, b.y));
}
pub inline fn approxEq(a: Vec2, b: Vec2, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Vec2) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Vec2) []const f32 {
return @ptrCast(*const [2]f32, a);
}
};
pub const Vec3 = extern struct {
pub const neg_inf = splat(-math.inf(f32));
pub const pos_inf = splat(math.inf(f32));
pub const unit_x = init(1, 0, 0);
pub const unit_y = init(0, 1, 0);
pub const unit_z = init(0, 0, 1);
pub const zero = splat(0);
pub const one = splat(1);
x: f32,
y: f32,
z: f32,
pub inline fn init(x: f32, y: f32, z: f32) Vec3 {
const v = Vec3{ .x = x, .y = y, .z = z };
assert(!v.isNan());
return v;
}
pub inline fn splat(a: f32) Vec3 {
return init(a, a, a);
}
pub inline fn add(a: Vec3, b: Vec3) Vec3 {
return init(a.x + b.x, a.y + b.y, a.z + b.z);
}
pub inline fn sub(a: Vec3, b: Vec3) Vec3 {
return init(a.x - b.x, a.y - b.y, a.z - b.z);
}
pub inline fn mulAdd(a: Vec3, b: Vec3, c: Vec2) Vec3 {
return init(@mulAdd(f32, a.x, b.x, c.x), @mulAdd(f32, a.y, b.y, c.y), @mulAdd(f32, a.z, b.z, c.z));
}
pub inline fn scale(a: Vec3, b: f32) Vec3 {
return init(a.x * b, a.y * b, a.z * b);
}
pub inline fn hadamard(a: Vec3, b: Vec3) Vec3 {
return init(a.x * b.x, a.y * b.y, a.z * b.z);
}
pub inline fn cross(a: Vec3, b: Vec3) Vec3 {
return init((a.y * b.z) - (a.z * b.y), (a.z * b.x) - (a.x * b.z), (a.x * b.y) - (a.y * b.x));
}
pub inline fn dot(a: Vec3, b: Vec3) f32 {
return (a.x * b.x) + (a.y * b.y) + (a.z * b.z);
}
pub inline fn lengthSquared(a: Vec3) f32 {
return dot(a, a);
}
pub inline fn length(a: Vec3) f32 {
return math.sqrt(dot(a, a));
}
pub inline fn unit(a: Vec3) Vec3 {
const len = length(a);
assert(!math.approxEqAbs(f32, len, 0, math.epsilon(f32)));
return scale(a, 1.0 / len);
}
pub inline fn clamp(a: Vec3, lower: Vec3, upper: Vec3) Vec3 {
return init(math.clamp(a.x, lower.x, upper.x), math.clamp(a.y, lower.y, upper.y), math.clamp(a.z, lower.z, upper.z));
}
pub inline fn lerp(a: Vec3, b: Vec3, t: f32) Vec3 {
return add(a, scale(sub(b, a), t));
}
pub inline fn absolute(a: Vec3) Vec3 {
return init(math.absFloat(a.x), math.absFloat(a.y), math.absFloat(a.z));
}
pub inline fn minComponent(a: Vec3) f32 {
return math.min(a.x, math.min(a.y.a.z));
}
pub inline fn maxComponent(a: Vec3) f32 {
return math.max(a.x, math.max(a.y, a.z));
}
pub inline fn min(a: Vec3, b: Vec3) Vec3 {
return init(math.min(a.x, b.x), math.min(a.y, b.y), math.min(a.z, b.z));
}
pub inline fn max(a: Vec3, b: Vec3) Vec3 {
return init(math.max(a.x, b.x), math.max(a.y, b.y), math.max(a.z, b.z));
}
pub inline fn approxEq(a: Vec3, b: Vec3, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Vec3) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Vec3) []const f32 {
return @ptrCast(*const [3]f32, a);
}
};
pub const Vec4 = extern struct {
pub const neg_inf = splat(-math.inf(f32));
pub const pos_inf = splat(math.inf(f32));
pub const unit_x = init(1, 0, 0, 0);
pub const unit_y = init(0, 1, 0, 0);
pub const unit_z = init(0, 0, 1, 0);
pub const unit_w = init(0, 0, 0, 1);
pub const zero = splat(0);
pub const one = splat(1);
x: f32,
y: f32,
z: f32,
w: f32,
pub inline fn init(x: f32, y: f32, z: f32, w: f32) Vec4 {
const v = Vec4{ .x = x, .y = y, .z = z, .w = w };
assert(!v.isNan());
return v;
}
pub inline fn splat(a: f32) Vec4 {
return init(a, a, a, a);
}
pub inline fn add(a: Vec4, b: Vec4) Vec4 {
return init(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
}
pub inline fn sub(a: Vec4, b: Vec4) Vec4 {
return init(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
}
pub inline fn mulAdd(a: Vec4, b: Vec4, c: Vec2) Vec4 {
return init(@mulAdd(f32, a.x, b.x, c.x), @mulAdd(f32, a.y, b.y, c.y), @mulAdd(f32, a.z, b.z, c.z), @mulAdd(f32, a.w, b.w, c.w));
}
pub inline fn scale(a: Vec4, b: f32) Vec4 {
return init(a.x * b, a.y * b, a.z * b, a.w * b);
}
pub inline fn hadamard(a: Vec4, b: Vec4) Vec4 {
return init(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
}
pub inline fn dot(a: Vec4, b: Vec4) f32 {
return (a.x * b.x) + (a.y * b.y) + (a.z * b.z) + (a.w * b.w);
}
pub inline fn lengthSquared(a: Vec4) f32 {
return dot(a, a);
}
pub inline fn length(a: Vec4) f32 {
return math.sqrt(dot(a, a));
}
pub inline fn unit(a: Vec4) Vec4 {
const len = length(a);
assert(!math.approxEqAbs(f32, len, 0, math.epsilon(f32)));
return scale(a, 1.0 / len);
}
pub inline fn clamp(a: Vec4, lower: Vec4, upper: Vec4) Vec4 {
return init(math.clamp(a.x, lower.x, upper.x), math.clamp(a.y, lower.y, upper.y), math.clamp(a.z, lower.z, upper.z), math.clamp(a.w, lower.w, upper.w));
}
pub inline fn lerp(a: Vec4, b: Vec4, t: f32) Vec4 {
return add(a, scale(sub(b, a), t));
}
pub inline fn absolute(a: Vec4) Vec4 {
return init(math.absFloat(a.x), math.absFloat(a.y), math.absFloat(a.z), math.absFloat(a.w));
}
pub inline fn minComponent(a: Vec4) f32 {
return math.min(a.x, math.min(a.y.math.min(a.z, a.w)));
}
pub inline fn maxComponent(a: Vec4) f32 {
return math.max(a.x, math.max(a.y, math.max(a.z, a.w)));
}
pub inline fn min(a: Vec4, b: Vec4) Vec4 {
return init(math.min(a.x, b.x), math.min(a.y, b.y), math.min(a.z, b.z), math.min(a.w, b.w));
}
pub inline fn max(a: Vec4, b: Vec4) Vec4 {
return init(math.max(a.x, b.x), math.max(a.y, b.y), math.max(a.z, b.z), math.max(a.w, b.w));
}
pub inline fn approxEq(a: Vec4, b: Vec4, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Vec4) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Vec4) []const f32 {
return @ptrCast(*const [4]f32, a);
}
};
pub const Mat2 = struct {
pub const identity = init(1, 0, 0, 1);
pub const zero = init(0, 0, 0, 0);
e: [2][2]f32,
pub inline fn init(e00: f32, e01: f32, e10: f32, e11: f32) Mat2 {
const m = Mat2{ .e = [2][2]f32{
[2]f32{ e00, e01 },
[2]f32{ e10, e11 },
} };
assert(!m.isNan());
return m;
}
pub inline fn approxEq(a: Mat2, b: Mat2, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Mat2) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Mat2) []const f32 {
return @ptrCast(*const [4]f32, &a.e[0]);
}
};
pub const Mat3 = extern struct {
pub const identity = init(1, 0, 0, 0, 1, 0, 0, 0, 1);
pub const zero = init(0, 0, 0, 0, 0, 0, 0, 0, 0);
e: [3][3]f32,
pub inline fn init(e00: f32, e01: f32, e02: f32, e10: f32, e11: f32, e12: f32, e20: f32, e21: f32, e22: f32) Mat3 {
const m = Mat3{ .e = [3][3]f32{
[3]f32{ e00, e01, e02 },
[3]f32{ e10, e11, e12 },
[3]f32{ e20, e21, e22 },
} };
assert(!m.isNan());
return m;
}
pub inline fn approxEq(a: Mat3, b: Mat3, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Mat3) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Mat3) []const f32 {
return @ptrCast(*const [9]f32, &a.e[0]);
}
};
pub const Mat4 = extern struct {
pub const identity = init(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
pub const zero = init(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
e: [4][4]f32,
pub inline fn init(e00: f32, e01: f32, e02: f32, e03: f32, e10: f32, e11: f32, e12: f32, e13: f32, e20: f32, e21: f32, e22: f32, e23: f32, e30: f32, e31: f32, e32: f32, e33: f32) Mat4 {
const m = Mat4{ .e = [4][4]f32{
[4]f32{ e00, e01, e02, e03 },
[4]f32{ e10, e11, e12, e13 },
[4]f32{ e20, e21, e22, e23 },
[4]f32{ e30, e31, e32, e33 },
} };
assert(!m.isNan());
return m;
}
pub fn mul(a: Mat4, b: Mat4) Mat4 {
return init(
a.e[0][0] * b.e[0][0] + a.e[0][1] * b.e[1][0] + a.e[0][2] * b.e[2][0] + a.e[0][3] * b.e[3][0],
a.e[0][0] * b.e[0][1] + a.e[0][1] * b.e[1][1] + a.e[0][2] * b.e[2][1] + a.e[0][3] * b.e[3][1],
a.e[0][0] * b.e[0][2] + a.e[0][1] * b.e[1][2] + a.e[0][2] * b.e[2][2] + a.e[0][3] * b.e[3][2],
a.e[0][0] * b.e[0][3] + a.e[0][1] * b.e[1][3] + a.e[0][2] * b.e[2][3] + a.e[0][3] * b.e[3][3],
a.e[1][0] * b.e[0][0] + a.e[1][1] * b.e[1][0] + a.e[1][2] * b.e[2][0] + a.e[1][3] * b.e[3][0],
a.e[1][0] * b.e[0][1] + a.e[1][1] * b.e[1][1] + a.e[1][2] * b.e[2][1] + a.e[1][3] * b.e[3][1],
a.e[1][0] * b.e[0][2] + a.e[1][1] * b.e[1][2] + a.e[1][2] * b.e[2][2] + a.e[1][3] * b.e[3][2],
a.e[1][0] * b.e[0][3] + a.e[1][1] * b.e[1][3] + a.e[1][2] * b.e[2][3] + a.e[1][3] * b.e[3][3],
a.e[2][0] * b.e[0][0] + a.e[2][1] * b.e[1][0] + a.e[2][2] * b.e[2][0] + a.e[2][3] * b.e[3][0],
a.e[2][0] * b.e[0][1] + a.e[2][1] * b.e[1][1] + a.e[2][2] * b.e[2][1] + a.e[2][3] * b.e[3][1],
a.e[2][0] * b.e[0][2] + a.e[2][1] * b.e[1][2] + a.e[2][2] * b.e[2][2] + a.e[2][3] * b.e[3][2],
a.e[2][0] * b.e[0][3] + a.e[2][1] * b.e[1][3] + a.e[2][2] * b.e[2][3] + a.e[2][3] * b.e[3][3],
a.e[3][0] * b.e[0][0] + a.e[3][1] * b.e[1][0] + a.e[3][2] * b.e[2][0] + a.e[3][3] * b.e[3][0],
a.e[3][0] * b.e[0][1] + a.e[3][1] * b.e[1][1] + a.e[3][2] * b.e[2][1] + a.e[3][3] * b.e[3][1],
a.e[3][0] * b.e[0][2] + a.e[3][1] * b.e[1][2] + a.e[3][2] * b.e[2][2] + a.e[3][3] * b.e[3][2],
a.e[3][0] * b.e[0][3] + a.e[3][1] * b.e[1][3] + a.e[3][2] * b.e[2][3] + a.e[3][3] * b.e[3][3],
);
}
pub inline fn scale(a: Mat4, b: f32) Mat4 {
// zig fmt: off
return init(
a.e[0][0] * b, a.e[0][1] * b, a.e[0][2] * b, a.e[0][3] * b,
a.e[1][0] * b, a.e[1][1] * b, a.e[1][2] * b, a.e[1][3] * b,
a.e[2][0] * b, a.e[2][1] * b, a.e[2][2] * b, a.e[2][3] * b,
a.e[3][0] * b, a.e[3][1] * b, a.e[3][2] * b, a.e[3][3] * b,
);
// zig fmt: on
}
pub inline fn transpose(a: Mat4) Mat4 {
// zig fmt: off
return init(
a.e[0][0], a.e[1][0], a.e[2][0], a.e[3][0],
a.e[0][1], a.e[1][1], a.e[2][1], a.e[3][1],
a.e[0][2], a.e[1][2], a.e[2][2], a.e[3][2],
a.e[0][3], a.e[1][3], a.e[2][3], a.e[3][3],
);
// zig fmt: on
}
pub fn inverse(a: Mat4) Mat4 {
const b00 = a.e[0][0] * a.e[1][1] - a.e[0][1] * a.e[1][0];
const b01 = a.e[0][0] * a.e[1][2] - a.e[0][2] * a.e[1][0];
const b02 = a.e[0][0] * a.e[1][3] - a.e[0][3] * a.e[1][0];
const b03 = a.e[0][1] * a.e[1][2] - a.e[0][2] * a.e[1][1];
const b04 = a.e[0][1] * a.e[1][3] - a.e[0][3] * a.e[1][1];
const b05 = a.e[0][2] * a.e[1][3] - a.e[0][3] * a.e[1][2];
const b06 = a.e[2][0] * a.e[3][1] - a.e[2][1] * a.e[3][0];
const b07 = a.e[2][0] * a.e[3][2] - a.e[2][2] * a.e[3][0];
const b08 = a.e[2][0] * a.e[3][3] - a.e[2][3] * a.e[3][0];
const b09 = a.e[2][1] * a.e[3][2] - a.e[2][2] * a.e[3][1];
const b10 = a.e[2][1] * a.e[3][3] - a.e[2][3] * a.e[3][1];
const b11 = a.e[2][2] * a.e[3][3] - a.e[2][3] * a.e[3][2];
const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
if (det == 0) {
panic("Matrix is singular", .{});
}
const inv_det = 1.0 / det;
return init(
(a.e[1][1] * b11 - a.e[1][2] * b10 + a.e[1][3] * b09) * inv_det,
(a.e[0][2] * b10 - a.e[0][1] * b11 - a.e[0][3] * b09) * inv_det,
(a.e[3][1] * b05 - a.e[3][2] * b04 + a.e[3][3] * b03) * inv_det,
(a.e[2][2] * b04 - a.e[2][1] * b05 - a.e[2][3] * b03) * inv_det,
(a.e[1][2] * b08 - a.e[1][0] * b11 - a.e[1][3] * b07) * inv_det,
(a.e[0][0] * b11 - a.e[0][2] * b08 + a.e[0][3] * b07) * inv_det,
(a.e[3][2] * b02 - a.e[3][0] * b05 - a.e[3][3] * b01) * inv_det,
(a.e[2][0] * b05 - a.e[2][2] * b02 + a.e[2][3] * b01) * inv_det,
(a.e[1][0] * b10 - a.e[1][1] * b08 + a.e[1][3] * b06) * inv_det,
(a.e[0][1] * b08 - a.e[0][0] * b10 - a.e[0][3] * b06) * inv_det,
(a.e[3][0] * b04 - a.e[3][1] * b02 + a.e[3][3] * b00) * inv_det,
(a.e[2][1] * b02 - a.e[2][0] * b04 - a.e[2][3] * b00) * inv_det,
(a.e[1][1] * b07 - a.e[1][0] * b09 - a.e[1][2] * b06) * inv_det,
(a.e[0][0] * b09 - a.e[0][1] * b07 + a.e[0][2] * b06) * inv_det,
(a.e[3][1] * b01 - a.e[3][0] * b03 - a.e[3][2] * b00) * inv_det,
(a.e[2][0] * b03 - a.e[2][1] * b01 + a.e[2][2] * b00) * inv_det,
);
}
pub fn determinant(a: Mat4) f32 {
const b00 = a.e[0][0] * a.e[1][1] - a.e[0][1] * a.e[1][0];
const b01 = a.e[0][0] * a.e[1][2] - a.e[0][2] * a.e[1][0];
const b02 = a.e[0][0] * a.e[1][3] - a.e[0][3] * a.e[1][0];
const b03 = a.e[0][1] * a.e[1][2] - a.e[0][2] * a.e[1][1];
const b04 = a.e[0][1] * a.e[1][3] - a.e[0][3] * a.e[1][1];
const b05 = a.e[0][2] * a.e[1][3] - a.e[0][3] * a.e[1][2];
const b06 = a.e[2][0] * a.e[3][1] - a.e[2][1] * a.e[3][0];
const b07 = a.e[2][0] * a.e[3][2] - a.e[2][2] * a.e[3][0];
const b08 = a.e[2][0] * a.e[3][3] - a.e[2][3] * a.e[3][0];
const b09 = a.e[2][1] * a.e[3][2] - a.e[2][2] * a.e[3][1];
const b10 = a.e[2][1] * a.e[3][3] - a.e[2][3] * a.e[3][1];
const b11 = a.e[2][2] * a.e[3][3] - a.e[2][3] * a.e[3][2];
return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
}
pub inline fn approxEq(a: Mat4, b: Mat4, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Mat4) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Mat4) []const f32 {
return @ptrCast(*const [16]f32, &a.e[0]);
}
};
pub const Box2 = extern struct {
pub const inf = init(Vec2.neg_inf, Vec2.pos_inf);
pub const zero = init(Vec2.zero, Vec2.zero);
min: Vec2,
max: Vec2,
pub inline fn init(corner1: Vec2, corner2: Vec2) Box2 {
return Box2{
.min = Vec2.min(corner1, corner2),
.max = Vec2.max(corner1, corner2),
};
}
};
pub const Box3 = extern struct {
pub const inf = init(Vec3.neg_inf, Vec3.pos_inf);
pub const zero = init(Vec3.zero, Vec3.zero);
min: Vec3,
max: Vec3,
pub inline fn init(corner1: Vec3, corner2: Vec3) Box3 {
return Box2{
.min = Vec3.min(corner1, corner2),
.max = Vec3.max(corner1, corner2),
};
}
};
pub const Interval = extern struct {
pub const inf = init(-math.inf(f32), math.inf(f32));
pub const unit = init(-1, 1);
lower: f32,
upper: f32,
pub inline fn init(lower: f32, upper: f32) Interval {
const interval = Interval{ .lower = lower, .upper = upper };
assert(!interval.isNan());
assert(lower <= upper);
return interval;
}
pub fn between(a: Interval, value: f32) bool {
return a.lower <= value and value <= a.upper;
}
pub fn betweenExclusive(a: Interval, value: f32) bool {
return a.lower < value and value < a.upper;
}
pub fn outside(a: Interval, value: f32) bool {
return value <= a.lower or a.upper <= value;
}
pub fn outsideExclusive(a: Interval, value: f32) bool {
return value < a.lower or a.upper < value;
}
pub inline fn approxEq(a: Interval, b: Interval, epsilon: f32) bool {
return isApproxEq(a.asSlice(), b.asSlice(), epsilon);
}
pub inline fn isNan(a: Interval) bool {
return isAnyNan(a.asSlice());
}
pub inline fn asSlice(a: *const Interval) []const f32 {
return @ptrCast(*const [2]f32, a);
}
};
test "VecN add" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const c = Vec2.add(a, b);
try expect(Vec2.approxEq(c, Vec2.init(4, 7), math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const c = Vec3.add(a, b);
try expect(Vec3.approxEq(c, Vec3.init(6, 9, 14), math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = Vec4.init(7, 11, 13, 17);
const c = Vec4.add(a, b);
try expect(Vec4.approxEq(c, Vec4.init(8, 13, 16, 22), math.epsilon(f32)));
}
}
test "VecN sub" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const c = Vec2.sub(a, b);
try expect(Vec2.approxEq(c, Vec2.init(-2, -3), math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const c = Vec3.sub(a, b);
try expect(Vec3.approxEq(c, Vec3.init(-4, -5, -8), math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = Vec4.init(7, 11, 13, 17);
const c = Vec4.sub(a, b);
try expect(Vec4.approxEq(c, Vec4.init(-6, -9, -10, -12), math.epsilon(f32)));
}
}
test "VecN scale" {
{
const a = Vec2.init(1, 2);
const b = 100;
const c = Vec2.scale(a, b);
try expect(Vec2.approxEq(c, Vec2.init(100, 200), math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = 100;
const c = Vec3.scale(a, b);
try expect(Vec3.approxEq(c, Vec3.init(100, 200, 300), math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = 100;
const c = Vec4.scale(a, b);
try expect(Vec4.approxEq(c, Vec4.init(100, 200, 300, 500), math.epsilon(f32)));
}
}
test "VecN hadamard" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const c = Vec2.hadamard(a, b);
try expect(Vec2.approxEq(c, Vec2.init(3, 10), math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const c = Vec3.hadamard(a, b);
try expect(Vec3.approxEq(c, Vec3.init(5, 14, 33), math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = Vec4.init(7, 11, 13, 17);
const c = Vec4.hadamard(a, b);
try expect(Vec4.approxEq(c, Vec4.init(7, 22, 39, 85), math.epsilon(f32)));
}
}
test "VecN cross" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const c = Vec2.cross(a, b);
try expect(math.approxEqAbs(f32, c, -1, math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const c = Vec3.cross(a, b);
try expect(Vec3.approxEq(c, Vec3.init(1, 4, -3), math.epsilon(f32)));
}
}
test "VecN dot" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const c = Vec2.dot(a, b);
try expect(math.approxEqAbs(f32, c, 13, math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const c = Vec3.dot(a, b);
try expect(math.approxEqAbs(f32, c, 52, math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = Vec4.init(7, 11, 13, 17);
const c = Vec4.dot(a, b);
try expect(math.approxEqAbs(f32, c, 153, math.epsilon(f32)));
}
}
test "VecN lerp" {
{
const a = Vec2.init(1, 2);
const b = Vec2.init(3, 5);
const start = Vec2.lerp(a, b, 0);
const half = Vec2.lerp(a, b, 0.5);
const end = Vec2.lerp(a, b, 1);
try expect(Vec2.approxEq(start, a, math.epsilon(f32)));
try expect(Vec2.approxEq(half, Vec2.init(2, 3.5), math.epsilon(f32)));
try expect(Vec2.approxEq(end, b, math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const b = Vec3.init(5, 7, 11);
const start = Vec3.lerp(a, b, 0);
const half = Vec3.lerp(a, b, 0.5);
const end = Vec3.lerp(a, b, 1);
try expect(Vec3.approxEq(start, a, math.epsilon(f32)));
try expect(Vec3.approxEq(half, Vec3.init(3, 4.5, 7), math.epsilon(f32)));
try expect(Vec3.approxEq(end, b, math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const b = Vec4.init(7, 11, 13, 17);
const start = Vec4.lerp(a, b, 0);
const half = Vec4.lerp(a, b, 0.5);
const end = Vec4.lerp(a, b, 1);
try expect(Vec4.approxEq(start, a, math.epsilon(f32)));
try expect(Vec4.approxEq(half, Vec4.init(4, 6.5, 8, 11), math.epsilon(f32)));
try expect(Vec4.approxEq(end, b, math.epsilon(f32)));
}
}
test "VecN unit" {
{
const a = Vec2.init(1, 2);
const c = Vec2.unit(a);
try expect(Vec2.approxEq(c, Vec2.init(1.0 / math.sqrt(5.0), 2.0 / math.sqrt(5.0)), math.epsilon(f32)));
}
{
const a = Vec3.init(1, 2, 3);
const c = Vec3.unit(a);
try expect(Vec3.approxEq(c, Vec3.init(1.0 / math.sqrt(14.0), math.sqrt(2.0 / 7.0), 3.0 / math.sqrt(14.0)), math.epsilon(f32)));
}
{
const a = Vec4.init(1, 2, 3, 5);
const c = Vec4.unit(a);
try expect(Vec4.approxEq(c, Vec4.init(1.0 / math.sqrt(39.0), 2.0 / math.sqrt(39.0), math.sqrt(3.0 / 13.0), 5.0 / math.sqrt(39.0)), math.epsilon(f32)));
}
}
test "VecN asSlice" {
{
const a = Vec2.init(1, 2);
const slice = a.asSlice();
try expect(slice.len == 2);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.x));
try expect(@ptrToInt(&slice[1]) == @ptrToInt(&a.y));
}
{
const a = Vec3.init(1, 2, 3);
const slice = a.asSlice();
try expect(slice.len == 3);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.x));
try expect(@ptrToInt(&slice[2]) == @ptrToInt(&a.z));
}
{
const a = Vec4.init(1, 2, 3, 4);
const slice = a.asSlice();
try expect(slice.len == 4);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.x));
try expect(@ptrToInt(&slice[3]) == @ptrToInt(&a.w));
}
}
test "VecN min, max" {
{
const a = Vec2.init(-1, 1);
const b = Vec2.init(-2, 2);
const min = Vec2.min(a, b);
const max = Vec2.max(a, b);
try expect(Vec2.approxEq(min, Vec2.init(-2, 1), math.epsilon(f32)));
try expect(Vec2.approxEq(max, Vec2.init(-1, 2), math.epsilon(f32)));
}
{
const a = Vec3.init(-1, 1, 0);
const b = Vec3.init(-2, 2, -1);
const min = Vec3.min(a, b);
const max = Vec3.max(a, b);
try expect(Vec3.approxEq(min, Vec3.init(-2, 1, -1), math.epsilon(f32)));
try expect(Vec3.approxEq(max, Vec3.init(-1, 2, 0), math.epsilon(f32)));
}
{
const a = Vec4.init(-1, 1, 0, 0.3);
const b = Vec4.init(-2, 2, -1, 0.2);
const min = Vec4.min(a, b);
const max = Vec4.max(a, b);
try expect(Vec4.approxEq(min, Vec4.init(-2, 1, -1, 0.2), math.epsilon(f32)));
try expect(Vec4.approxEq(max, Vec4.init(-1, 2, 0, 0.3), math.epsilon(f32)));
}
}
test "MatN asSlice" {
{
const a = Mat2.identity;
const slice = a.asSlice();
try expect(slice.len == 4);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.e[0][0]));
try expect(@ptrToInt(&slice[3]) == @ptrToInt(&a.e[1][1]));
}
{
const a = Mat3.identity;
const slice = a.asSlice();
try expect(slice.len == 9);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.e[0][0]));
try expect(@ptrToInt(&slice[8]) == @ptrToInt(&a.e[2][2]));
}
{
const a = Mat4.identity;
const slice = a.asSlice();
try expect(slice.len == 16);
try expect(@ptrToInt(&slice[0]) == @ptrToInt(&a.e[0][0]));
try expect(@ptrToInt(&slice[15]) == @ptrToInt(&a.e[3][3]));
}
}
test "MatN inverse" {
{
// TODO(amroller): Mat2
}
{
// TODO(amroller): Mat3
}
{
const a = Mat4.init(1, 0, 0, 1, 0, 2, 1, 2, 2, 1, 0, 1, 2, 0, 1, 4);
const b = Mat4.inverse(a);
try expect(Mat4.approxEq(b, Mat4.init(-2, -0.5, 1, 0.5, 1, 0.5, 0, -0.5, -8, -1, 2, 2, 3, 0.5, -1, -0.5), math.epsilon(f32)));
}
}
test "MatN determinant" {
{
// TODO(amroller): Mat2
}
{
// TODO(amroller): Mat3
}
{
const a = Mat4.init(1, 0, 4, -6, 2, 5, 0, 3, -1, 2, 3, 5, 2, 1, -2, 3);
const b = Mat4.determinant(a);
try expect(math.approxEqAbs(f32, b, 318, math.epsilon(f32)));
}
} | src/algebra.zig |
const print = @import("std").debug.print;
// This struct is the model of a model boat. We can transform it
// to any scale we would like: 1:2 is half-size, 1:32 is
// thirty-two times smaller than the real thing, and so forth.
const Schooner = struct {
name: []const u8,
scale: u32 = 1,
hull_length: u32 = 143,
bowsprit_length: u32 = 34,
mainmast_height: u32 = 95,
fn scaleMe(self: *Schooner, comptime scale: u32) void {
var my_scale = scale;
// We did something neat here: we've anticipated the
// possibility of accidentally attempting to create a
// scale of 1:0. Rather than having this result in a
// divide-by-zero error at runtime, we've turned this
// into a compile error.
//
// This is probably the correct solution most of the
// time. But our model boat model program is very casual
// and we just want it to "do what I mean" and keep
// working.
//
// Please change this so that it sets a 0 scale to 1
// instead.
// if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
if (my_scale == 0) my_scale = 1;
self.scale = my_scale;
self.hull_length /= my_scale;
self.bowsprit_length /= my_scale;
self.mainmast_height /= my_scale;
}
fn printMe(self: Schooner) void {
print("{s} (1:{}, {} x {})\n", .{
self.name,
self.scale,
self.hull_length,
self.mainmast_height,
});
}
};
pub fn main() void {
var whale = Schooner{ .name = "Whale" };
var shark = Schooner{ .name = "Shark" };
var minnow = Schooner{ .name = "Minnow" };
// Hey, we can't just pass this runtime variable as an
// argument to the scaleMe() method. What would let us do
// that?
comptime var scale: u32 = undefined;
scale = 32; // 1:32 scale
minnow.scaleMe(scale);
minnow.printMe();
scale -= 16; // 1:16 scale
shark.scaleMe(scale);
shark.printMe();
scale -= 16; // 1:0 scale (oops, but DON'T FIX THIS!)
whale.scaleMe(scale);
whale.printMe();
}
//
// Going deeper:
//
// What would happen if you DID attempt to build a model in the
// scale of 1:0?
//
// A) You're already done!
// B) You would suffer a mental divide-by-zero error.
// C) You would construct a singularity and destroy the
// planet.
//
// And how about a model in the scale of 0:1?
//
// A) You're already done!
// B) You'd arrange nothing carefully into the form of the
// original nothing but infinitely larger.
// C) You would construct a singularity and destroy the
// planet.
//
// Answers can be found on the back of the Ziglings packaging. | exercises/068_comptime3.zig |
const std = @import("std");
const clap = @import("clap");
const assert = std.debug.assert;
pub const Param = struct {
pub const Repository = struct {};
pub const Directory = struct {};
pub const Package = struct {};
pub const AnyFile = struct {};
pub const File = struct {};
short_name: ?u8 = null,
long_name: ?[]const u8 = null,
description: []const u8,
value_name: ?[]const u8 = null,
size: clap.Values = .None,
data: type,
};
const ClapParam = clap.Param(clap.Help);
pub const Command = struct {
name: []const u8,
summary: []const u8,
params: []const Param = &[_]Param{},
clap_params: []const ClapParam = &[_]ClapParam{},
parent: type,
passthrough: bool = false,
pub fn init(comptime name: []const u8, summary: []const u8, parent: type) Command {
return .{
.name = name,
.summary = summary,
.parent = parent,
};
}
pub fn addFlag(comptime self: *Command, comptime short: ?u8, comptime long: ?[]const u8, comptime description: []const u8) void {
assert(short != null or long != null);
self.params = self.params ++ [_]Param{.{
.short_name = short,
.long_name = long,
.description = description,
.data = void,
}};
}
pub fn addOption(comptime self: *Command, comptime short: ?u8, comptime long: ?[]const u8, comptime value_name: []const u8, data: type, comptime description: []const u8) void {
assert(short != null or long != null);
self.params = self.params ++ [_]Param{.{
.short_name = short,
.long_name = long,
.description = description,
.value_name = value_name,
.data = data,
.size = .One,
}};
}
pub fn addPositional(comptime self: *Command, comptime value_name: []const u8, data: type, comptime size: clap.Values, comptime description: []const u8) void {
self.params = self.params ++ [_]Param{.{
.description = description,
.value_name = value_name,
.data = data,
.size = size,
}};
}
pub fn done(comptime self: *Command) void {
self.clap_params = &[_]ClapParam{};
for (self.params) |p| {
self.clap_params = self.clap_params ++ [_]ClapParam{.{
.id = .{
.msg = p.description,
.value = p.value_name orelse "",
},
.names = .{
.short = p.short_name,
.long = p.long_name,
},
.takes_value = p.size,
}};
}
}
pub fn ClapComptime(comptime self: *const Command) type {
return clap.ComptimeClap(clap.Help, self.clap_params);
}
};
pub const shells = struct {
pub const List = enum { zsh };
pub const zsh = struct {
pub fn writeAll(writer: anytype, comptime commands: []const Command) !void {
try writer.writeAll(
\\#compdef gyro
\\
\\function _gyro {
\\ local -a __subcommands
\\ local line state
\\
\\ __subcommands=(
\\
);
inline for (commands) |cmd| {
try writer.print(" \"{s}:{}\"\n", .{ cmd.name, std.zig.fmtEscapes(cmd.summary) });
}
try writer.writeAll(
\\ )
\\
\\ _arguments -C \
\\ "1: :->subcommand" \
\\ "*::arg:->args"
\\
\\ case $state in
\\ subcommand)
\\ _describe 'command' __subcommands
\\ ;;
\\ args)
\\ __subcommand="__gyro_cmd_${line[1]}"
\\ if type $__subcommand >/dev/null; then
\\ $__subcommand
\\ fi
\\ ;;
\\ esac
\\}
\\
\\
);
inline for (commands) |cmd| {
try writer.print("function __gyro_cmd_{s} {{\n", .{cmd.name});
try writer.writeAll(" _arguments \\\n");
inline for (cmd.params) |param, i| {
try writer.writeAll(" ");
if (param.short_name == null and param.long_name == null) {
// positional
try writer.writeAll("\"");
} else {
// flag or option
if (param.short_name == null) {
try writer.print("--{s}", .{param.long_name});
} else if (param.long_name == null) {
try writer.print("-{c}", .{param.short_name});
} else {
try writer.print("{{-{c},--{s}}}", .{ param.short_name, param.long_name });
}
try writer.print("\"[{}]", .{std.zig.fmtEscapes(param.description)});
}
try writeType(writer, param.data);
try writer.writeAll("\"");
if (i < cmd.params.len - 1) {
try writer.writeAll(" \\\n");
}
}
try writer.writeAll("\n}\n\n");
}
try writer.writeAll("_gyro\n");
}
fn writeType(writer: anytype, comptime T: type) @TypeOf(writer).Error!void {
switch (T) {
void => return,
Param.Directory => {
try writer.writeAll(": :_files -/");
},
Param.AnyFile => {
try writer.writeAll(": :_files");
},
Param.File => {
try writer.writeAll(": :_files -g '*.zig'");
},
Param.Package, Param.Repository => {
try writer.writeAll(": :_nothing");
},
else => {
switch (@typeInfo(T)) {
.Optional => |info| {
try writer.writeAll(":");
try writeType(writer, info.child);
},
.Enum => |info| {
try writer.writeAll(": :(");
inline for (info.fields) |field| {
try writer.print("'{s}' ", .{field.name});
}
try writer.writeAll(")");
},
else => @compileError("not implemented"),
}
},
}
}
};
}; | src/completion.zig |
pub const MIXERCONTROL_CONTROLTYPE_CUSTOM = @as(u32, 0);
pub const MIXERCONTROL_CONTROLTYPE_BOOLEANMETER = @as(u32, 268500992);
pub const MIXERCONTROL_CONTROLTYPE_SIGNEDMETER = @as(u32, 268566528);
pub const MIXERCONTROL_CONTROLTYPE_PEAKMETER = @as(u32, 268566529);
pub const MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER = @as(u32, 268632064);
pub const MIXERCONTROL_CONTROLTYPE_BOOLEAN = @as(u32, 536936448);
pub const MIXERCONTROL_CONTROLTYPE_ONOFF = @as(u32, 536936449);
pub const MIXERCONTROL_CONTROLTYPE_MUTE = @as(u32, 536936450);
pub const MIXERCONTROL_CONTROLTYPE_MONO = @as(u32, 536936451);
pub const MIXERCONTROL_CONTROLTYPE_LOUDNESS = @as(u32, 536936452);
pub const MIXERCONTROL_CONTROLTYPE_STEREOENH = @as(u32, 536936453);
pub const MIXERCONTROL_CONTROLTYPE_BASS_BOOST = @as(u32, 536945271);
pub const MIXERCONTROL_CONTROLTYPE_BUTTON = @as(u32, 553713664);
pub const MIXERCONTROL_CONTROLTYPE_DECIBELS = @as(u32, 805568512);
pub const MIXERCONTROL_CONTROLTYPE_SIGNED = @as(u32, 805437440);
pub const MIXERCONTROL_CONTROLTYPE_UNSIGNED = @as(u32, 805502976);
pub const MIXERCONTROL_CONTROLTYPE_PERCENT = @as(u32, 805634048);
pub const MIXERCONTROL_CONTROLTYPE_SLIDER = @as(u32, 1073872896);
pub const MIXERCONTROL_CONTROLTYPE_PAN = @as(u32, 1073872897);
pub const MIXERCONTROL_CONTROLTYPE_QSOUNDPAN = @as(u32, 1073872898);
pub const MIXERCONTROL_CONTROLTYPE_FADER = @as(u32, 1342373888);
pub const MIXERCONTROL_CONTROLTYPE_VOLUME = @as(u32, 1342373889);
pub const MIXERCONTROL_CONTROLTYPE_BASS = @as(u32, 1342373890);
pub const MIXERCONTROL_CONTROLTYPE_TREBLE = @as(u32, 1342373891);
pub const MIXERCONTROL_CONTROLTYPE_EQUALIZER = @as(u32, 1342373892);
pub const MIXERCONTROL_CONTROLTYPE_SINGLESELECT = @as(u32, 1879113728);
pub const MIXERCONTROL_CONTROLTYPE_MUX = @as(u32, 1879113729);
pub const MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT = @as(u32, 1895890944);
pub const MIXERCONTROL_CONTROLTYPE_MIXER = @as(u32, 1895890945);
pub const MIXERCONTROL_CONTROLTYPE_MICROTIME = @as(u32, 1610809344);
pub const MIXERCONTROL_CONTROLTYPE_MILLITIME = @as(u32, 1627586560);
pub const WAVE_MAPPER = @as(u32, 4294967295);
pub const ENDPOINT_FORMAT_RESET_MIX_ONLY = @as(u32, 1);
pub const ENDPOINT_HARDWARE_SUPPORT_VOLUME = @as(u32, 1);
pub const ENDPOINT_HARDWARE_SUPPORT_MUTE = @as(u32, 2);
pub const ENDPOINT_HARDWARE_SUPPORT_METER = @as(u32, 4);
pub const AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ = @as(u32, 1);
pub const AMBISONICS_PARAM_VERSION_1 = @as(u32, 1);
pub const AUDCLNT_E_NOT_INITIALIZED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287487));
pub const AUDCLNT_E_ALREADY_INITIALIZED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287486));
pub const AUDCLNT_E_WRONG_ENDPOINT_TYPE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287485));
pub const AUDCLNT_E_DEVICE_INVALIDATED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287484));
pub const AUDCLNT_E_NOT_STOPPED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287483));
pub const AUDCLNT_E_BUFFER_TOO_LARGE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287482));
pub const AUDCLNT_E_OUT_OF_ORDER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287481));
pub const AUDCLNT_E_UNSUPPORTED_FORMAT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287480));
pub const AUDCLNT_E_INVALID_SIZE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287479));
pub const AUDCLNT_E_DEVICE_IN_USE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287478));
pub const AUDCLNT_E_BUFFER_OPERATION_PENDING = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287477));
pub const AUDCLNT_E_THREAD_NOT_REGISTERED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287476));
pub const AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287474));
pub const AUDCLNT_E_ENDPOINT_CREATE_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287473));
pub const AUDCLNT_E_SERVICE_NOT_RUNNING = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287472));
pub const AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287471));
pub const AUDCLNT_E_EXCLUSIVE_MODE_ONLY = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287470));
pub const AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287469));
pub const AUDCLNT_E_EVENTHANDLE_NOT_SET = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287468));
pub const AUDCLNT_E_INCORRECT_BUFFER_SIZE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287467));
pub const AUDCLNT_E_BUFFER_SIZE_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287466));
pub const AUDCLNT_E_CPUUSAGE_EXCEEDED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287465));
pub const AUDCLNT_E_BUFFER_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287464));
pub const AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287463));
pub const AUDCLNT_E_INVALID_DEVICE_PERIOD = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287456));
pub const AUDCLNT_E_INVALID_STREAM_FLAG = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287455));
pub const AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287454));
pub const AUDCLNT_E_OUT_OF_OFFLOAD_RESOURCES = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287453));
pub const AUDCLNT_E_OFFLOAD_MODE_ONLY = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287452));
pub const AUDCLNT_E_NONOFFLOAD_MODE_ONLY = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287451));
pub const AUDCLNT_E_RESOURCES_INVALIDATED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287450));
pub const AUDCLNT_E_RAW_MODE_UNSUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287449));
pub const AUDCLNT_E_ENGINE_PERIODICITY_LOCKED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287448));
pub const AUDCLNT_E_ENGINE_FORMAT_LOCKED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287447));
pub const AUDCLNT_E_HEADTRACKING_ENABLED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287440));
pub const AUDCLNT_E_HEADTRACKING_UNSUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287424));
pub const AUDCLNT_E_EFFECT_NOT_AVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287423));
pub const AUDCLNT_E_EFFECT_STATE_READ_ONLY = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287422));
pub const AUDCLNT_S_BUFFER_EMPTY = @import("../zig.zig").typedConst(HRESULT, @as(i32, 143196161));
pub const AUDCLNT_S_THREAD_ALREADY_REGISTERED = @import("../zig.zig").typedConst(HRESULT, @as(i32, 143196162));
pub const AUDCLNT_S_POSITION_STALLED = @import("../zig.zig").typedConst(HRESULT, @as(i32, 143196163));
pub const AUDCLNT_STREAMFLAGS_CROSSPROCESS = @as(u32, 65536);
pub const AUDCLNT_STREAMFLAGS_LOOPBACK = @as(u32, 131072);
pub const AUDCLNT_STREAMFLAGS_EVENTCALLBACK = @as(u32, 262144);
pub const AUDCLNT_STREAMFLAGS_NOPERSIST = @as(u32, 524288);
pub const AUDCLNT_STREAMFLAGS_RATEADJUST = @as(u32, 1048576);
pub const AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY = @as(u32, 134217728);
pub const AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM = @as(u32, 2147483648);
pub const AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED = @as(u32, 268435456);
pub const AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE = @as(u32, 536870912);
pub const AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED = @as(u32, 1073741824);
pub const SPTLAUDCLNT_E_DESTROYED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287232));
pub const SPTLAUDCLNT_E_OUT_OF_ORDER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287231));
pub const SPTLAUDCLNT_E_RESOURCES_INVALIDATED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287230));
pub const SPTLAUDCLNT_E_NO_MORE_OBJECTS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287229));
pub const SPTLAUDCLNT_E_PROPERTY_NOT_SUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287228));
pub const SPTLAUDCLNT_E_ERRORS_IN_OBJECT_CALLS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287227));
pub const SPTLAUDCLNT_E_METADATA_FORMAT_NOT_SUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287226));
pub const SPTLAUDCLNT_E_STREAM_NOT_AVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287225));
pub const SPTLAUDCLNT_E_INVALID_LICENSE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287224));
pub const SPTLAUDCLNT_E_STREAM_NOT_STOPPED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287222));
pub const SPTLAUDCLNT_E_STATIC_OBJECT_NOT_AVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287221));
pub const SPTLAUDCLNT_E_OBJECT_ALREADY_ACTIVE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287220));
pub const SPTLAUDCLNT_E_INTERNAL = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004287219));
pub const DEVICE_STATE_ACTIVE = @as(u32, 1);
pub const DEVICE_STATE_DISABLED = @as(u32, 2);
pub const DEVICE_STATE_NOTPRESENT = @as(u32, 4);
pub const DEVICE_STATE_UNPLUGGED = @as(u32, 8);
pub const DEVICE_STATEMASK_ALL = @as(u32, 15);
pub const ENDPOINT_SYSFX_ENABLED = @as(u32, 0);
pub const ENDPOINT_SYSFX_DISABLED = @as(u32, 1);
pub const DEVINTERFACE_AUDIO_RENDER = Guid.initString("e6327cad-dcec-4949-ae8a-991e976a79d2");
pub const DEVINTERFACE_AUDIO_CAPTURE = Guid.initString("2eef81be-33fa-4800-9670-1cd474972c3f");
pub const DEVINTERFACE_MIDI_OUTPUT = Guid.initString("6dc23320-ab33-4ce4-80d4-bbb3ebbf2814");
pub const DEVINTERFACE_MIDI_INPUT = Guid.initString("504be32c-ccf6-4d2c-b73f-6f8b3747e22b");
pub const EVENTCONTEXT_VOLUMESLIDER = Guid.initString("e2c2e9de-09b1-4b04-84e5-07931225ee04");
pub const SPATIAL_AUDIO_STANDARD_COMMANDS_START = @as(u32, 200);
pub const SPATIAL_AUDIO_POSITION = @as(u32, 200);
pub const SPTLAUD_MD_CLNT_E_COMMAND_NOT_FOUND = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286976));
pub const SPTLAUD_MD_CLNT_E_OBJECT_NOT_INITIALIZED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286975));
pub const SPTLAUD_MD_CLNT_E_INVALID_ARGS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286974));
pub const SPTLAUD_MD_CLNT_E_METADATA_FORMAT_NOT_FOUND = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286973));
pub const SPTLAUD_MD_CLNT_E_VALUE_BUFFER_INCORRECT_SIZE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286972));
pub const SPTLAUD_MD_CLNT_E_MEMORY_BOUNDS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286971));
pub const SPTLAUD_MD_CLNT_E_NO_MORE_COMMANDS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286970));
pub const SPTLAUD_MD_CLNT_E_BUFFER_ALREADY_ATTACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286969));
pub const SPTLAUD_MD_CLNT_E_BUFFER_NOT_ATTACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286968));
pub const SPTLAUD_MD_CLNT_E_FRAMECOUNT_OUT_OF_RANGE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286967));
pub const SPTLAUD_MD_CLNT_E_NO_ITEMS_FOUND = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286960));
pub const SPTLAUD_MD_CLNT_E_ITEM_COPY_OVERFLOW = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286959));
pub const SPTLAUD_MD_CLNT_E_NO_ITEMS_OPEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286958));
pub const SPTLAUD_MD_CLNT_E_ITEMS_ALREADY_OPEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286957));
pub const SPTLAUD_MD_CLNT_E_ATTACH_FAILED_INTERNAL_BUFFER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286956));
pub const SPTLAUD_MD_CLNT_E_DETACH_FAILED_INTERNAL_BUFFER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286955));
pub const SPTLAUD_MD_CLNT_E_NO_BUFFER_ATTACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286954));
pub const SPTLAUD_MD_CLNT_E_NO_MORE_ITEMS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286953));
pub const SPTLAUD_MD_CLNT_E_FRAMEOFFSET_OUT_OF_RANGE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286952));
pub const SPTLAUD_MD_CLNT_E_ITEM_MUST_HAVE_COMMANDS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286951));
pub const SPTLAUD_MD_CLNT_E_NO_ITEMOFFSET_WRITTEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286944));
pub const SPTLAUD_MD_CLNT_E_NO_ITEMS_WRITTEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286943));
pub const SPTLAUD_MD_CLNT_E_COMMAND_ALREADY_WRITTEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286942));
pub const SPTLAUD_MD_CLNT_E_FORMAT_MISMATCH = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286941));
pub const SPTLAUD_MD_CLNT_E_BUFFER_STILL_ATTACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286940));
pub const SPTLAUD_MD_CLNT_E_ITEMS_LOCKED_FOR_WRITING = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2004286939));
pub const WAVERR_BADFORMAT = @as(u32, 32);
pub const WAVERR_STILLPLAYING = @as(u32, 33);
pub const WAVERR_UNPREPARED = @as(u32, 34);
pub const WAVERR_SYNC = @as(u32, 35);
pub const WAVERR_LASTERROR = @as(u32, 35);
pub const WHDR_DONE = @as(u32, 1);
pub const WHDR_PREPARED = @as(u32, 2);
pub const WHDR_BEGINLOOP = @as(u32, 4);
pub const WHDR_ENDLOOP = @as(u32, 8);
pub const WHDR_INQUEUE = @as(u32, 16);
pub const WAVECAPS_PITCH = @as(u32, 1);
pub const WAVECAPS_PLAYBACKRATE = @as(u32, 2);
pub const WAVECAPS_VOLUME = @as(u32, 4);
pub const WAVECAPS_LRVOLUME = @as(u32, 8);
pub const WAVECAPS_SYNC = @as(u32, 16);
pub const WAVECAPS_SAMPLEACCURATE = @as(u32, 32);
pub const WAVE_INVALIDFORMAT = @as(u32, 0);
pub const WAVE_FORMAT_1M08 = @as(u32, 1);
pub const WAVE_FORMAT_1S08 = @as(u32, 2);
pub const WAVE_FORMAT_1M16 = @as(u32, 4);
pub const WAVE_FORMAT_1S16 = @as(u32, 8);
pub const WAVE_FORMAT_2M08 = @as(u32, 16);
pub const WAVE_FORMAT_2S08 = @as(u32, 32);
pub const WAVE_FORMAT_2M16 = @as(u32, 64);
pub const WAVE_FORMAT_2S16 = @as(u32, 128);
pub const WAVE_FORMAT_4M08 = @as(u32, 256);
pub const WAVE_FORMAT_4S08 = @as(u32, 512);
pub const WAVE_FORMAT_4M16 = @as(u32, 1024);
pub const WAVE_FORMAT_4S16 = @as(u32, 2048);
pub const WAVE_FORMAT_44M08 = @as(u32, 256);
pub const WAVE_FORMAT_44S08 = @as(u32, 512);
pub const WAVE_FORMAT_44M16 = @as(u32, 1024);
pub const WAVE_FORMAT_44S16 = @as(u32, 2048);
pub const WAVE_FORMAT_48M08 = @as(u32, 4096);
pub const WAVE_FORMAT_48S08 = @as(u32, 8192);
pub const WAVE_FORMAT_48M16 = @as(u32, 16384);
pub const WAVE_FORMAT_48S16 = @as(u32, 32768);
pub const WAVE_FORMAT_96M08 = @as(u32, 65536);
pub const WAVE_FORMAT_96S08 = @as(u32, 131072);
pub const WAVE_FORMAT_96M16 = @as(u32, 262144);
pub const WAVE_FORMAT_96S16 = @as(u32, 524288);
pub const WAVE_FORMAT_PCM = @as(u32, 1);
pub const MIDIERR_UNPREPARED = @as(u32, 64);
pub const MIDIERR_STILLPLAYING = @as(u32, 65);
pub const MIDIERR_NOMAP = @as(u32, 66);
pub const MIDIERR_NOTREADY = @as(u32, 67);
pub const MIDIERR_NODEVICE = @as(u32, 68);
pub const MIDIERR_INVALIDSETUP = @as(u32, 69);
pub const MIDIERR_BADOPENMODE = @as(u32, 70);
pub const MIDIERR_DONT_CONTINUE = @as(u32, 71);
pub const MIDIERR_LASTERROR = @as(u32, 71);
pub const MIDIPATCHSIZE = @as(u32, 128);
pub const MIDI_CACHE_ALL = @as(u32, 1);
pub const MIDI_CACHE_BESTFIT = @as(u32, 2);
pub const MIDI_CACHE_QUERY = @as(u32, 3);
pub const MIDI_UNCACHE = @as(u32, 4);
pub const MOD_MIDIPORT = @as(u32, 1);
pub const MOD_SYNTH = @as(u32, 2);
pub const MOD_SQSYNTH = @as(u32, 3);
pub const MOD_FMSYNTH = @as(u32, 4);
pub const MOD_MAPPER = @as(u32, 5);
pub const MOD_WAVETABLE = @as(u32, 6);
pub const MOD_SWSYNTH = @as(u32, 7);
pub const MIDICAPS_VOLUME = @as(u32, 1);
pub const MIDICAPS_LRVOLUME = @as(u32, 2);
pub const MIDICAPS_CACHE = @as(u32, 4);
pub const MIDICAPS_STREAM = @as(u32, 8);
pub const MHDR_DONE = @as(u32, 1);
pub const MHDR_PREPARED = @as(u32, 2);
pub const MHDR_INQUEUE = @as(u32, 4);
pub const MHDR_ISSTRM = @as(u32, 8);
pub const MEVT_F_SHORT = @as(i32, 0);
pub const MEVT_F_LONG = @as(i32, -2147483648);
pub const MEVT_F_CALLBACK = @as(i32, 1073741824);
pub const MIDISTRM_ERROR = @as(i32, -2);
pub const MIDIPROP_SET = @as(i32, -2147483648);
pub const MIDIPROP_GET = @as(i32, 1073741824);
pub const MIDIPROP_TIMEDIV = @as(i32, 1);
pub const MIDIPROP_TEMPO = @as(i32, 2);
pub const AUXCAPS_CDAUDIO = @as(u32, 1);
pub const AUXCAPS_AUXIN = @as(u32, 2);
pub const AUXCAPS_VOLUME = @as(u32, 1);
pub const AUXCAPS_LRVOLUME = @as(u32, 2);
pub const MIXER_SHORT_NAME_CHARS = @as(u32, 16);
pub const MIXER_LONG_NAME_CHARS = @as(u32, 64);
pub const MIXERR_INVALLINE = @as(u32, 1024);
pub const MIXERR_INVALCONTROL = @as(u32, 1025);
pub const MIXERR_INVALVALUE = @as(u32, 1026);
pub const MIXERR_LASTERROR = @as(u32, 1026);
pub const MIXER_OBJECTF_HANDLE = @as(i32, -2147483648);
pub const MIXER_OBJECTF_MIXER = @as(i32, 0);
pub const MIXER_OBJECTF_WAVEOUT = @as(i32, 268435456);
pub const MIXER_OBJECTF_WAVEIN = @as(i32, 536870912);
pub const MIXER_OBJECTF_MIDIOUT = @as(i32, 805306368);
pub const MIXER_OBJECTF_MIDIIN = @as(i32, 1073741824);
pub const MIXER_OBJECTF_AUX = @as(i32, 1342177280);
pub const MIXERLINE_LINEF_ACTIVE = @as(i32, 1);
pub const MIXERLINE_LINEF_DISCONNECTED = @as(i32, 32768);
pub const MIXERLINE_LINEF_SOURCE = @as(i32, -2147483648);
pub const MIXERLINE_COMPONENTTYPE_DST_FIRST = @as(i32, 0);
pub const MIXERLINE_COMPONENTTYPE_DST_LAST = @as(u32, 8);
pub const MIXERLINE_COMPONENTTYPE_SRC_FIRST = @as(i32, 4096);
pub const MIXERLINE_COMPONENTTYPE_SRC_LAST = @as(u32, 4106);
pub const MIXERLINE_TARGETTYPE_UNDEFINED = @as(u32, 0);
pub const MIXERLINE_TARGETTYPE_WAVEOUT = @as(u32, 1);
pub const MIXERLINE_TARGETTYPE_WAVEIN = @as(u32, 2);
pub const MIXERLINE_TARGETTYPE_MIDIOUT = @as(u32, 3);
pub const MIXERLINE_TARGETTYPE_MIDIIN = @as(u32, 4);
pub const MIXERLINE_TARGETTYPE_AUX = @as(u32, 5);
pub const MIXER_GETLINEINFOF_DESTINATION = @as(i32, 0);
pub const MIXER_GETLINEINFOF_SOURCE = @as(i32, 1);
pub const MIXER_GETLINEINFOF_LINEID = @as(i32, 2);
pub const MIXER_GETLINEINFOF_COMPONENTTYPE = @as(i32, 3);
pub const MIXER_GETLINEINFOF_TARGETTYPE = @as(i32, 4);
pub const MIXER_GETLINEINFOF_QUERYMASK = @as(i32, 15);
pub const MIXERCONTROL_CONTROLF_UNIFORM = @as(i32, 1);
pub const MIXERCONTROL_CONTROLF_MULTIPLE = @as(i32, 2);
pub const MIXERCONTROL_CONTROLF_DISABLED = @as(i32, -2147483648);
pub const MIXERCONTROL_CT_CLASS_MASK = @as(i32, -268435456);
pub const MIXERCONTROL_CT_CLASS_CUSTOM = @as(i32, 0);
pub const MIXERCONTROL_CT_CLASS_METER = @as(i32, 268435456);
pub const MIXERCONTROL_CT_CLASS_SWITCH = @as(i32, 536870912);
pub const MIXERCONTROL_CT_CLASS_NUMBER = @as(i32, 805306368);
pub const MIXERCONTROL_CT_CLASS_SLIDER = @as(i32, 1073741824);
pub const MIXERCONTROL_CT_CLASS_FADER = @as(i32, 1342177280);
pub const MIXERCONTROL_CT_CLASS_TIME = @as(i32, 1610612736);
pub const MIXERCONTROL_CT_CLASS_LIST = @as(i32, 1879048192);
pub const MIXERCONTROL_CT_SUBCLASS_MASK = @as(i32, 251658240);
pub const MIXERCONTROL_CT_SC_SWITCH_BOOLEAN = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_SWITCH_BUTTON = @as(i32, 16777216);
pub const MIXERCONTROL_CT_SC_METER_POLLED = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_TIME_MICROSECS = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_TIME_MILLISECS = @as(i32, 16777216);
pub const MIXERCONTROL_CT_SC_LIST_SINGLE = @as(i32, 0);
pub const MIXERCONTROL_CT_SC_LIST_MULTIPLE = @as(i32, 16777216);
pub const MIXERCONTROL_CT_UNITS_MASK = @as(i32, 16711680);
pub const MIXERCONTROL_CT_UNITS_CUSTOM = @as(i32, 0);
pub const MIXERCONTROL_CT_UNITS_BOOLEAN = @as(i32, 65536);
pub const MIXERCONTROL_CT_UNITS_SIGNED = @as(i32, 131072);
pub const MIXERCONTROL_CT_UNITS_UNSIGNED = @as(i32, 196608);
pub const MIXERCONTROL_CT_UNITS_DECIBELS = @as(i32, 262144);
pub const MIXERCONTROL_CT_UNITS_PERCENT = @as(i32, 327680);
pub const MIXER_GETLINECONTROLSF_ALL = @as(i32, 0);
pub const MIXER_GETLINECONTROLSF_ONEBYID = @as(i32, 1);
pub const MIXER_GETLINECONTROLSF_ONEBYTYPE = @as(i32, 2);
pub const MIXER_GETLINECONTROLSF_QUERYMASK = @as(i32, 15);
pub const MIXER_GETCONTROLDETAILSF_VALUE = @as(i32, 0);
pub const MIXER_GETCONTROLDETAILSF_LISTTEXT = @as(i32, 1);
pub const MIXER_GETCONTROLDETAILSF_QUERYMASK = @as(i32, 15);
pub const MIXER_SETCONTROLDETAILSF_VALUE = @as(i32, 0);
pub const MIXER_SETCONTROLDETAILSF_CUSTOM = @as(i32, 1);
pub const MIXER_SETCONTROLDETAILSF_QUERYMASK = @as(i32, 15);
pub const DRV_MAPPER_PREFERRED_INPUT_GET = @as(u32, 16384);
pub const DRV_MAPPER_PREFERRED_OUTPUT_GET = @as(u32, 16386);
pub const DRVM_MAPPER = @as(u32, 8192);
pub const DRVM_MAPPER_STATUS = @as(u32, 8192);
pub const WIDM_MAPPER_STATUS = @as(u32, 8192);
pub const WAVEIN_MAPPER_STATUS_DEVICE = @as(u32, 0);
pub const WAVEIN_MAPPER_STATUS_MAPPED = @as(u32, 1);
pub const WAVEIN_MAPPER_STATUS_FORMAT = @as(u32, 2);
pub const WODM_MAPPER_STATUS = @as(u32, 8192);
pub const WAVEOUT_MAPPER_STATUS_DEVICE = @as(u32, 0);
pub const WAVEOUT_MAPPER_STATUS_MAPPED = @as(u32, 1);
pub const WAVEOUT_MAPPER_STATUS_FORMAT = @as(u32, 2);
pub const ACMERR_BASE = @as(u32, 512);
pub const ACMERR_NOTPOSSIBLE = @as(u32, 512);
pub const ACMERR_BUSY = @as(u32, 513);
pub const ACMERR_UNPREPARED = @as(u32, 514);
pub const ACMERR_CANCELED = @as(u32, 515);
pub const ACM_METRIC_COUNT_DRIVERS = @as(u32, 1);
pub const ACM_METRIC_COUNT_CODECS = @as(u32, 2);
pub const ACM_METRIC_COUNT_CONVERTERS = @as(u32, 3);
pub const ACM_METRIC_COUNT_FILTERS = @as(u32, 4);
pub const ACM_METRIC_COUNT_DISABLED = @as(u32, 5);
pub const ACM_METRIC_COUNT_HARDWARE = @as(u32, 6);
pub const ACM_METRIC_COUNT_LOCAL_DRIVERS = @as(u32, 20);
pub const ACM_METRIC_COUNT_LOCAL_CODECS = @as(u32, 21);
pub const ACM_METRIC_COUNT_LOCAL_CONVERTERS = @as(u32, 22);
pub const ACM_METRIC_COUNT_LOCAL_FILTERS = @as(u32, 23);
pub const ACM_METRIC_COUNT_LOCAL_DISABLED = @as(u32, 24);
pub const ACM_METRIC_HARDWARE_WAVE_INPUT = @as(u32, 30);
pub const ACM_METRIC_HARDWARE_WAVE_OUTPUT = @as(u32, 31);
pub const ACM_METRIC_MAX_SIZE_FORMAT = @as(u32, 50);
pub const ACM_METRIC_MAX_SIZE_FILTER = @as(u32, 51);
pub const ACM_METRIC_DRIVER_SUPPORT = @as(u32, 100);
pub const ACM_METRIC_DRIVER_PRIORITY = @as(u32, 101);
pub const ACM_DRIVERENUMF_NOLOCAL = @as(i32, 1073741824);
pub const ACM_DRIVERENUMF_DISABLED = @as(i32, -2147483648);
pub const ACM_DRIVERADDF_NAME = @as(i32, 1);
pub const ACM_DRIVERADDF_FUNCTION = @as(i32, 3);
pub const ACM_DRIVERADDF_NOTIFYHWND = @as(i32, 4);
pub const ACM_DRIVERADDF_TYPEMASK = @as(i32, 7);
pub const ACM_DRIVERADDF_LOCAL = @as(i32, 0);
pub const ACM_DRIVERADDF_GLOBAL = @as(i32, 8);
pub const ACMDM_USER = @as(u32, 16384);
pub const ACMDM_RESERVED_LOW = @as(u32, 24576);
pub const ACMDM_RESERVED_HIGH = @as(u32, 28671);
pub const ACMDM_DRIVER_ABOUT = @as(u32, 24587);
pub const ACM_DRIVERPRIORITYF_ENABLE = @as(i32, 1);
pub const ACM_DRIVERPRIORITYF_DISABLE = @as(i32, 2);
pub const ACM_DRIVERPRIORITYF_ABLEMASK = @as(i32, 3);
pub const ACM_DRIVERPRIORITYF_BEGIN = @as(i32, 65536);
pub const ACM_DRIVERPRIORITYF_END = @as(i32, 131072);
pub const ACM_DRIVERPRIORITYF_DEFERMASK = @as(i32, 196608);
pub const ACMDRIVERDETAILS_SHORTNAME_CHARS = @as(u32, 32);
pub const ACMDRIVERDETAILS_LONGNAME_CHARS = @as(u32, 128);
pub const ACMDRIVERDETAILS_COPYRIGHT_CHARS = @as(u32, 80);
pub const ACMDRIVERDETAILS_LICENSING_CHARS = @as(u32, 128);
pub const ACMDRIVERDETAILS_FEATURES_CHARS = @as(u32, 512);
pub const ACMDRIVERDETAILS_SUPPORTF_CODEC = @as(i32, 1);
pub const ACMDRIVERDETAILS_SUPPORTF_CONVERTER = @as(i32, 2);
pub const ACMDRIVERDETAILS_SUPPORTF_FILTER = @as(i32, 4);
pub const ACMDRIVERDETAILS_SUPPORTF_HARDWARE = @as(i32, 8);
pub const ACMDRIVERDETAILS_SUPPORTF_ASYNC = @as(i32, 16);
pub const ACMDRIVERDETAILS_SUPPORTF_LOCAL = @as(i32, 1073741824);
pub const ACMDRIVERDETAILS_SUPPORTF_DISABLED = @as(i32, -2147483648);
pub const ACMFORMATTAGDETAILS_FORMATTAG_CHARS = @as(u32, 48);
pub const ACM_FORMATTAGDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FORMATTAGDETAILSF_FORMATTAG = @as(i32, 1);
pub const ACM_FORMATTAGDETAILSF_LARGESTSIZE = @as(i32, 2);
pub const ACM_FORMATTAGDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACMFORMATDETAILS_FORMAT_CHARS = @as(u32, 128);
pub const ACM_FORMATDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FORMATDETAILSF_FORMAT = @as(i32, 1);
pub const ACM_FORMATDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACM_FORMATENUMF_WFORMATTAG = @as(i32, 65536);
pub const ACM_FORMATENUMF_NCHANNELS = @as(i32, 131072);
pub const ACM_FORMATENUMF_NSAMPLESPERSEC = @as(i32, 262144);
pub const ACM_FORMATENUMF_WBITSPERSAMPLE = @as(i32, 524288);
pub const ACM_FORMATENUMF_CONVERT = @as(i32, 1048576);
pub const ACM_FORMATENUMF_SUGGEST = @as(i32, 2097152);
pub const ACM_FORMATENUMF_HARDWARE = @as(i32, 4194304);
pub const ACM_FORMATENUMF_INPUT = @as(i32, 8388608);
pub const ACM_FORMATENUMF_OUTPUT = @as(i32, 16777216);
pub const ACM_FORMATSUGGESTF_WFORMATTAG = @as(i32, 65536);
pub const ACM_FORMATSUGGESTF_NCHANNELS = @as(i32, 131072);
pub const ACM_FORMATSUGGESTF_NSAMPLESPERSEC = @as(i32, 262144);
pub const ACM_FORMATSUGGESTF_WBITSPERSAMPLE = @as(i32, 524288);
pub const ACM_FORMATSUGGESTF_TYPEMASK = @as(i32, 16711680);
pub const MM_ACM_FORMATCHOOSE = @as(u32, 32768);
pub const FORMATCHOOSE_MESSAGE = @as(u32, 0);
pub const FORMATCHOOSE_FORMATTAG_VERIFY = @as(u32, 0);
pub const FORMATCHOOSE_FORMAT_VERIFY = @as(u32, 1);
pub const FORMATCHOOSE_CUSTOM_VERIFY = @as(u32, 2);
pub const ACMFORMATCHOOSE_STYLEF_SHOWHELP = @as(i32, 4);
pub const ACMFORMATCHOOSE_STYLEF_ENABLEHOOK = @as(i32, 8);
pub const ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE = @as(i32, 16);
pub const ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = @as(i32, 32);
pub const ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT = @as(i32, 64);
pub const ACMFORMATCHOOSE_STYLEF_CONTEXTHELP = @as(i32, 128);
pub const ACMFILTERTAGDETAILS_FILTERTAG_CHARS = @as(u32, 48);
pub const ACM_FILTERTAGDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FILTERTAGDETAILSF_FILTERTAG = @as(i32, 1);
pub const ACM_FILTERTAGDETAILSF_LARGESTSIZE = @as(i32, 2);
pub const ACM_FILTERTAGDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACMFILTERDETAILS_FILTER_CHARS = @as(u32, 128);
pub const ACM_FILTERDETAILSF_INDEX = @as(i32, 0);
pub const ACM_FILTERDETAILSF_FILTER = @as(i32, 1);
pub const ACM_FILTERDETAILSF_QUERYMASK = @as(i32, 15);
pub const ACM_FILTERENUMF_DWFILTERTAG = @as(i32, 65536);
pub const MM_ACM_FILTERCHOOSE = @as(u32, 32768);
pub const FILTERCHOOSE_MESSAGE = @as(u32, 0);
pub const FILTERCHOOSE_FILTERTAG_VERIFY = @as(u32, 0);
pub const FILTERCHOOSE_FILTER_VERIFY = @as(u32, 1);
pub const FILTERCHOOSE_CUSTOM_VERIFY = @as(u32, 2);
pub const ACMFILTERCHOOSE_STYLEF_SHOWHELP = @as(i32, 4);
pub const ACMFILTERCHOOSE_STYLEF_ENABLEHOOK = @as(i32, 8);
pub const ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE = @as(i32, 16);
pub const ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = @as(i32, 32);
pub const ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT = @as(i32, 64);
pub const ACMFILTERCHOOSE_STYLEF_CONTEXTHELP = @as(i32, 128);
pub const ACMSTREAMHEADER_STATUSF_DONE = @as(i32, 65536);
pub const ACMSTREAMHEADER_STATUSF_PREPARED = @as(i32, 131072);
pub const ACMSTREAMHEADER_STATUSF_INQUEUE = @as(i32, 1048576);
pub const ACM_STREAMOPENF_QUERY = @as(u32, 1);
pub const ACM_STREAMOPENF_ASYNC = @as(u32, 2);
pub const ACM_STREAMOPENF_NONREALTIME = @as(u32, 4);
pub const ACM_STREAMSIZEF_SOURCE = @as(i32, 0);
pub const ACM_STREAMSIZEF_DESTINATION = @as(i32, 1);
pub const ACM_STREAMSIZEF_QUERYMASK = @as(i32, 15);
pub const ACM_STREAMCONVERTF_BLOCKALIGN = @as(u32, 4);
pub const ACM_STREAMCONVERTF_START = @as(u32, 16);
pub const ACM_STREAMCONVERTF_END = @as(u32, 32);
pub const SND_SYNC = @as(u32, 0);
pub const SND_ASYNC = @as(u32, 1);
pub const SND_NODEFAULT = @as(u32, 2);
pub const SND_MEMORY = @as(u32, 4);
pub const SND_LOOP = @as(u32, 8);
pub const SND_NOSTOP = @as(u32, 16);
pub const SND_NOWAIT = @as(i32, 8192);
pub const SND_ALIAS = @as(i32, 65536);
pub const SND_ALIAS_ID = @as(i32, 1114112);
pub const SND_FILENAME = @as(i32, 131072);
pub const SND_RESOURCE = @as(i32, 262148);
pub const SND_PURGE = @as(u32, 64);
pub const SND_APPLICATION = @as(u32, 128);
pub const SND_SENTRY = @as(i32, 524288);
pub const SND_RING = @as(i32, 1048576);
pub const SND_SYSTEM = @as(i32, 2097152);
pub const SND_ALIAS_START = @as(u32, 0);
pub const ACMDM_DRIVER_NOTIFY = @as(u32, 24577);
pub const ACMDM_DRIVER_DETAILS = @as(u32, 24586);
pub const ACMDM_HARDWARE_WAVE_CAPS_INPUT = @as(u32, 24596);
pub const ACMDM_HARDWARE_WAVE_CAPS_OUTPUT = @as(u32, 24597);
pub const ACMDM_FORMATTAG_DETAILS = @as(u32, 24601);
pub const ACMDM_FORMAT_DETAILS = @as(u32, 24602);
pub const ACMDM_FORMAT_SUGGEST = @as(u32, 24603);
pub const ACMDM_FILTERTAG_DETAILS = @as(u32, 24626);
pub const ACMDM_FILTER_DETAILS = @as(u32, 24627);
pub const ACMDM_STREAM_OPEN = @as(u32, 24652);
pub const ACMDM_STREAM_CLOSE = @as(u32, 24653);
pub const ACMDM_STREAM_SIZE = @as(u32, 24654);
pub const ACMDM_STREAM_CONVERT = @as(u32, 24655);
pub const ACMDM_STREAM_RESET = @as(u32, 24656);
pub const ACMDM_STREAM_PREPARE = @as(u32, 24657);
pub const ACMDM_STREAM_UNPREPARE = @as(u32, 24658);
pub const ACMDM_STREAM_UPDATE = @as(u32, 24659);
//--------------------------------------------------------------------------------
// Section: Types (229)
//--------------------------------------------------------------------------------
pub const LPWAVECALLBACK = fn(
hdrvr: ?HDRVR,
uMsg: u32,
dwUser: usize,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const LPMIDICALLBACK = fn(
hdrvr: ?HDRVR,
uMsg: u32,
dwUser: usize,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MIDI_WAVE_OPEN_TYPE = enum(u32) {
CALLBACK_TYPEMASK = 458752,
CALLBACK_NULL = 0,
CALLBACK_WINDOW = 65536,
CALLBACK_TASK = 131072,
CALLBACK_FUNCTION = 196608,
// CALLBACK_THREAD = 131072, this enum value conflicts with CALLBACK_TASK
CALLBACK_EVENT = 327680,
WAVE_FORMAT_QUERY = 1,
WAVE_ALLOWSYNC = 2,
WAVE_MAPPED = 4,
WAVE_FORMAT_DIRECT = 8,
WAVE_FORMAT_DIRECT_QUERY = 9,
WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE = 16,
MIDI_IO_STATUS = 32,
_,
pub fn initFlags(o: struct {
CALLBACK_TYPEMASK: u1 = 0,
CALLBACK_NULL: u1 = 0,
CALLBACK_WINDOW: u1 = 0,
CALLBACK_TASK: u1 = 0,
CALLBACK_FUNCTION: u1 = 0,
CALLBACK_EVENT: u1 = 0,
WAVE_FORMAT_QUERY: u1 = 0,
WAVE_ALLOWSYNC: u1 = 0,
WAVE_MAPPED: u1 = 0,
WAVE_FORMAT_DIRECT: u1 = 0,
WAVE_FORMAT_DIRECT_QUERY: u1 = 0,
WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE: u1 = 0,
MIDI_IO_STATUS: u1 = 0,
}) MIDI_WAVE_OPEN_TYPE {
return @intToEnum(MIDI_WAVE_OPEN_TYPE,
(if (o.CALLBACK_TYPEMASK == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_TYPEMASK) else 0)
| (if (o.CALLBACK_NULL == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_NULL) else 0)
| (if (o.CALLBACK_WINDOW == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_WINDOW) else 0)
| (if (o.CALLBACK_TASK == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK) else 0)
| (if (o.CALLBACK_FUNCTION == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_FUNCTION) else 0)
| (if (o.CALLBACK_EVENT == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.CALLBACK_EVENT) else 0)
| (if (o.WAVE_FORMAT_QUERY == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_QUERY) else 0)
| (if (o.WAVE_ALLOWSYNC == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_ALLOWSYNC) else 0)
| (if (o.WAVE_MAPPED == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED) else 0)
| (if (o.WAVE_FORMAT_DIRECT == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT) else 0)
| (if (o.WAVE_FORMAT_DIRECT_QUERY == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT_QUERY) else 0)
| (if (o.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE) else 0)
| (if (o.MIDI_IO_STATUS == 1) @enumToInt(MIDI_WAVE_OPEN_TYPE.MIDI_IO_STATUS) else 0)
);
}
};
pub const CALLBACK_TYPEMASK = MIDI_WAVE_OPEN_TYPE.CALLBACK_TYPEMASK;
pub const CALLBACK_NULL = MIDI_WAVE_OPEN_TYPE.CALLBACK_NULL;
pub const CALLBACK_WINDOW = MIDI_WAVE_OPEN_TYPE.CALLBACK_WINDOW;
pub const CALLBACK_TASK = MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK;
pub const CALLBACK_FUNCTION = MIDI_WAVE_OPEN_TYPE.CALLBACK_FUNCTION;
pub const CALLBACK_THREAD = MIDI_WAVE_OPEN_TYPE.CALLBACK_TASK;
pub const CALLBACK_EVENT = MIDI_WAVE_OPEN_TYPE.CALLBACK_EVENT;
pub const WAVE_FORMAT_QUERY = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_QUERY;
pub const WAVE_ALLOWSYNC = MIDI_WAVE_OPEN_TYPE.WAVE_ALLOWSYNC;
pub const WAVE_MAPPED = MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED;
pub const WAVE_FORMAT_DIRECT = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT;
pub const WAVE_FORMAT_DIRECT_QUERY = MIDI_WAVE_OPEN_TYPE.WAVE_FORMAT_DIRECT_QUERY;
pub const WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE = MIDI_WAVE_OPEN_TYPE.WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE;
pub const MIDI_IO_STATUS = MIDI_WAVE_OPEN_TYPE.MIDI_IO_STATUS;
pub const MIXERLINE_COMPONENTTYPE = enum(u32) {
DST_DIGITAL = 1,
DST_HEADPHONES = 5,
DST_LINE = 2,
DST_MONITOR = 3,
DST_SPEAKERS = 4,
DST_TELEPHONE = 6,
DST_UNDEFINED = 0,
DST_VOICEIN = 8,
DST_WAVEIN = 7,
SRC_ANALOG = 4106,
SRC_AUXILIARY = 4105,
SRC_COMPACTDISC = 4101,
SRC_DIGITAL = 4097,
SRC_LINE = 4098,
SRC_MICROPHONE = 4099,
SRC_PCSPEAKER = 4103,
SRC_SYNTHESIZER = 4100,
SRC_TELEPHONE = 4102,
SRC_UNDEFINED = 4096,
SRC_WAVEOUT = 4104,
};
pub const MIXERLINE_COMPONENTTYPE_DST_DIGITAL = MIXERLINE_COMPONENTTYPE.DST_DIGITAL;
pub const MIXERLINE_COMPONENTTYPE_DST_HEADPHONES = MIXERLINE_COMPONENTTYPE.DST_HEADPHONES;
pub const MIXERLINE_COMPONENTTYPE_DST_LINE = MIXERLINE_COMPONENTTYPE.DST_LINE;
pub const MIXERLINE_COMPONENTTYPE_DST_MONITOR = MIXERLINE_COMPONENTTYPE.DST_MONITOR;
pub const MIXERLINE_COMPONENTTYPE_DST_SPEAKERS = MIXERLINE_COMPONENTTYPE.DST_SPEAKERS;
pub const MIXERLINE_COMPONENTTYPE_DST_TELEPHONE = MIXERLINE_COMPONENTTYPE.DST_TELEPHONE;
pub const MIXERLINE_COMPONENTTYPE_DST_UNDEFINED = MIXERLINE_COMPONENTTYPE.DST_UNDEFINED;
pub const MIXERLINE_COMPONENTTYPE_DST_VOICEIN = MIXERLINE_COMPONENTTYPE.DST_VOICEIN;
pub const MIXERLINE_COMPONENTTYPE_DST_WAVEIN = MIXERLINE_COMPONENTTYPE.DST_WAVEIN;
pub const MIXERLINE_COMPONENTTYPE_SRC_ANALOG = MIXERLINE_COMPONENTTYPE.SRC_ANALOG;
pub const MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY = MIXERLINE_COMPONENTTYPE.SRC_AUXILIARY;
pub const MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC = MIXERLINE_COMPONENTTYPE.SRC_COMPACTDISC;
pub const MIXERLINE_COMPONENTTYPE_SRC_DIGITAL = MIXERLINE_COMPONENTTYPE.SRC_DIGITAL;
pub const MIXERLINE_COMPONENTTYPE_SRC_LINE = MIXERLINE_COMPONENTTYPE.SRC_LINE;
pub const MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE = MIXERLINE_COMPONENTTYPE.SRC_MICROPHONE;
pub const MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER = MIXERLINE_COMPONENTTYPE.SRC_PCSPEAKER;
pub const MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER = MIXERLINE_COMPONENTTYPE.SRC_SYNTHESIZER;
pub const MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE = MIXERLINE_COMPONENTTYPE.SRC_TELEPHONE;
pub const MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED = MIXERLINE_COMPONENTTYPE.SRC_UNDEFINED;
pub const MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT = MIXERLINE_COMPONENTTYPE.SRC_WAVEOUT;
pub const AUDIO_VOLUME_NOTIFICATION_DATA = extern struct {
guidEventContext: Guid,
bMuted: BOOL,
fMasterVolume: f32,
nChannels: u32,
afChannelVolumes: [1]f32,
};
pub const HMIDI = *opaque{};
pub const HMIDIIN = *opaque{};
pub const HMIDIOUT = *opaque{};
pub const HMIDISTRM = *opaque{};
pub const HMIXER = *opaque{};
pub const HMIXEROBJ = *opaque{};
pub const HWAVE = *opaque{};
pub const HWAVEOUT = *opaque{};
pub const HWAVEIN = *opaque{};
pub const HACMDRIVERID = *opaque{};
pub const HACMDRIVER = *opaque{};
pub const HACMSTREAM = *opaque{};
pub const HACMOBJ = *opaque{};
// TODO: this type is limited to platform 'windows5.0'
const IID_IMessageFilter_Value = Guid.initString("00000016-0000-0000-c000-000000000046");
pub const IID_IMessageFilter = &IID_IMessageFilter_Value;
pub const IMessageFilter = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
HandleInComingCall: fn(
self: *const IMessageFilter,
dwCallType: u32,
htaskCaller: ?HTASK,
dwTickCount: u32,
lpInterfaceInfo: ?*INTERFACEINFO,
) callconv(@import("std").os.windows.WINAPI) u32,
RetryRejectedCall: fn(
self: *const IMessageFilter,
htaskCallee: ?HTASK,
dwTickCount: u32,
dwRejectType: u32,
) callconv(@import("std").os.windows.WINAPI) u32,
MessagePending: fn(
self: *const IMessageFilter,
htaskCallee: ?HTASK,
dwTickCount: u32,
dwPendingType: u32,
) callconv(@import("std").os.windows.WINAPI) u32,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMessageFilter_HandleInComingCall(self: *const T, dwCallType: u32, htaskCaller: ?HTASK, dwTickCount: u32, lpInterfaceInfo: ?*INTERFACEINFO) callconv(.Inline) u32 {
return @ptrCast(*const IMessageFilter.VTable, self.vtable).HandleInComingCall(@ptrCast(*const IMessageFilter, self), dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMessageFilter_RetryRejectedCall(self: *const T, htaskCallee: ?HTASK, dwTickCount: u32, dwRejectType: u32) callconv(.Inline) u32 {
return @ptrCast(*const IMessageFilter.VTable, self.vtable).RetryRejectedCall(@ptrCast(*const IMessageFilter, self), htaskCallee, dwTickCount, dwRejectType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMessageFilter_MessagePending(self: *const T, htaskCallee: ?HTASK, dwTickCount: u32, dwPendingType: u32) callconv(.Inline) u32 {
return @ptrCast(*const IMessageFilter.VTable, self.vtable).MessagePending(@ptrCast(*const IMessageFilter, self), htaskCallee, dwTickCount, dwPendingType);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WAVEFORMATEXTENSIBLE = packed struct {
Format: WAVEFORMATEX,
Samples: packed union {
wValidBitsPerSample: u16,
wSamplesPerBlock: u16,
wReserved: u16,
},
dwChannelMask: u32,
SubFormat: Guid,
};
pub const WAVEFILTER = packed struct {
cbStruct: u32,
dwFilterTag: u32,
fdwFilter: u32,
dwReserved: [5]u32,
};
pub const VOLUMEWAVEFILTER = packed struct {
wfltr: WAVEFILTER,
dwVolume: u32,
};
pub const ECHOWAVEFILTER = packed struct {
wfltr: WAVEFILTER,
dwVolume: u32,
dwDelay: u32,
};
pub const WAVEHDR = packed struct {
lpData: ?PSTR,
dwBufferLength: u32,
dwBytesRecorded: u32,
dwUser: usize,
dwFlags: u32,
dwLoops: u32,
lpNext: ?*WAVEHDR,
reserved: usize,
};
pub const WAVEOUTCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const WAVEOUTCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const WAVEOUTCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEOUTCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEINCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
};
pub const WAVEINCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
};
pub const WAVEINCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEINCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwFormats: u32,
wChannels: u16,
wReserved1: u16,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const WAVEFORMAT = packed struct {
wFormatTag: u16,
nChannels: u16,
nSamplesPerSec: u32,
nAvgBytesPerSec: u32,
nBlockAlign: u16,
};
pub const PCMWAVEFORMAT = packed struct {
wf: WAVEFORMAT,
wBitsPerSample: u16,
};
pub const WAVEFORMATEX = packed struct {
wFormatTag: u16,
nChannels: u16,
nSamplesPerSec: u32,
nAvgBytesPerSec: u32,
nBlockAlign: u16,
wBitsPerSample: u16,
cbSize: u16,
};
pub const MIDIOUTCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
};
pub const MIDIOUTCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
};
pub const MIDIOUTCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIOUTCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wVoices: u16,
wNotes: u16,
wChannelMask: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIINCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwSupport: u32,
};
pub const MIDIINCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwSupport: u32,
};
pub const MIDIINCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIINCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIDIHDR = packed struct {
lpData: ?PSTR,
dwBufferLength: u32,
dwBytesRecorded: u32,
dwUser: usize,
dwFlags: u32,
lpNext: ?*MIDIHDR,
reserved: usize,
dwOffset: u32,
dwReserved: [8]usize,
};
pub const MIDIEVENT = packed struct {
dwDeltaTime: u32,
dwStreamID: u32,
dwEvent: u32,
dwParms: [1]u32,
};
pub const MIDISTRMBUFFVER = packed struct {
dwVersion: u32,
dwMid: u32,
dwOEMVersion: u32,
};
pub const MIDIPROPTIMEDIV = packed struct {
cbStruct: u32,
dwTimeDiv: u32,
};
pub const MIDIPROPTEMPO = packed struct {
cbStruct: u32,
dwTempo: u32,
};
pub const AUXCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const AUXCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
};
pub const AUXCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const AUXCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
wTechnology: u16,
wReserved1: u16,
dwSupport: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERCAPSA = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
fdwSupport: u32,
cDestinations: u32,
};
pub const MIXERCAPSW = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
fdwSupport: u32,
cDestinations: u32,
};
pub const MIXERCAPS2A = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
fdwSupport: u32,
cDestinations: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERCAPS2W = packed struct {
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
fdwSupport: u32,
cDestinations: u32,
ManufacturerGuid: Guid,
ProductGuid: Guid,
NameGuid: Guid,
};
pub const MIXERLINEA = packed struct {
cbStruct: u32,
dwDestination: u32,
dwSource: u32,
dwLineID: u32,
fdwLine: u32,
dwUser: usize,
dwComponentType: MIXERLINE_COMPONENTTYPE,
cChannels: u32,
cConnections: u32,
cControls: u32,
szShortName: [16]CHAR,
szName: [64]CHAR,
Target: packed struct {
dwType: u32,
dwDeviceID: u32,
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]CHAR,
},
};
pub const MIXERLINEW = packed struct {
cbStruct: u32,
dwDestination: u32,
dwSource: u32,
dwLineID: u32,
fdwLine: u32,
dwUser: usize,
dwComponentType: MIXERLINE_COMPONENTTYPE,
cChannels: u32,
cConnections: u32,
cControls: u32,
szShortName: [16]u16,
szName: [64]u16,
Target: packed struct {
dwType: u32,
dwDeviceID: u32,
wMid: u16,
wPid: u16,
vDriverVersion: u32,
szPname: [32]u16,
},
};
pub const MIXERCONTROLA = packed struct {
cbStruct: u32,
dwControlID: u32,
dwControlType: u32,
fdwControl: u32,
cMultipleItems: u32,
szShortName: [16]CHAR,
szName: [64]CHAR,
Bounds: packed union {
Anonymous1: packed struct {
lMinimum: i32,
lMaximum: i32,
},
Anonymous2: packed struct {
dwMinimum: u32,
dwMaximum: u32,
},
dwReserved: [6]u32,
},
Metrics: packed union {
cSteps: u32,
cbCustomData: u32,
dwReserved: [6]u32,
},
};
pub const MIXERCONTROLW = packed struct {
cbStruct: u32,
dwControlID: u32,
dwControlType: u32,
fdwControl: u32,
cMultipleItems: u32,
szShortName: [16]u16,
szName: [64]u16,
Bounds: packed union {
Anonymous1: packed struct {
lMinimum: i32,
lMaximum: i32,
},
Anonymous2: packed struct {
dwMinimum: u32,
dwMaximum: u32,
},
dwReserved: [6]u32,
},
Metrics: packed union {
cSteps: u32,
cbCustomData: u32,
dwReserved: [6]u32,
},
};
pub const MIXERLINECONTROLSA = packed struct {
cbStruct: u32,
dwLineID: u32,
Anonymous: packed union {
dwControlID: u32,
dwControlType: u32,
},
cControls: u32,
cbmxctrl: u32,
pamxctrl: ?*MIXERCONTROLA,
};
pub const MIXERLINECONTROLSW = packed struct {
cbStruct: u32,
dwLineID: u32,
Anonymous: packed union {
dwControlID: u32,
dwControlType: u32,
},
cControls: u32,
cbmxctrl: u32,
pamxctrl: ?*MIXERCONTROLW,
};
pub const MIXERCONTROLDETAILS = packed struct {
cbStruct: u32,
dwControlID: u32,
cChannels: u32,
Anonymous: packed union {
hwndOwner: ?HWND,
cMultipleItems: u32,
},
cbDetails: u32,
paDetails: ?*anyopaque,
};
pub const MIXERCONTROLDETAILS_LISTTEXTA = packed struct {
dwParam1: u32,
dwParam2: u32,
szName: [64]CHAR,
};
pub const MIXERCONTROLDETAILS_LISTTEXTW = packed struct {
dwParam1: u32,
dwParam2: u32,
szName: [64]u16,
};
pub const MIXERCONTROLDETAILS_BOOLEAN = packed struct {
fValue: i32,
};
pub const MIXERCONTROLDETAILS_SIGNED = packed struct {
lValue: i32,
};
pub const MIXERCONTROLDETAILS_UNSIGNED = packed struct {
dwValue: u32,
};
pub const AUDCLNT_SHAREMODE = enum(i32) {
SHARED = 0,
EXCLUSIVE = 1,
};
pub const AUDCLNT_SHAREMODE_SHARED = AUDCLNT_SHAREMODE.SHARED;
pub const AUDCLNT_SHAREMODE_EXCLUSIVE = AUDCLNT_SHAREMODE.EXCLUSIVE;
pub const AUDIO_STREAM_CATEGORY = enum(i32) {
Other = 0,
ForegroundOnlyMedia = 1,
Communications = 3,
Alerts = 4,
SoundEffects = 5,
GameEffects = 6,
GameMedia = 7,
GameChat = 8,
Speech = 9,
Movie = 10,
Media = 11,
FarFieldSpeech = 12,
UniformSpeech = 13,
VoiceTyping = 14,
};
pub const AudioCategory_Other = AUDIO_STREAM_CATEGORY.Other;
pub const AudioCategory_ForegroundOnlyMedia = AUDIO_STREAM_CATEGORY.ForegroundOnlyMedia;
pub const AudioCategory_Communications = AUDIO_STREAM_CATEGORY.Communications;
pub const AudioCategory_Alerts = AUDIO_STREAM_CATEGORY.Alerts;
pub const AudioCategory_SoundEffects = AUDIO_STREAM_CATEGORY.SoundEffects;
pub const AudioCategory_GameEffects = AUDIO_STREAM_CATEGORY.GameEffects;
pub const AudioCategory_GameMedia = AUDIO_STREAM_CATEGORY.GameMedia;
pub const AudioCategory_GameChat = AUDIO_STREAM_CATEGORY.GameChat;
pub const AudioCategory_Speech = AUDIO_STREAM_CATEGORY.Speech;
pub const AudioCategory_Movie = AUDIO_STREAM_CATEGORY.Movie;
pub const AudioCategory_Media = AUDIO_STREAM_CATEGORY.Media;
pub const AudioCategory_FarFieldSpeech = AUDIO_STREAM_CATEGORY.FarFieldSpeech;
pub const AudioCategory_UniformSpeech = AUDIO_STREAM_CATEGORY.UniformSpeech;
pub const AudioCategory_VoiceTyping = AUDIO_STREAM_CATEGORY.VoiceTyping;
pub const AudioSessionState = enum(i32) {
Inactive = 0,
Active = 1,
Expired = 2,
};
pub const AudioSessionStateInactive = AudioSessionState.Inactive;
pub const AudioSessionStateActive = AudioSessionState.Active;
pub const AudioSessionStateExpired = AudioSessionState.Expired;
pub const _AUDCLNT_BUFFERFLAGS = enum(i32) {
DATA_DISCONTINUITY = 1,
SILENT = 2,
TIMESTAMP_ERROR = 4,
};
pub const AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY = _AUDCLNT_BUFFERFLAGS.DATA_DISCONTINUITY;
pub const AUDCLNT_BUFFERFLAGS_SILENT = _AUDCLNT_BUFFERFLAGS.SILENT;
pub const AUDCLNT_BUFFERFLAGS_TIMESTAMP_ERROR = _AUDCLNT_BUFFERFLAGS.TIMESTAMP_ERROR;
pub const AUDCLNT_STREAMOPTIONS = enum(u32) {
NONE = 0,
RAW = 1,
MATCH_FORMAT = 2,
AMBISONICS = 4,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
RAW: u1 = 0,
MATCH_FORMAT: u1 = 0,
AMBISONICS: u1 = 0,
}) AUDCLNT_STREAMOPTIONS {
return @intToEnum(AUDCLNT_STREAMOPTIONS,
(if (o.NONE == 1) @enumToInt(AUDCLNT_STREAMOPTIONS.NONE) else 0)
| (if (o.RAW == 1) @enumToInt(AUDCLNT_STREAMOPTIONS.RAW) else 0)
| (if (o.MATCH_FORMAT == 1) @enumToInt(AUDCLNT_STREAMOPTIONS.MATCH_FORMAT) else 0)
| (if (o.AMBISONICS == 1) @enumToInt(AUDCLNT_STREAMOPTIONS.AMBISONICS) else 0)
);
}
};
pub const AUDCLNT_STREAMOPTIONS_NONE = AUDCLNT_STREAMOPTIONS.NONE;
pub const AUDCLNT_STREAMOPTIONS_RAW = AUDCLNT_STREAMOPTIONS.RAW;
pub const AUDCLNT_STREAMOPTIONS_MATCH_FORMAT = AUDCLNT_STREAMOPTIONS.MATCH_FORMAT;
pub const AUDCLNT_STREAMOPTIONS_AMBISONICS = AUDCLNT_STREAMOPTIONS.AMBISONICS;
pub const AudioClientProperties = extern struct {
cbSize: u32,
bIsOffload: BOOL,
eCategory: AUDIO_STREAM_CATEGORY,
Options: AUDCLNT_STREAMOPTIONS,
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioClient_Value = Guid.initString("1cb9ad4c-dbfa-4c32-b178-c2f568a703b2");
pub const IID_IAudioClient = &IID_IAudioClient_Value;
pub const IAudioClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const IAudioClient,
ShareMode: AUDCLNT_SHAREMODE,
StreamFlags: u32,
hnsBufferDuration: i64,
hnsPeriodicity: i64,
pFormat: ?*const WAVEFORMATEX,
AudioSessionGuid: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBufferSize: fn(
self: *const IAudioClient,
pNumBufferFrames: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStreamLatency: fn(
self: *const IAudioClient,
phnsLatency: ?*i64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrentPadding: fn(
self: *const IAudioClient,
pNumPaddingFrames: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsFormatSupported: fn(
self: *const IAudioClient,
ShareMode: AUDCLNT_SHAREMODE,
pFormat: ?*const WAVEFORMATEX,
ppClosestMatch: ?*?*WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMixFormat: fn(
self: *const IAudioClient,
ppDeviceFormat: ?*?*WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDevicePeriod: fn(
self: *const IAudioClient,
phnsDefaultDevicePeriod: ?*i64,
phnsMinimumDevicePeriod: ?*i64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Start: fn(
self: *const IAudioClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stop: fn(
self: *const IAudioClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IAudioClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEventHandle: fn(
self: *const IAudioClient,
eventHandle: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetService: fn(
self: *const IAudioClient,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_Initialize(self: *const T, ShareMode: AUDCLNT_SHAREMODE, StreamFlags: u32, hnsBufferDuration: i64, hnsPeriodicity: i64, pFormat: ?*const WAVEFORMATEX, AudioSessionGuid: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).Initialize(@ptrCast(*const IAudioClient, self), ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat, AudioSessionGuid);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetBufferSize(self: *const T, pNumBufferFrames: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetBufferSize(@ptrCast(*const IAudioClient, self), pNumBufferFrames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetStreamLatency(self: *const T, phnsLatency: ?*i64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetStreamLatency(@ptrCast(*const IAudioClient, self), phnsLatency);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetCurrentPadding(self: *const T, pNumPaddingFrames: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetCurrentPadding(@ptrCast(*const IAudioClient, self), pNumPaddingFrames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_IsFormatSupported(self: *const T, ShareMode: AUDCLNT_SHAREMODE, pFormat: ?*const WAVEFORMATEX, ppClosestMatch: ?*?*WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).IsFormatSupported(@ptrCast(*const IAudioClient, self), ShareMode, pFormat, ppClosestMatch);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetMixFormat(self: *const T, ppDeviceFormat: ?*?*WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetMixFormat(@ptrCast(*const IAudioClient, self), ppDeviceFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetDevicePeriod(self: *const T, phnsDefaultDevicePeriod: ?*i64, phnsMinimumDevicePeriod: ?*i64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetDevicePeriod(@ptrCast(*const IAudioClient, self), phnsDefaultDevicePeriod, phnsMinimumDevicePeriod);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_Start(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).Start(@ptrCast(*const IAudioClient, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_Stop(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).Stop(@ptrCast(*const IAudioClient, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).Reset(@ptrCast(*const IAudioClient, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_SetEventHandle(self: *const T, eventHandle: ?HANDLE) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).SetEventHandle(@ptrCast(*const IAudioClient, self), eventHandle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient_GetService(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient.VTable, self.vtable).GetService(@ptrCast(*const IAudioClient, self), riid, ppv);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IAudioClient2_Value = Guid.initString("726778cd-f60a-4eda-82de-e47610cd78aa");
pub const IID_IAudioClient2 = &IID_IAudioClient2_Value;
pub const IAudioClient2 = extern struct {
pub const VTable = extern struct {
base: IAudioClient.VTable,
IsOffloadCapable: fn(
self: *const IAudioClient2,
Category: AUDIO_STREAM_CATEGORY,
pbOffloadCapable: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetClientProperties: fn(
self: *const IAudioClient2,
pProperties: ?*const AudioClientProperties,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBufferSizeLimits: fn(
self: *const IAudioClient2,
pFormat: ?*const WAVEFORMATEX,
bEventDriven: BOOL,
phnsMinBufferDuration: ?*i64,
phnsMaxBufferDuration: ?*i64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IAudioClient.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient2_IsOffloadCapable(self: *const T, Category: AUDIO_STREAM_CATEGORY, pbOffloadCapable: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient2.VTable, self.vtable).IsOffloadCapable(@ptrCast(*const IAudioClient2, self), Category, pbOffloadCapable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient2_SetClientProperties(self: *const T, pProperties: ?*const AudioClientProperties) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient2.VTable, self.vtable).SetClientProperties(@ptrCast(*const IAudioClient2, self), pProperties);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient2_GetBufferSizeLimits(self: *const T, pFormat: ?*const WAVEFORMATEX, bEventDriven: BOOL, phnsMinBufferDuration: ?*i64, phnsMaxBufferDuration: ?*i64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient2.VTable, self.vtable).GetBufferSizeLimits(@ptrCast(*const IAudioClient2, self), pFormat, bEventDriven, phnsMinBufferDuration, phnsMaxBufferDuration);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AudioClient3ActivationParams = extern struct {
tracingContextId: Guid,
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_IAudioClient3_Value = Guid.initString("7ed4ee07-8e67-4cd4-8c1a-2b7a5987ad42");
pub const IID_IAudioClient3 = &IID_IAudioClient3_Value;
pub const IAudioClient3 = extern struct {
pub const VTable = extern struct {
base: IAudioClient2.VTable,
GetSharedModeEnginePeriod: fn(
self: *const IAudioClient3,
pFormat: ?*const WAVEFORMATEX,
pDefaultPeriodInFrames: ?*u32,
pFundamentalPeriodInFrames: ?*u32,
pMinPeriodInFrames: ?*u32,
pMaxPeriodInFrames: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCurrentSharedModeEnginePeriod: fn(
self: *const IAudioClient3,
ppFormat: ?*?*WAVEFORMATEX,
pCurrentPeriodInFrames: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InitializeSharedAudioStream: fn(
self: *const IAudioClient3,
StreamFlags: u32,
PeriodInFrames: u32,
pFormat: ?*const WAVEFORMATEX,
AudioSessionGuid: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IAudioClient2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient3_GetSharedModeEnginePeriod(self: *const T, pFormat: ?*const WAVEFORMATEX, pDefaultPeriodInFrames: ?*u32, pFundamentalPeriodInFrames: ?*u32, pMinPeriodInFrames: ?*u32, pMaxPeriodInFrames: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient3.VTable, self.vtable).GetSharedModeEnginePeriod(@ptrCast(*const IAudioClient3, self), pFormat, pDefaultPeriodInFrames, pFundamentalPeriodInFrames, pMinPeriodInFrames, pMaxPeriodInFrames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient3_GetCurrentSharedModeEnginePeriod(self: *const T, ppFormat: ?*?*WAVEFORMATEX, pCurrentPeriodInFrames: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient3.VTable, self.vtable).GetCurrentSharedModeEnginePeriod(@ptrCast(*const IAudioClient3, self), ppFormat, pCurrentPeriodInFrames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClient3_InitializeSharedAudioStream(self: *const T, StreamFlags: u32, PeriodInFrames: u32, pFormat: ?*const WAVEFORMATEX, AudioSessionGuid: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClient3.VTable, self.vtable).InitializeSharedAudioStream(@ptrCast(*const IAudioClient3, self), StreamFlags, PeriodInFrames, pFormat, AudioSessionGuid);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioRenderClient_Value = Guid.initString("f294acfc-3146-4483-a7bf-addca7c260e2");
pub const IID_IAudioRenderClient = &IID_IAudioRenderClient_Value;
pub const IAudioRenderClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetBuffer: fn(
self: *const IAudioRenderClient,
NumFramesRequested: u32,
ppData: ?*?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseBuffer: fn(
self: *const IAudioRenderClient,
NumFramesWritten: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioRenderClient_GetBuffer(self: *const T, NumFramesRequested: u32, ppData: ?*?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioRenderClient.VTable, self.vtable).GetBuffer(@ptrCast(*const IAudioRenderClient, self), NumFramesRequested, ppData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioRenderClient_ReleaseBuffer(self: *const T, NumFramesWritten: u32, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioRenderClient.VTable, self.vtable).ReleaseBuffer(@ptrCast(*const IAudioRenderClient, self), NumFramesWritten, dwFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioCaptureClient_Value = Guid.initString("c8adbd64-e71e-48a0-a4de-185c395cd317");
pub const IID_IAudioCaptureClient = &IID_IAudioCaptureClient_Value;
pub const IAudioCaptureClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetBuffer: fn(
self: *const IAudioCaptureClient,
ppData: ?*?*u8,
pNumFramesToRead: ?*u32,
pdwFlags: ?*u32,
pu64DevicePosition: ?*u64,
pu64QPCPosition: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseBuffer: fn(
self: *const IAudioCaptureClient,
NumFramesRead: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNextPacketSize: fn(
self: *const IAudioCaptureClient,
pNumFramesInNextPacket: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioCaptureClient_GetBuffer(self: *const T, ppData: ?*?*u8, pNumFramesToRead: ?*u32, pdwFlags: ?*u32, pu64DevicePosition: ?*u64, pu64QPCPosition: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioCaptureClient.VTable, self.vtable).GetBuffer(@ptrCast(*const IAudioCaptureClient, self), ppData, pNumFramesToRead, pdwFlags, pu64DevicePosition, pu64QPCPosition);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioCaptureClient_ReleaseBuffer(self: *const T, NumFramesRead: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioCaptureClient.VTable, self.vtable).ReleaseBuffer(@ptrCast(*const IAudioCaptureClient, self), NumFramesRead);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioCaptureClient_GetNextPacketSize(self: *const T, pNumFramesInNextPacket: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioCaptureClient.VTable, self.vtable).GetNextPacketSize(@ptrCast(*const IAudioCaptureClient, self), pNumFramesInNextPacket);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioClock_Value = Guid.initString("cd63314f-3fba-4a1b-812c-ef96358728e7");
pub const IID_IAudioClock = &IID_IAudioClock_Value;
pub const IAudioClock = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetFrequency: fn(
self: *const IAudioClock,
pu64Frequency: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPosition: fn(
self: *const IAudioClock,
pu64Position: ?*u64,
pu64QPCPosition: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCharacteristics: fn(
self: *const IAudioClock,
pdwCharacteristics: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClock_GetFrequency(self: *const T, pu64Frequency: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClock.VTable, self.vtable).GetFrequency(@ptrCast(*const IAudioClock, self), pu64Frequency);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClock_GetPosition(self: *const T, pu64Position: ?*u64, pu64QPCPosition: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClock.VTable, self.vtable).GetPosition(@ptrCast(*const IAudioClock, self), pu64Position, pu64QPCPosition);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClock_GetCharacteristics(self: *const T, pdwCharacteristics: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClock.VTable, self.vtable).GetCharacteristics(@ptrCast(*const IAudioClock, self), pdwCharacteristics);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioClock2_Value = Guid.initString("6f49ff73-6727-49ac-a008-d98cf5e70048");
pub const IID_IAudioClock2 = &IID_IAudioClock2_Value;
pub const IAudioClock2 = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDevicePosition: fn(
self: *const IAudioClock2,
DevicePosition: ?*u64,
QPCPosition: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClock2_GetDevicePosition(self: *const T, DevicePosition: ?*u64, QPCPosition: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClock2.VTable, self.vtable).GetDevicePosition(@ptrCast(*const IAudioClock2, self), DevicePosition, QPCPosition);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioClockAdjustment_Value = Guid.initString("f6e4c0a0-46d9-4fb8-be21-57a3ef2b626c");
pub const IID_IAudioClockAdjustment = &IID_IAudioClockAdjustment_Value;
pub const IAudioClockAdjustment = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetSampleRate: fn(
self: *const IAudioClockAdjustment,
flSampleRate: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClockAdjustment_SetSampleRate(self: *const T, flSampleRate: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClockAdjustment.VTable, self.vtable).SetSampleRate(@ptrCast(*const IAudioClockAdjustment, self), flSampleRate);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_ISimpleAudioVolume_Value = Guid.initString("87ce5498-68d6-44e5-9215-6da47ef883d8");
pub const IID_ISimpleAudioVolume = &IID_ISimpleAudioVolume_Value;
pub const ISimpleAudioVolume = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetMasterVolume: fn(
self: *const ISimpleAudioVolume,
fLevel: f32,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMasterVolume: fn(
self: *const ISimpleAudioVolume,
pfLevel: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMute: fn(
self: *const ISimpleAudioVolume,
bMute: BOOL,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMute: fn(
self: *const ISimpleAudioVolume,
pbMute: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISimpleAudioVolume_SetMasterVolume(self: *const T, fLevel: f32, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).SetMasterVolume(@ptrCast(*const ISimpleAudioVolume, self), fLevel, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISimpleAudioVolume_GetMasterVolume(self: *const T, pfLevel: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).GetMasterVolume(@ptrCast(*const ISimpleAudioVolume, self), pfLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISimpleAudioVolume_SetMute(self: *const T, bMute: BOOL, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).SetMute(@ptrCast(*const ISimpleAudioVolume, self), bMute, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISimpleAudioVolume_GetMute(self: *const T, pbMute: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).GetMute(@ptrCast(*const ISimpleAudioVolume, self), pbMute);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AUDIO_DUCKING_OPTIONS = enum(u32) {
EFAULT = 0,
O_NOT_DUCK_OTHER_STREAMS = 1,
_,
pub fn initFlags(o: struct {
EFAULT: u1 = 0,
O_NOT_DUCK_OTHER_STREAMS: u1 = 0,
}) AUDIO_DUCKING_OPTIONS {
return @intToEnum(AUDIO_DUCKING_OPTIONS,
(if (o.EFAULT == 1) @enumToInt(AUDIO_DUCKING_OPTIONS.EFAULT) else 0)
| (if (o.O_NOT_DUCK_OTHER_STREAMS == 1) @enumToInt(AUDIO_DUCKING_OPTIONS.O_NOT_DUCK_OTHER_STREAMS) else 0)
);
}
};
pub const AUDIO_DUCKING_OPTIONS_DEFAULT = AUDIO_DUCKING_OPTIONS.EFAULT;
pub const AUDIO_DUCKING_OPTIONS_DO_NOT_DUCK_OTHER_STREAMS = AUDIO_DUCKING_OPTIONS.O_NOT_DUCK_OTHER_STREAMS;
const IID_IAudioClientDuckingControl_Value = Guid.initString("c789d381-a28c-4168-b28f-d3a837924dc3");
pub const IID_IAudioClientDuckingControl = &IID_IAudioClientDuckingControl_Value;
pub const IAudioClientDuckingControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetDuckingOptionsForCurrentStream: fn(
self: *const IAudioClientDuckingControl,
options: AUDIO_DUCKING_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioClientDuckingControl_SetDuckingOptionsForCurrentStream(self: *const T, options: AUDIO_DUCKING_OPTIONS) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioClientDuckingControl.VTable, self.vtable).SetDuckingOptionsForCurrentStream(@ptrCast(*const IAudioClientDuckingControl, self), options);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AUDIO_EFFECT_STATE = enum(i32) {
FF = 0,
N = 1,
};
pub const AUDIO_EFFECT_STATE_OFF = AUDIO_EFFECT_STATE.FF;
pub const AUDIO_EFFECT_STATE_ON = AUDIO_EFFECT_STATE.N;
pub const AUDIO_EFFECT = extern struct {
id: Guid,
canSetState: BOOL,
state: AUDIO_EFFECT_STATE,
};
const IID_IAudioEffectsChangedNotificationClient_Value = Guid.initString("a5ded44f-3c5d-4b2b-bd1e-5dc1ee20bbf6");
pub const IID_IAudioEffectsChangedNotificationClient = &IID_IAudioEffectsChangedNotificationClient_Value;
pub const IAudioEffectsChangedNotificationClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnAudioEffectsChanged: fn(
self: *const IAudioEffectsChangedNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioEffectsChangedNotificationClient_OnAudioEffectsChanged(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioEffectsChangedNotificationClient.VTable, self.vtable).OnAudioEffectsChanged(@ptrCast(*const IAudioEffectsChangedNotificationClient, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IAudioEffectsManager_Value = Guid.initString("4460b3ae-4b44-4527-8676-7548a8acd260");
pub const IID_IAudioEffectsManager = &IID_IAudioEffectsManager_Value;
pub const IAudioEffectsManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
RegisterAudioEffectsChangedNotificationCallback: fn(
self: *const IAudioEffectsManager,
client: ?*IAudioEffectsChangedNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterAudioEffectsChangedNotificationCallback: fn(
self: *const IAudioEffectsManager,
client: ?*IAudioEffectsChangedNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAudioEffects: fn(
self: *const IAudioEffectsManager,
effects: ?*?*AUDIO_EFFECT,
numEffects: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAudioEffectState: fn(
self: *const IAudioEffectsManager,
effectId: Guid,
state: AUDIO_EFFECT_STATE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioEffectsManager_RegisterAudioEffectsChangedNotificationCallback(self: *const T, client: ?*IAudioEffectsChangedNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioEffectsManager.VTable, self.vtable).RegisterAudioEffectsChangedNotificationCallback(@ptrCast(*const IAudioEffectsManager, self), client);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioEffectsManager_UnregisterAudioEffectsChangedNotificationCallback(self: *const T, client: ?*IAudioEffectsChangedNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioEffectsManager.VTable, self.vtable).UnregisterAudioEffectsChangedNotificationCallback(@ptrCast(*const IAudioEffectsManager, self), client);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioEffectsManager_GetAudioEffects(self: *const T, effects: ?*?*AUDIO_EFFECT, numEffects: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioEffectsManager.VTable, self.vtable).GetAudioEffects(@ptrCast(*const IAudioEffectsManager, self), effects, numEffects);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioEffectsManager_SetAudioEffectState(self: *const T, effectId: Guid, state: AUDIO_EFFECT_STATE) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioEffectsManager.VTable, self.vtable).SetAudioEffectState(@ptrCast(*const IAudioEffectsManager, self), effectId, state);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioStreamVolume_Value = Guid.initString("93014887-242d-4068-8a15-cf5e93b90fe3");
pub const IID_IAudioStreamVolume = &IID_IAudioStreamVolume_Value;
pub const IAudioStreamVolume = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetChannelCount: fn(
self: *const IAudioStreamVolume,
pdwCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetChannelVolume: fn(
self: *const IAudioStreamVolume,
dwIndex: u32,
fLevel: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetChannelVolume: fn(
self: *const IAudioStreamVolume,
dwIndex: u32,
pfLevel: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAllVolumes: fn(
self: *const IAudioStreamVolume,
dwCount: u32,
pfVolumes: [*]const f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAllVolumes: fn(
self: *const IAudioStreamVolume,
dwCount: u32,
pfVolumes: [*]f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStreamVolume_GetChannelCount(self: *const T, pdwCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStreamVolume.VTable, self.vtable).GetChannelCount(@ptrCast(*const IAudioStreamVolume, self), pdwCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStreamVolume_SetChannelVolume(self: *const T, dwIndex: u32, fLevel: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStreamVolume.VTable, self.vtable).SetChannelVolume(@ptrCast(*const IAudioStreamVolume, self), dwIndex, fLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStreamVolume_GetChannelVolume(self: *const T, dwIndex: u32, pfLevel: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStreamVolume.VTable, self.vtable).GetChannelVolume(@ptrCast(*const IAudioStreamVolume, self), dwIndex, pfLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStreamVolume_SetAllVolumes(self: *const T, dwCount: u32, pfVolumes: [*]const f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStreamVolume.VTable, self.vtable).SetAllVolumes(@ptrCast(*const IAudioStreamVolume, self), dwCount, pfVolumes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStreamVolume_GetAllVolumes(self: *const T, dwCount: u32, pfVolumes: [*]f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStreamVolume.VTable, self.vtable).GetAllVolumes(@ptrCast(*const IAudioStreamVolume, self), dwCount, pfVolumes);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AMBISONICS_TYPE = enum(i32) {
D = 0,
};
pub const AMBISONICS_TYPE_FULL3D = AMBISONICS_TYPE.D;
pub const AMBISONICS_CHANNEL_ORDERING = enum(i32) {
N = 0,
};
pub const AMBISONICS_CHANNEL_ORDERING_ACN = AMBISONICS_CHANNEL_ORDERING.N;
pub const AMBISONICS_NORMALIZATION = enum(i32) {
SN3D = 0,
N3D = 1,
};
pub const AMBISONICS_NORMALIZATION_SN3D = AMBISONICS_NORMALIZATION.SN3D;
pub const AMBISONICS_NORMALIZATION_N3D = AMBISONICS_NORMALIZATION.N3D;
pub const AMBISONICS_PARAMS = extern struct {
u32Size: u32,
u32Version: u32,
u32Type: AMBISONICS_TYPE,
u32ChannelOrdering: AMBISONICS_CHANNEL_ORDERING,
u32Normalization: AMBISONICS_NORMALIZATION,
u32Order: u32,
u32NumChannels: u32,
pu32ChannelMap: ?*u32,
};
const IID_IAudioAmbisonicsControl_Value = Guid.initString("28724c91-df35-4856-9f76-d6a26413f3df");
pub const IID_IAudioAmbisonicsControl = &IID_IAudioAmbisonicsControl_Value;
pub const IAudioAmbisonicsControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetData: fn(
self: *const IAudioAmbisonicsControl,
pAmbisonicsParams: [*]const AMBISONICS_PARAMS,
cbAmbisonicsParams: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetHeadTracking: fn(
self: *const IAudioAmbisonicsControl,
bEnableHeadTracking: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetHeadTracking: fn(
self: *const IAudioAmbisonicsControl,
pbEnableHeadTracking: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetRotation: fn(
self: *const IAudioAmbisonicsControl,
X: f32,
Y: f32,
Z: f32,
W: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAmbisonicsControl_SetData(self: *const T, pAmbisonicsParams: [*]const AMBISONICS_PARAMS, cbAmbisonicsParams: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAmbisonicsControl.VTable, self.vtable).SetData(@ptrCast(*const IAudioAmbisonicsControl, self), pAmbisonicsParams, cbAmbisonicsParams);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAmbisonicsControl_SetHeadTracking(self: *const T, bEnableHeadTracking: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAmbisonicsControl.VTable, self.vtable).SetHeadTracking(@ptrCast(*const IAudioAmbisonicsControl, self), bEnableHeadTracking);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAmbisonicsControl_GetHeadTracking(self: *const T, pbEnableHeadTracking: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAmbisonicsControl.VTable, self.vtable).GetHeadTracking(@ptrCast(*const IAudioAmbisonicsControl, self), pbEnableHeadTracking);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAmbisonicsControl_SetRotation(self: *const T, X: f32, Y: f32, Z: f32, W: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAmbisonicsControl.VTable, self.vtable).SetRotation(@ptrCast(*const IAudioAmbisonicsControl, self), X, Y, Z, W);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IChannelAudioVolume_Value = Guid.initString("1c158861-b533-4b30-b1cf-e853e51c59b8");
pub const IID_IChannelAudioVolume = &IID_IChannelAudioVolume_Value;
pub const IChannelAudioVolume = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetChannelCount: fn(
self: *const IChannelAudioVolume,
pdwCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetChannelVolume: fn(
self: *const IChannelAudioVolume,
dwIndex: u32,
fLevel: f32,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetChannelVolume: fn(
self: *const IChannelAudioVolume,
dwIndex: u32,
pfLevel: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAllVolumes: fn(
self: *const IChannelAudioVolume,
dwCount: u32,
pfVolumes: [*]const f32,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAllVolumes: fn(
self: *const IChannelAudioVolume,
dwCount: u32,
pfVolumes: [*]f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IChannelAudioVolume_GetChannelCount(self: *const T, pdwCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IChannelAudioVolume.VTable, self.vtable).GetChannelCount(@ptrCast(*const IChannelAudioVolume, self), pdwCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IChannelAudioVolume_SetChannelVolume(self: *const T, dwIndex: u32, fLevel: f32, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IChannelAudioVolume.VTable, self.vtable).SetChannelVolume(@ptrCast(*const IChannelAudioVolume, self), dwIndex, fLevel, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IChannelAudioVolume_GetChannelVolume(self: *const T, dwIndex: u32, pfLevel: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IChannelAudioVolume.VTable, self.vtable).GetChannelVolume(@ptrCast(*const IChannelAudioVolume, self), dwIndex, pfLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IChannelAudioVolume_SetAllVolumes(self: *const T, dwCount: u32, pfVolumes: [*]const f32, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IChannelAudioVolume.VTable, self.vtable).SetAllVolumes(@ptrCast(*const IChannelAudioVolume, self), dwCount, pfVolumes, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IChannelAudioVolume_GetAllVolumes(self: *const T, dwCount: u32, pfVolumes: [*]f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IChannelAudioVolume.VTable, self.vtable).GetAllVolumes(@ptrCast(*const IChannelAudioVolume, self), dwCount, pfVolumes);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AudioObjectType = enum(u32) {
None = 0,
Dynamic = 1,
FrontLeft = 2,
FrontRight = 4,
FrontCenter = 8,
LowFrequency = 16,
SideLeft = 32,
SideRight = 64,
BackLeft = 128,
BackRight = 256,
TopFrontLeft = 512,
TopFrontRight = 1024,
TopBackLeft = 2048,
TopBackRight = 4096,
BottomFrontLeft = 8192,
BottomFrontRight = 16384,
BottomBackLeft = 32768,
BottomBackRight = 65536,
BackCenter = 131072,
_,
pub fn initFlags(o: struct {
None: u1 = 0,
Dynamic: u1 = 0,
FrontLeft: u1 = 0,
FrontRight: u1 = 0,
FrontCenter: u1 = 0,
LowFrequency: u1 = 0,
SideLeft: u1 = 0,
SideRight: u1 = 0,
BackLeft: u1 = 0,
BackRight: u1 = 0,
TopFrontLeft: u1 = 0,
TopFrontRight: u1 = 0,
TopBackLeft: u1 = 0,
TopBackRight: u1 = 0,
BottomFrontLeft: u1 = 0,
BottomFrontRight: u1 = 0,
BottomBackLeft: u1 = 0,
BottomBackRight: u1 = 0,
BackCenter: u1 = 0,
}) AudioObjectType {
return @intToEnum(AudioObjectType,
(if (o.None == 1) @enumToInt(AudioObjectType.None) else 0)
| (if (o.Dynamic == 1) @enumToInt(AudioObjectType.Dynamic) else 0)
| (if (o.FrontLeft == 1) @enumToInt(AudioObjectType.FrontLeft) else 0)
| (if (o.FrontRight == 1) @enumToInt(AudioObjectType.FrontRight) else 0)
| (if (o.FrontCenter == 1) @enumToInt(AudioObjectType.FrontCenter) else 0)
| (if (o.LowFrequency == 1) @enumToInt(AudioObjectType.LowFrequency) else 0)
| (if (o.SideLeft == 1) @enumToInt(AudioObjectType.SideLeft) else 0)
| (if (o.SideRight == 1) @enumToInt(AudioObjectType.SideRight) else 0)
| (if (o.BackLeft == 1) @enumToInt(AudioObjectType.BackLeft) else 0)
| (if (o.BackRight == 1) @enumToInt(AudioObjectType.BackRight) else 0)
| (if (o.TopFrontLeft == 1) @enumToInt(AudioObjectType.TopFrontLeft) else 0)
| (if (o.TopFrontRight == 1) @enumToInt(AudioObjectType.TopFrontRight) else 0)
| (if (o.TopBackLeft == 1) @enumToInt(AudioObjectType.TopBackLeft) else 0)
| (if (o.TopBackRight == 1) @enumToInt(AudioObjectType.TopBackRight) else 0)
| (if (o.BottomFrontLeft == 1) @enumToInt(AudioObjectType.BottomFrontLeft) else 0)
| (if (o.BottomFrontRight == 1) @enumToInt(AudioObjectType.BottomFrontRight) else 0)
| (if (o.BottomBackLeft == 1) @enumToInt(AudioObjectType.BottomBackLeft) else 0)
| (if (o.BottomBackRight == 1) @enumToInt(AudioObjectType.BottomBackRight) else 0)
| (if (o.BackCenter == 1) @enumToInt(AudioObjectType.BackCenter) else 0)
);
}
};
pub const AudioObjectType_None = AudioObjectType.None;
pub const AudioObjectType_Dynamic = AudioObjectType.Dynamic;
pub const AudioObjectType_FrontLeft = AudioObjectType.FrontLeft;
pub const AudioObjectType_FrontRight = AudioObjectType.FrontRight;
pub const AudioObjectType_FrontCenter = AudioObjectType.FrontCenter;
pub const AudioObjectType_LowFrequency = AudioObjectType.LowFrequency;
pub const AudioObjectType_SideLeft = AudioObjectType.SideLeft;
pub const AudioObjectType_SideRight = AudioObjectType.SideRight;
pub const AudioObjectType_BackLeft = AudioObjectType.BackLeft;
pub const AudioObjectType_BackRight = AudioObjectType.BackRight;
pub const AudioObjectType_TopFrontLeft = AudioObjectType.TopFrontLeft;
pub const AudioObjectType_TopFrontRight = AudioObjectType.TopFrontRight;
pub const AudioObjectType_TopBackLeft = AudioObjectType.TopBackLeft;
pub const AudioObjectType_TopBackRight = AudioObjectType.TopBackRight;
pub const AudioObjectType_BottomFrontLeft = AudioObjectType.BottomFrontLeft;
pub const AudioObjectType_BottomFrontRight = AudioObjectType.BottomFrontRight;
pub const AudioObjectType_BottomBackLeft = AudioObjectType.BottomBackLeft;
pub const AudioObjectType_BottomBackRight = AudioObjectType.BottomBackRight;
pub const AudioObjectType_BackCenter = AudioObjectType.BackCenter;
pub const SPATIAL_AUDIO_STREAM_OPTIONS = enum(u32) {
NONE = 0,
OFFLOAD = 1,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
OFFLOAD: u1 = 0,
}) SPATIAL_AUDIO_STREAM_OPTIONS {
return @intToEnum(SPATIAL_AUDIO_STREAM_OPTIONS,
(if (o.NONE == 1) @enumToInt(SPATIAL_AUDIO_STREAM_OPTIONS.NONE) else 0)
| (if (o.OFFLOAD == 1) @enumToInt(SPATIAL_AUDIO_STREAM_OPTIONS.OFFLOAD) else 0)
);
}
};
pub const SPATIAL_AUDIO_STREAM_OPTIONS_NONE = SPATIAL_AUDIO_STREAM_OPTIONS.NONE;
pub const SPATIAL_AUDIO_STREAM_OPTIONS_OFFLOAD = SPATIAL_AUDIO_STREAM_OPTIONS.OFFLOAD;
pub const SpatialAudioObjectRenderStreamActivationParams = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
};
pub const SpatialAudioObjectRenderStreamActivationParams2 = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
Options: SPATIAL_AUDIO_STREAM_OPTIONS,
};
const IID_IAudioFormatEnumerator_Value = Guid.initString("dcdaa858-895a-4a22-a5eb-67bda506096d");
pub const IID_IAudioFormatEnumerator = &IID_IAudioFormatEnumerator_Value;
pub const IAudioFormatEnumerator = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCount: fn(
self: *const IAudioFormatEnumerator,
count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormat: fn(
self: *const IAudioFormatEnumerator,
index: u32,
format: ?*?*WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioFormatEnumerator_GetCount(self: *const T, count: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioFormatEnumerator.VTable, self.vtable).GetCount(@ptrCast(*const IAudioFormatEnumerator, self), count);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioFormatEnumerator_GetFormat(self: *const T, index: u32, format: ?*?*WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioFormatEnumerator.VTable, self.vtable).GetFormat(@ptrCast(*const IAudioFormatEnumerator, self), index, format);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectBase_Value = Guid.initString("cce0b8f2-8d4d-4efb-a8cf-3d6ecf1c30e0");
pub const IID_ISpatialAudioObjectBase = &IID_ISpatialAudioObjectBase_Value;
pub const ISpatialAudioObjectBase = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetBuffer: fn(
self: *const ISpatialAudioObjectBase,
buffer: ?*?*u8,
bufferLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEndOfStream: fn(
self: *const ISpatialAudioObjectBase,
frameCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsActive: fn(
self: *const ISpatialAudioObjectBase,
isActive: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAudioObjectType: fn(
self: *const ISpatialAudioObjectBase,
audioObjectType: ?*AudioObjectType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectBase_GetBuffer(self: *const T, buffer: ?*?*u8, bufferLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectBase.VTable, self.vtable).GetBuffer(@ptrCast(*const ISpatialAudioObjectBase, self), buffer, bufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectBase_SetEndOfStream(self: *const T, frameCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectBase.VTable, self.vtable).SetEndOfStream(@ptrCast(*const ISpatialAudioObjectBase, self), frameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectBase_IsActive(self: *const T, isActive: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectBase.VTable, self.vtable).IsActive(@ptrCast(*const ISpatialAudioObjectBase, self), isActive);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectBase_GetAudioObjectType(self: *const T, audioObjectType: ?*AudioObjectType) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectBase.VTable, self.vtable).GetAudioObjectType(@ptrCast(*const ISpatialAudioObjectBase, self), audioObjectType);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObject_Value = Guid.initString("dde28967-521b-46e5-8f00-bd6f2bc8ab1d");
pub const IID_ISpatialAudioObject = &IID_ISpatialAudioObject_Value;
pub const ISpatialAudioObject = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectBase.VTable,
SetPosition: fn(
self: *const ISpatialAudioObject,
x: f32,
y: f32,
z: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetVolume: fn(
self: *const ISpatialAudioObject,
volume: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObject_SetPosition(self: *const T, x: f32, y: f32, z: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObject.VTable, self.vtable).SetPosition(@ptrCast(*const ISpatialAudioObject, self), x, y, z);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObject_SetVolume(self: *const T, volume: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObject.VTable, self.vtable).SetVolume(@ptrCast(*const ISpatialAudioObject, self), volume);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectRenderStreamBase_Value = Guid.initString("feaaf403-c1d8-450d-aa05-e0ccee7502a8");
pub const IID_ISpatialAudioObjectRenderStreamBase = &IID_ISpatialAudioObjectRenderStreamBase_Value;
pub const ISpatialAudioObjectRenderStreamBase = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetAvailableDynamicObjectCount: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
value: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetService: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
riid: ?*const Guid,
service: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Start: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stop: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginUpdatingAudioObjects: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
availableDynamicObjectCount: ?*u32,
frameCountPerBuffer: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndUpdatingAudioObjects: fn(
self: *const ISpatialAudioObjectRenderStreamBase,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_GetAvailableDynamicObjectCount(self: *const T, value: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).GetAvailableDynamicObjectCount(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self), value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_GetService(self: *const T, riid: ?*const Guid, service: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).GetService(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self), riid, service);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_Start(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).Start(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_Stop(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).Stop(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).Reset(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_BeginUpdatingAudioObjects(self: *const T, availableDynamicObjectCount: ?*u32, frameCountPerBuffer: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).BeginUpdatingAudioObjects(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self), availableDynamicObjectCount, frameCountPerBuffer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamBase_EndUpdatingAudioObjects(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamBase.VTable, self.vtable).EndUpdatingAudioObjects(@ptrCast(*const ISpatialAudioObjectRenderStreamBase, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectRenderStream_Value = Guid.initString("bab5f473-b423-477b-85f5-b5a332a04153");
pub const IID_ISpatialAudioObjectRenderStream = &IID_ISpatialAudioObjectRenderStream_Value;
pub const ISpatialAudioObjectRenderStream = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectRenderStreamBase.VTable,
ActivateSpatialAudioObject: fn(
self: *const ISpatialAudioObjectRenderStream,
type: AudioObjectType,
audioObject: ?*?*ISpatialAudioObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectRenderStreamBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStream_ActivateSpatialAudioObject(self: *const T, type_: AudioObjectType, audioObject: ?*?*ISpatialAudioObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStream.VTable, self.vtable).ActivateSpatialAudioObject(@ptrCast(*const ISpatialAudioObjectRenderStream, self), type_, audioObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectRenderStreamNotify_Value = Guid.initString("dddf83e6-68d7-4c70-883f-a1836afb4a50");
pub const IID_ISpatialAudioObjectRenderStreamNotify = &IID_ISpatialAudioObjectRenderStreamNotify_Value;
pub const ISpatialAudioObjectRenderStreamNotify = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnAvailableDynamicObjectCountChange: fn(
self: *const ISpatialAudioObjectRenderStreamNotify,
sender: ?*ISpatialAudioObjectRenderStreamBase,
hnsComplianceDeadlineTime: i64,
availableDynamicObjectCountChange: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamNotify_OnAvailableDynamicObjectCountChange(self: *const T, sender: ?*ISpatialAudioObjectRenderStreamBase, hnsComplianceDeadlineTime: i64, availableDynamicObjectCountChange: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamNotify.VTable, self.vtable).OnAvailableDynamicObjectCountChange(@ptrCast(*const ISpatialAudioObjectRenderStreamNotify, self), sender, hnsComplianceDeadlineTime, availableDynamicObjectCountChange);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioClient_Value = Guid.initString("bbf8e066-aaaa-49be-9a4d-fd2a858ea27f");
pub const IID_ISpatialAudioClient = &IID_ISpatialAudioClient_Value;
pub const ISpatialAudioClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetStaticObjectPosition: fn(
self: *const ISpatialAudioClient,
type: AudioObjectType,
x: ?*f32,
y: ?*f32,
z: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNativeStaticObjectTypeMask: fn(
self: *const ISpatialAudioClient,
mask: ?*AudioObjectType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaxDynamicObjectCount: fn(
self: *const ISpatialAudioClient,
value: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSupportedAudioObjectFormatEnumerator: fn(
self: *const ISpatialAudioClient,
enumerator: ?*?*IAudioFormatEnumerator,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaxFrameCount: fn(
self: *const ISpatialAudioClient,
objectFormat: ?*const WAVEFORMATEX,
frameCountPerBuffer: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsAudioObjectFormatSupported: fn(
self: *const ISpatialAudioClient,
objectFormat: ?*const WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsSpatialAudioStreamAvailable: fn(
self: *const ISpatialAudioClient,
streamUuid: ?*const Guid,
auxiliaryInfo: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateSpatialAudioStream: fn(
self: *const ISpatialAudioClient,
activationParams: ?*const PROPVARIANT,
riid: ?*const Guid,
stream: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_GetStaticObjectPosition(self: *const T, type_: AudioObjectType, x: ?*f32, y: ?*f32, z: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).GetStaticObjectPosition(@ptrCast(*const ISpatialAudioClient, self), type_, x, y, z);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_GetNativeStaticObjectTypeMask(self: *const T, mask: ?*AudioObjectType) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).GetNativeStaticObjectTypeMask(@ptrCast(*const ISpatialAudioClient, self), mask);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_GetMaxDynamicObjectCount(self: *const T, value: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).GetMaxDynamicObjectCount(@ptrCast(*const ISpatialAudioClient, self), value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_GetSupportedAudioObjectFormatEnumerator(self: *const T, enumerator: ?*?*IAudioFormatEnumerator) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).GetSupportedAudioObjectFormatEnumerator(@ptrCast(*const ISpatialAudioClient, self), enumerator);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_GetMaxFrameCount(self: *const T, objectFormat: ?*const WAVEFORMATEX, frameCountPerBuffer: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).GetMaxFrameCount(@ptrCast(*const ISpatialAudioClient, self), objectFormat, frameCountPerBuffer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_IsAudioObjectFormatSupported(self: *const T, objectFormat: ?*const WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).IsAudioObjectFormatSupported(@ptrCast(*const ISpatialAudioClient, self), objectFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_IsSpatialAudioStreamAvailable(self: *const T, streamUuid: ?*const Guid, auxiliaryInfo: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).IsSpatialAudioStreamAvailable(@ptrCast(*const ISpatialAudioClient, self), streamUuid, auxiliaryInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient_ActivateSpatialAudioStream(self: *const T, activationParams: ?*const PROPVARIANT, riid: ?*const Guid, stream: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient.VTable, self.vtable).ActivateSpatialAudioStream(@ptrCast(*const ISpatialAudioClient, self), activationParams, riid, stream);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISpatialAudioClient2_Value = Guid.initString("caabe452-a66a-4bee-a93e-e320463f6a53");
pub const IID_ISpatialAudioClient2 = &IID_ISpatialAudioClient2_Value;
pub const ISpatialAudioClient2 = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioClient.VTable,
IsOffloadCapable: fn(
self: *const ISpatialAudioClient2,
category: AUDIO_STREAM_CATEGORY,
isOffloadCapable: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaxFrameCountForCategory: fn(
self: *const ISpatialAudioClient2,
category: AUDIO_STREAM_CATEGORY,
offloadEnabled: BOOL,
objectFormat: ?*const WAVEFORMATEX,
frameCountPerBuffer: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioClient.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient2_IsOffloadCapable(self: *const T, category: AUDIO_STREAM_CATEGORY, isOffloadCapable: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient2.VTable, self.vtable).IsOffloadCapable(@ptrCast(*const ISpatialAudioClient2, self), category, isOffloadCapable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioClient2_GetMaxFrameCountForCategory(self: *const T, category: AUDIO_STREAM_CATEGORY, offloadEnabled: BOOL, objectFormat: ?*const WAVEFORMATEX, frameCountPerBuffer: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioClient2.VTable, self.vtable).GetMaxFrameCountForCategory(@ptrCast(*const ISpatialAudioClient2, self), category, offloadEnabled, objectFormat, frameCountPerBuffer);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const SpatialAudioClientActivationParams = extern struct {
tracingContextId: Guid,
appId: Guid,
majorVersion: i32,
minorVersion1: i32,
minorVersion2: i32,
minorVersion3: i32,
};
pub const SpatialAudioHrtfDirectivityType = enum(i32) {
OmniDirectional = 0,
Cardioid = 1,
Cone = 2,
};
pub const SpatialAudioHrtfDirectivity_OmniDirectional = SpatialAudioHrtfDirectivityType.OmniDirectional;
pub const SpatialAudioHrtfDirectivity_Cardioid = SpatialAudioHrtfDirectivityType.Cardioid;
pub const SpatialAudioHrtfDirectivity_Cone = SpatialAudioHrtfDirectivityType.Cone;
pub const SpatialAudioHrtfEnvironmentType = enum(i32) {
Small = 0,
Medium = 1,
Large = 2,
Outdoors = 3,
Average = 4,
};
pub const SpatialAudioHrtfEnvironment_Small = SpatialAudioHrtfEnvironmentType.Small;
pub const SpatialAudioHrtfEnvironment_Medium = SpatialAudioHrtfEnvironmentType.Medium;
pub const SpatialAudioHrtfEnvironment_Large = SpatialAudioHrtfEnvironmentType.Large;
pub const SpatialAudioHrtfEnvironment_Outdoors = SpatialAudioHrtfEnvironmentType.Outdoors;
pub const SpatialAudioHrtfEnvironment_Average = SpatialAudioHrtfEnvironmentType.Average;
pub const SpatialAudioHrtfDistanceDecayType = enum(i32) {
NaturalDecay = 0,
CustomDecay = 1,
};
pub const SpatialAudioHrtfDistanceDecay_NaturalDecay = SpatialAudioHrtfDistanceDecayType.NaturalDecay;
pub const SpatialAudioHrtfDistanceDecay_CustomDecay = SpatialAudioHrtfDistanceDecayType.CustomDecay;
pub const SpatialAudioHrtfDirectivity = packed struct {
Type: SpatialAudioHrtfDirectivityType,
Scaling: f32,
};
pub const SpatialAudioHrtfDirectivityCardioid = packed struct {
directivity: SpatialAudioHrtfDirectivity,
Order: f32,
};
pub const SpatialAudioHrtfDirectivityCone = packed struct {
directivity: SpatialAudioHrtfDirectivity,
InnerAngle: f32,
OuterAngle: f32,
};
pub const SpatialAudioHrtfDirectivityUnion = extern union {
Cone: SpatialAudioHrtfDirectivityCone,
Cardiod: SpatialAudioHrtfDirectivityCardioid,
Omni: SpatialAudioHrtfDirectivity,
};
pub const SpatialAudioHrtfDistanceDecay = packed struct {
Type: SpatialAudioHrtfDistanceDecayType,
MaxGain: f32,
MinGain: f32,
UnityGainDistance: f32,
CutoffDistance: f32,
};
pub const SpatialAudioHrtfActivationParams = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
DistanceDecay: ?*SpatialAudioHrtfDistanceDecay,
Directivity: ?*SpatialAudioHrtfDirectivityUnion,
Environment: ?*SpatialAudioHrtfEnvironmentType,
Orientation: ?*f32,
};
pub const SpatialAudioHrtfActivationParams2 = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
DistanceDecay: ?*SpatialAudioHrtfDistanceDecay,
Directivity: ?*SpatialAudioHrtfDirectivityUnion,
Environment: ?*SpatialAudioHrtfEnvironmentType,
Orientation: ?*f32,
Options: SPATIAL_AUDIO_STREAM_OPTIONS,
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectForHrtf_Value = Guid.initString("d7436ade-1978-4e14-aba0-555bd8eb83b4");
pub const IID_ISpatialAudioObjectForHrtf = &IID_ISpatialAudioObjectForHrtf_Value;
pub const ISpatialAudioObjectForHrtf = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectBase.VTable,
SetPosition: fn(
self: *const ISpatialAudioObjectForHrtf,
x: f32,
y: f32,
z: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetGain: fn(
self: *const ISpatialAudioObjectForHrtf,
gain: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOrientation: fn(
self: *const ISpatialAudioObjectForHrtf,
orientation: ?*const ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEnvironment: fn(
self: *const ISpatialAudioObjectForHrtf,
environment: SpatialAudioHrtfEnvironmentType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDistanceDecay: fn(
self: *const ISpatialAudioObjectForHrtf,
distanceDecay: ?*SpatialAudioHrtfDistanceDecay,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDirectivity: fn(
self: *const ISpatialAudioObjectForHrtf,
directivity: ?*SpatialAudioHrtfDirectivityUnion,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetPosition(self: *const T, x: f32, y: f32, z: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetPosition(@ptrCast(*const ISpatialAudioObjectForHrtf, self), x, y, z);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetGain(self: *const T, gain: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetGain(@ptrCast(*const ISpatialAudioObjectForHrtf, self), gain);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetOrientation(self: *const T, orientation: ?*const ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetOrientation(@ptrCast(*const ISpatialAudioObjectForHrtf, self), orientation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetEnvironment(self: *const T, environment: SpatialAudioHrtfEnvironmentType) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetEnvironment(@ptrCast(*const ISpatialAudioObjectForHrtf, self), environment);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetDistanceDecay(self: *const T, distanceDecay: ?*SpatialAudioHrtfDistanceDecay) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetDistanceDecay(@ptrCast(*const ISpatialAudioObjectForHrtf, self), distanceDecay);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForHrtf_SetDirectivity(self: *const T, directivity: ?*SpatialAudioHrtfDirectivityUnion) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForHrtf.VTable, self.vtable).SetDirectivity(@ptrCast(*const ISpatialAudioObjectForHrtf, self), directivity);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectRenderStreamForHrtf_Value = Guid.initString("e08deef9-5363-406e-9fdc-080ee247bbe0");
pub const IID_ISpatialAudioObjectRenderStreamForHrtf = &IID_ISpatialAudioObjectRenderStreamForHrtf_Value;
pub const ISpatialAudioObjectRenderStreamForHrtf = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectRenderStreamBase.VTable,
ActivateSpatialAudioObjectForHrtf: fn(
self: *const ISpatialAudioObjectRenderStreamForHrtf,
type: AudioObjectType,
audioObject: ?*?*ISpatialAudioObjectForHrtf,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectRenderStreamBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamForHrtf_ActivateSpatialAudioObjectForHrtf(self: *const T, type_: AudioObjectType, audioObject: ?*?*ISpatialAudioObjectForHrtf) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamForHrtf.VTable, self.vtable).ActivateSpatialAudioObjectForHrtf(@ptrCast(*const ISpatialAudioObjectRenderStreamForHrtf, self), type_, audioObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_MMDeviceEnumerator_Value = Guid.initString("bcde0395-e52f-467c-8e3d-c4579291692e");
pub const CLSID_MMDeviceEnumerator = &CLSID_MMDeviceEnumerator_Value;
pub const DIRECTX_AUDIO_ACTIVATION_PARAMS = extern struct {
cbDirectXAudioActivationParams: u32,
guidAudioSession: Guid,
dwAudioStreamFlags: u32,
};
pub const EDataFlow = enum(i32) {
eRender = 0,
eCapture = 1,
eAll = 2,
EDataFlow_enum_count = 3,
};
pub const eRender = EDataFlow.eRender;
pub const eCapture = EDataFlow.eCapture;
pub const eAll = EDataFlow.eAll;
pub const EDataFlow_enum_count = EDataFlow.EDataFlow_enum_count;
pub const ERole = enum(i32) {
eConsole = 0,
eMultimedia = 1,
eCommunications = 2,
ERole_enum_count = 3,
};
pub const eConsole = ERole.eConsole;
pub const eMultimedia = ERole.eMultimedia;
pub const eCommunications = ERole.eCommunications;
pub const ERole_enum_count = ERole.ERole_enum_count;
pub const EndpointFormFactor = enum(i32) {
RemoteNetworkDevice = 0,
Speakers = 1,
LineLevel = 2,
Headphones = 3,
Microphone = 4,
Headset = 5,
Handset = 6,
UnknownDigitalPassthrough = 7,
SPDIF = 8,
DigitalAudioDisplayDevice = 9,
UnknownFormFactor = 10,
EndpointFormFactor_enum_count = 11,
};
pub const RemoteNetworkDevice = EndpointFormFactor.RemoteNetworkDevice;
pub const Speakers = EndpointFormFactor.Speakers;
pub const LineLevel = EndpointFormFactor.LineLevel;
pub const Headphones = EndpointFormFactor.Headphones;
pub const Microphone = EndpointFormFactor.Microphone;
pub const Headset = EndpointFormFactor.Headset;
pub const Handset = EndpointFormFactor.Handset;
pub const UnknownDigitalPassthrough = EndpointFormFactor.UnknownDigitalPassthrough;
pub const SPDIF = EndpointFormFactor.SPDIF;
pub const DigitalAudioDisplayDevice = EndpointFormFactor.DigitalAudioDisplayDevice;
pub const UnknownFormFactor = EndpointFormFactor.UnknownFormFactor;
pub const EndpointFormFactor_enum_count = EndpointFormFactor.EndpointFormFactor_enum_count;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMMNotificationClient_Value = Guid.initString("7991eec9-7e89-4d85-8390-6c703cec60c0");
pub const IID_IMMNotificationClient = &IID_IMMNotificationClient_Value;
pub const IMMNotificationClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnDeviceStateChanged: fn(
self: *const IMMNotificationClient,
pwstrDeviceId: ?[*:0]const u16,
dwNewState: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnDeviceAdded: fn(
self: *const IMMNotificationClient,
pwstrDeviceId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnDeviceRemoved: fn(
self: *const IMMNotificationClient,
pwstrDeviceId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnDefaultDeviceChanged: fn(
self: *const IMMNotificationClient,
flow: EDataFlow,
role: ERole,
pwstrDefaultDeviceId: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnPropertyValueChanged: fn(
self: *const IMMNotificationClient,
pwstrDeviceId: ?[*:0]const u16,
key: PROPERTYKEY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMNotificationClient_OnDeviceStateChanged(self: *const T, pwstrDeviceId: ?[*:0]const u16, dwNewState: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceStateChanged(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId, dwNewState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMNotificationClient_OnDeviceAdded(self: *const T, pwstrDeviceId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceAdded(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMNotificationClient_OnDeviceRemoved(self: *const T, pwstrDeviceId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceRemoved(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMNotificationClient_OnDefaultDeviceChanged(self: *const T, flow: EDataFlow, role: ERole, pwstrDefaultDeviceId: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDefaultDeviceChanged(@ptrCast(*const IMMNotificationClient, self), flow, role, pwstrDefaultDeviceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMNotificationClient_OnPropertyValueChanged(self: *const T, pwstrDeviceId: ?[*:0]const u16, key: PROPERTYKEY) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnPropertyValueChanged(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId, key);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMMDevice_Value = Guid.initString("d666063f-1587-4e43-81f1-b948e807363f");
pub const IID_IMMDevice = &IID_IMMDevice_Value;
pub const IMMDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Activate: fn(
self: *const IMMDevice,
iid: ?*const Guid,
dwClsCtx: u32,
pActivationParams: ?*PROPVARIANT,
ppInterface: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenPropertyStore: fn(
self: *const IMMDevice,
stgmAccess: u32,
ppProperties: ?*?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetId: fn(
self: *const IMMDevice,
ppstrId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetState: fn(
self: *const IMMDevice,
pdwState: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDevice_Activate(self: *const T, iid: ?*const Guid, dwClsCtx: u32, pActivationParams: ?*PROPVARIANT, ppInterface: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDevice.VTable, self.vtable).Activate(@ptrCast(*const IMMDevice, self), iid, dwClsCtx, pActivationParams, ppInterface);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDevice_OpenPropertyStore(self: *const T, stgmAccess: u32, ppProperties: ?*?*IPropertyStore) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDevice.VTable, self.vtable).OpenPropertyStore(@ptrCast(*const IMMDevice, self), stgmAccess, ppProperties);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDevice_GetId(self: *const T, ppstrId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDevice.VTable, self.vtable).GetId(@ptrCast(*const IMMDevice, self), ppstrId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDevice_GetState(self: *const T, pdwState: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDevice.VTable, self.vtable).GetState(@ptrCast(*const IMMDevice, self), pdwState);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMMDeviceCollection_Value = Guid.initString("0bd7a1be-7a1a-44db-8397-cc5392387b5e");
pub const IID_IMMDeviceCollection = &IID_IMMDeviceCollection_Value;
pub const IMMDeviceCollection = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCount: fn(
self: *const IMMDeviceCollection,
pcDevices: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const IMMDeviceCollection,
nDevice: u32,
ppDevice: ?*?*IMMDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceCollection_GetCount(self: *const T, pcDevices: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceCollection.VTable, self.vtable).GetCount(@ptrCast(*const IMMDeviceCollection, self), pcDevices);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceCollection_Item(self: *const T, nDevice: u32, ppDevice: ?*?*IMMDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceCollection.VTable, self.vtable).Item(@ptrCast(*const IMMDeviceCollection, self), nDevice, ppDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMMEndpoint_Value = Guid.initString("1be09788-6894-4089-8586-9a2a6c265ac5");
pub const IID_IMMEndpoint = &IID_IMMEndpoint_Value;
pub const IMMEndpoint = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDataFlow: fn(
self: *const IMMEndpoint,
pDataFlow: ?*EDataFlow,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMEndpoint_GetDataFlow(self: *const T, pDataFlow: ?*EDataFlow) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMEndpoint.VTable, self.vtable).GetDataFlow(@ptrCast(*const IMMEndpoint, self), pDataFlow);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMMDeviceEnumerator_Value = Guid.initString("a95664d2-9614-4f35-a746-de8db63617e6");
pub const IID_IMMDeviceEnumerator = &IID_IMMDeviceEnumerator_Value;
pub const IMMDeviceEnumerator = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
EnumAudioEndpoints: fn(
self: *const IMMDeviceEnumerator,
dataFlow: EDataFlow,
dwStateMask: u32,
ppDevices: ?*?*IMMDeviceCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDefaultAudioEndpoint: fn(
self: *const IMMDeviceEnumerator,
dataFlow: EDataFlow,
role: ERole,
ppEndpoint: ?*?*IMMDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDevice: fn(
self: *const IMMDeviceEnumerator,
pwstrId: ?[*:0]const u16,
ppDevice: ?*?*IMMDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterEndpointNotificationCallback: fn(
self: *const IMMDeviceEnumerator,
pClient: ?*IMMNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterEndpointNotificationCallback: fn(
self: *const IMMDeviceEnumerator,
pClient: ?*IMMNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceEnumerator_EnumAudioEndpoints(self: *const T, dataFlow: EDataFlow, dwStateMask: u32, ppDevices: ?*?*IMMDeviceCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).EnumAudioEndpoints(@ptrCast(*const IMMDeviceEnumerator, self), dataFlow, dwStateMask, ppDevices);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceEnumerator_GetDefaultAudioEndpoint(self: *const T, dataFlow: EDataFlow, role: ERole, ppEndpoint: ?*?*IMMDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).GetDefaultAudioEndpoint(@ptrCast(*const IMMDeviceEnumerator, self), dataFlow, role, ppEndpoint);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceEnumerator_GetDevice(self: *const T, pwstrId: ?[*:0]const u16, ppDevice: ?*?*IMMDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).GetDevice(@ptrCast(*const IMMDeviceEnumerator, self), pwstrId, ppDevice);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceEnumerator_RegisterEndpointNotificationCallback(self: *const T, pClient: ?*IMMNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).RegisterEndpointNotificationCallback(@ptrCast(*const IMMDeviceEnumerator, self), pClient);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceEnumerator_UnregisterEndpointNotificationCallback(self: *const T, pClient: ?*IMMNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).UnregisterEndpointNotificationCallback(@ptrCast(*const IMMDeviceEnumerator, self), pClient);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMMDeviceActivator_Value = Guid.initString("3b0d0ea4-d0a9-4b0e-935b-09516746fac0");
pub const IID_IMMDeviceActivator = &IID_IMMDeviceActivator_Value;
pub const IMMDeviceActivator = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Activate: fn(
self: *const IMMDeviceActivator,
iid: ?*const Guid,
pDevice: ?*IMMDevice,
pActivationParams: ?*PROPVARIANT,
ppInterface: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMMDeviceActivator_Activate(self: *const T, iid: ?*const Guid, pDevice: ?*IMMDevice, pActivationParams: ?*PROPVARIANT, ppInterface: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IMMDeviceActivator.VTable, self.vtable).Activate(@ptrCast(*const IMMDeviceActivator, self), iid, pDevice, pActivationParams, ppInterface);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IActivateAudioInterfaceCompletionHandler_Value = Guid.initString("41d949ab-9862-444a-80f6-c261334da5eb");
pub const IID_IActivateAudioInterfaceCompletionHandler = &IID_IActivateAudioInterfaceCompletionHandler_Value;
pub const IActivateAudioInterfaceCompletionHandler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ActivateCompleted: fn(
self: *const IActivateAudioInterfaceCompletionHandler,
activateOperation: ?*IActivateAudioInterfaceAsyncOperation,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActivateAudioInterfaceCompletionHandler_ActivateCompleted(self: *const T, activateOperation: ?*IActivateAudioInterfaceAsyncOperation) callconv(.Inline) HRESULT {
return @ptrCast(*const IActivateAudioInterfaceCompletionHandler.VTable, self.vtable).ActivateCompleted(@ptrCast(*const IActivateAudioInterfaceCompletionHandler, self), activateOperation);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IActivateAudioInterfaceAsyncOperation_Value = Guid.initString("72a22d78-cde4-431d-b8cc-843a71199b6d");
pub const IID_IActivateAudioInterfaceAsyncOperation = &IID_IActivateAudioInterfaceAsyncOperation_Value;
pub const IActivateAudioInterfaceAsyncOperation = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetActivateResult: fn(
self: *const IActivateAudioInterfaceAsyncOperation,
activateResult: ?*HRESULT,
activatedInterface: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActivateAudioInterfaceAsyncOperation_GetActivateResult(self: *const T, activateResult: ?*HRESULT, activatedInterface: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IActivateAudioInterfaceAsyncOperation.VTable, self.vtable).GetActivateResult(@ptrCast(*const IActivateAudioInterfaceAsyncOperation, self), activateResult, activatedInterface);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AudioExtensionParams = extern struct {
AddPageParam: LPARAM,
pEndpoint: ?*IMMDevice,
pPnpInterface: ?*IMMDevice,
pPnpDevnode: ?*IMMDevice,
};
pub const __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002 = enum(i32) {
DEFAULT = 0,
USER = 1,
VOLATILE = 2,
ENUM_COUNT = 3,
};
pub const AUDIO_SYSTEMEFFECTS_PROPERTYSTORE_TYPE_DEFAULT = __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002.DEFAULT;
pub const AUDIO_SYSTEMEFFECTS_PROPERTYSTORE_TYPE_USER = __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002.USER;
pub const AUDIO_SYSTEMEFFECTS_PROPERTYSTORE_TYPE_VOLATILE = __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002.VOLATILE;
pub const AUDIO_SYSTEMEFFECTS_PROPERTYSTORE_TYPE_ENUM_COUNT = __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002.ENUM_COUNT;
const IID_IAudioSystemEffectsPropertyChangeNotificationClient_Value = Guid.initString("20049d40-56d5-400e-a2ef-385599feed49");
pub const IID_IAudioSystemEffectsPropertyChangeNotificationClient = &IID_IAudioSystemEffectsPropertyChangeNotificationClient_Value;
pub const IAudioSystemEffectsPropertyChangeNotificationClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnPropertyChanged: fn(
self: *const IAudioSystemEffectsPropertyChangeNotificationClient,
type: __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002,
key: PROPERTYKEY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyChangeNotificationClient_OnPropertyChanged(self: *const T, type_: __MIDL___MIDL_itf_mmdeviceapi_0000_0008_0002, key: PROPERTYKEY) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyChangeNotificationClient.VTable, self.vtable).OnPropertyChanged(@ptrCast(*const IAudioSystemEffectsPropertyChangeNotificationClient, self), type_, key);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IAudioSystemEffectsPropertyStore_Value = Guid.initString("302ae7f9-d7e0-43e4-971b-1f8293613d2a");
pub const IID_IAudioSystemEffectsPropertyStore = &IID_IAudioSystemEffectsPropertyStore_Value;
pub const IAudioSystemEffectsPropertyStore = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OpenDefaultPropertyStore: fn(
self: *const IAudioSystemEffectsPropertyStore,
stgmAccess: u32,
propStore: ?*?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenUserPropertyStore: fn(
self: *const IAudioSystemEffectsPropertyStore,
stgmAccess: u32,
propStore: ?*?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenVolatilePropertyStore: fn(
self: *const IAudioSystemEffectsPropertyStore,
stgmAccess: u32,
propStore: ?*?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ResetUserPropertyStore: fn(
self: *const IAudioSystemEffectsPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ResetVolatilePropertyStore: fn(
self: *const IAudioSystemEffectsPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterPropertyChangeNotification: fn(
self: *const IAudioSystemEffectsPropertyStore,
callback: ?*IAudioSystemEffectsPropertyChangeNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterPropertyChangeNotification: fn(
self: *const IAudioSystemEffectsPropertyStore,
callback: ?*IAudioSystemEffectsPropertyChangeNotificationClient,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_OpenDefaultPropertyStore(self: *const T, stgmAccess: u32, propStore: ?*?*IPropertyStore) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).OpenDefaultPropertyStore(@ptrCast(*const IAudioSystemEffectsPropertyStore, self), stgmAccess, propStore);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_OpenUserPropertyStore(self: *const T, stgmAccess: u32, propStore: ?*?*IPropertyStore) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).OpenUserPropertyStore(@ptrCast(*const IAudioSystemEffectsPropertyStore, self), stgmAccess, propStore);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_OpenVolatilePropertyStore(self: *const T, stgmAccess: u32, propStore: ?*?*IPropertyStore) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).OpenVolatilePropertyStore(@ptrCast(*const IAudioSystemEffectsPropertyStore, self), stgmAccess, propStore);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_ResetUserPropertyStore(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).ResetUserPropertyStore(@ptrCast(*const IAudioSystemEffectsPropertyStore, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_ResetVolatilePropertyStore(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).ResetVolatilePropertyStore(@ptrCast(*const IAudioSystemEffectsPropertyStore, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_RegisterPropertyChangeNotification(self: *const T, callback: ?*IAudioSystemEffectsPropertyChangeNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).RegisterPropertyChangeNotification(@ptrCast(*const IAudioSystemEffectsPropertyStore, self), callback);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSystemEffectsPropertyStore_UnregisterPropertyChangeNotification(self: *const T, callback: ?*IAudioSystemEffectsPropertyChangeNotificationClient) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSystemEffectsPropertyStore.VTable, self.vtable).UnregisterPropertyChangeNotification(@ptrCast(*const IAudioSystemEffectsPropertyStore, self), callback);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_DeviceTopology_Value = Guid.initString("1df639d0-5ec1-47aa-9379-828dc1aa8c59");
pub const CLSID_DeviceTopology = &CLSID_DeviceTopology_Value;
pub const DataFlow = enum(i32) {
In = 0,
Out = 1,
};
pub const In = DataFlow.In;
pub const Out = DataFlow.Out;
pub const PartType = enum(i32) {
Connector = 0,
Subunit = 1,
};
pub const Connector = PartType.Connector;
pub const Subunit = PartType.Subunit;
pub const ConnectorType = enum(i32) {
Unknown_Connector = 0,
Physical_Internal = 1,
Physical_External = 2,
Software_IO = 3,
Software_Fixed = 4,
Network = 5,
};
// NOTE: not creating aliases because this enum is 'Scoped'
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IPerChannelDbLevel_Value = Guid.initString("c2f8e001-f205-4bc9-99bc-c13b1e048ccb");
pub const IID_IPerChannelDbLevel = &IID_IPerChannelDbLevel_Value;
pub const IPerChannelDbLevel = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetChannelCount: fn(
self: *const IPerChannelDbLevel,
pcChannels: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLevelRange: fn(
self: *const IPerChannelDbLevel,
nChannel: u32,
pfMinLevelDB: ?*f32,
pfMaxLevelDB: ?*f32,
pfStepping: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLevel: fn(
self: *const IPerChannelDbLevel,
nChannel: u32,
pfLevelDB: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLevel: fn(
self: *const IPerChannelDbLevel,
nChannel: u32,
fLevelDB: f32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLevelUniform: fn(
self: *const IPerChannelDbLevel,
fLevelDB: f32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLevelAllChannels: fn(
self: *const IPerChannelDbLevel,
aLevelsDB: [*]f32,
cChannels: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_GetChannelCount(self: *const T, pcChannels: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).GetChannelCount(@ptrCast(*const IPerChannelDbLevel, self), pcChannels);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_GetLevelRange(self: *const T, nChannel: u32, pfMinLevelDB: ?*f32, pfMaxLevelDB: ?*f32, pfStepping: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).GetLevelRange(@ptrCast(*const IPerChannelDbLevel, self), nChannel, pfMinLevelDB, pfMaxLevelDB, pfStepping);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_GetLevel(self: *const T, nChannel: u32, pfLevelDB: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).GetLevel(@ptrCast(*const IPerChannelDbLevel, self), nChannel, pfLevelDB);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_SetLevel(self: *const T, nChannel: u32, fLevelDB: f32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).SetLevel(@ptrCast(*const IPerChannelDbLevel, self), nChannel, fLevelDB, pguidEventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_SetLevelUniform(self: *const T, fLevelDB: f32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).SetLevelUniform(@ptrCast(*const IPerChannelDbLevel, self), fLevelDB, pguidEventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPerChannelDbLevel_SetLevelAllChannels(self: *const T, aLevelsDB: [*]f32, cChannels: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IPerChannelDbLevel.VTable, self.vtable).SetLevelAllChannels(@ptrCast(*const IPerChannelDbLevel, self), aLevelsDB, cChannels, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioVolumeLevel_Value = Guid.initString("7fb7b48f-531d-44a2-bcb3-5ad5a134b3dc");
pub const IID_IAudioVolumeLevel = &IID_IAudioVolumeLevel_Value;
pub const IAudioVolumeLevel = extern struct {
pub const VTable = extern struct {
base: IPerChannelDbLevel.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IPerChannelDbLevel.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioChannelConfig_Value = Guid.initString("bb11c46f-ec28-493c-b88a-5db88062ce98");
pub const IID_IAudioChannelConfig = &IID_IAudioChannelConfig_Value;
pub const IAudioChannelConfig = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetChannelConfig: fn(
self: *const IAudioChannelConfig,
dwConfig: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetChannelConfig: fn(
self: *const IAudioChannelConfig,
pdwConfig: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioChannelConfig_SetChannelConfig(self: *const T, dwConfig: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioChannelConfig.VTable, self.vtable).SetChannelConfig(@ptrCast(*const IAudioChannelConfig, self), dwConfig, pguidEventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioChannelConfig_GetChannelConfig(self: *const T, pdwConfig: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioChannelConfig.VTable, self.vtable).GetChannelConfig(@ptrCast(*const IAudioChannelConfig, self), pdwConfig);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioLoudness_Value = Guid.initString("7d8b1437-dd53-4350-9c1b-1ee2890bd938");
pub const IID_IAudioLoudness = &IID_IAudioLoudness_Value;
pub const IAudioLoudness = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetEnabled: fn(
self: *const IAudioLoudness,
pbEnabled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEnabled: fn(
self: *const IAudioLoudness,
bEnable: BOOL,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioLoudness_GetEnabled(self: *const T, pbEnabled: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioLoudness.VTable, self.vtable).GetEnabled(@ptrCast(*const IAudioLoudness, self), pbEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioLoudness_SetEnabled(self: *const T, bEnable: BOOL, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioLoudness.VTable, self.vtable).SetEnabled(@ptrCast(*const IAudioLoudness, self), bEnable, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioInputSelector_Value = Guid.initString("4f03dc02-5e6e-4653-8f72-a030c123d598");
pub const IID_IAudioInputSelector = &IID_IAudioInputSelector_Value;
pub const IAudioInputSelector = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetSelection: fn(
self: *const IAudioInputSelector,
pnIdSelected: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSelection: fn(
self: *const IAudioInputSelector,
nIdSelect: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioInputSelector_GetSelection(self: *const T, pnIdSelected: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioInputSelector.VTable, self.vtable).GetSelection(@ptrCast(*const IAudioInputSelector, self), pnIdSelected);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioInputSelector_SetSelection(self: *const T, nIdSelect: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioInputSelector.VTable, self.vtable).SetSelection(@ptrCast(*const IAudioInputSelector, self), nIdSelect, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioOutputSelector_Value = Guid.initString("bb515f69-94a7-429e-8b9c-271b3f11a3ab");
pub const IID_IAudioOutputSelector = &IID_IAudioOutputSelector_Value;
pub const IAudioOutputSelector = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetSelection: fn(
self: *const IAudioOutputSelector,
pnIdSelected: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSelection: fn(
self: *const IAudioOutputSelector,
nIdSelect: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioOutputSelector_GetSelection(self: *const T, pnIdSelected: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioOutputSelector.VTable, self.vtable).GetSelection(@ptrCast(*const IAudioOutputSelector, self), pnIdSelected);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioOutputSelector_SetSelection(self: *const T, nIdSelect: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioOutputSelector.VTable, self.vtable).SetSelection(@ptrCast(*const IAudioOutputSelector, self), nIdSelect, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioMute_Value = Guid.initString("df45aeea-b74a-4b6b-afad-2366b6aa012e");
pub const IID_IAudioMute = &IID_IAudioMute_Value;
pub const IAudioMute = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetMute: fn(
self: *const IAudioMute,
bMuted: BOOL,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMute: fn(
self: *const IAudioMute,
pbMuted: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioMute_SetMute(self: *const T, bMuted: BOOL, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioMute.VTable, self.vtable).SetMute(@ptrCast(*const IAudioMute, self), bMuted, pguidEventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioMute_GetMute(self: *const T, pbMuted: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioMute.VTable, self.vtable).GetMute(@ptrCast(*const IAudioMute, self), pbMuted);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioBass_Value = Guid.initString("a2b1a1d9-4db3-425d-a2b2-bd335cb3e2e5");
pub const IID_IAudioBass = &IID_IAudioBass_Value;
pub const IAudioBass = extern struct {
pub const VTable = extern struct {
base: IPerChannelDbLevel.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IPerChannelDbLevel.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioMidrange_Value = Guid.initString("5e54b6d7-b44b-40d9-9a9e-e691d9ce6edf");
pub const IID_IAudioMidrange = &IID_IAudioMidrange_Value;
pub const IAudioMidrange = extern struct {
pub const VTable = extern struct {
base: IPerChannelDbLevel.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IPerChannelDbLevel.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioTreble_Value = Guid.initString("0a717812-694e-4907-b74b-bafa5cfdca7b");
pub const IID_IAudioTreble = &IID_IAudioTreble_Value;
pub const IAudioTreble = extern struct {
pub const VTable = extern struct {
base: IPerChannelDbLevel.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IPerChannelDbLevel.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioAutoGainControl_Value = Guid.initString("85401fd4-6de4-4b9d-9869-2d6753a82f3c");
pub const IID_IAudioAutoGainControl = &IID_IAudioAutoGainControl_Value;
pub const IAudioAutoGainControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetEnabled: fn(
self: *const IAudioAutoGainControl,
pbEnabled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEnabled: fn(
self: *const IAudioAutoGainControl,
bEnable: BOOL,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAutoGainControl_GetEnabled(self: *const T, pbEnabled: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAutoGainControl.VTable, self.vtable).GetEnabled(@ptrCast(*const IAudioAutoGainControl, self), pbEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioAutoGainControl_SetEnabled(self: *const T, bEnable: BOOL, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioAutoGainControl.VTable, self.vtable).SetEnabled(@ptrCast(*const IAudioAutoGainControl, self), bEnable, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioPeakMeter_Value = Guid.initString("dd79923c-0599-45e0-b8b6-c8df7db6e796");
pub const IID_IAudioPeakMeter = &IID_IAudioPeakMeter_Value;
pub const IAudioPeakMeter = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetChannelCount: fn(
self: *const IAudioPeakMeter,
pcChannels: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLevel: fn(
self: *const IAudioPeakMeter,
nChannel: u32,
pfLevel: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioPeakMeter_GetChannelCount(self: *const T, pcChannels: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioPeakMeter.VTable, self.vtable).GetChannelCount(@ptrCast(*const IAudioPeakMeter, self), pcChannels);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioPeakMeter_GetLevel(self: *const T, nChannel: u32, pfLevel: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioPeakMeter.VTable, self.vtable).GetLevel(@ptrCast(*const IAudioPeakMeter, self), nChannel, pfLevel);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IDeviceSpecificProperty_Value = Guid.initString("3b22bcbf-2586-4af0-8583-205d391b807c");
pub const IID_IDeviceSpecificProperty = &IID_IDeviceSpecificProperty_Value;
pub const IDeviceSpecificProperty = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetType: fn(
self: *const IDeviceSpecificProperty,
pVType: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValue: fn(
self: *const IDeviceSpecificProperty,
pvValue: ?*anyopaque,
pcbValue: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetValue: fn(
self: *const IDeviceSpecificProperty,
pvValue: ?*anyopaque,
cbValue: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Get4BRange: fn(
self: *const IDeviceSpecificProperty,
plMin: ?*i32,
plMax: ?*i32,
plStepping: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceSpecificProperty_GetType(self: *const T, pVType: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceSpecificProperty.VTable, self.vtable).GetType(@ptrCast(*const IDeviceSpecificProperty, self), pVType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceSpecificProperty_GetValue(self: *const T, pvValue: ?*anyopaque, pcbValue: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceSpecificProperty.VTable, self.vtable).GetValue(@ptrCast(*const IDeviceSpecificProperty, self), pvValue, pcbValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceSpecificProperty_SetValue(self: *const T, pvValue: ?*anyopaque, cbValue: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceSpecificProperty.VTable, self.vtable).SetValue(@ptrCast(*const IDeviceSpecificProperty, self), pvValue, cbValue, pguidEventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceSpecificProperty_Get4BRange(self: *const T, plMin: ?*i32, plMax: ?*i32, plStepping: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceSpecificProperty.VTable, self.vtable).Get4BRange(@ptrCast(*const IDeviceSpecificProperty, self), plMin, plMax, plStepping);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IPartsList_Value = Guid.initString("6daa848c-5eb0-45cc-aea5-998a2cda1ffb");
pub const IID_IPartsList = &IID_IPartsList_Value;
pub const IPartsList = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCount: fn(
self: *const IPartsList,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPart: fn(
self: *const IPartsList,
nIndex: u32,
ppPart: ?*?*IPart,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPartsList_GetCount(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPartsList.VTable, self.vtable).GetCount(@ptrCast(*const IPartsList, self), pCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPartsList_GetPart(self: *const T, nIndex: u32, ppPart: ?*?*IPart) callconv(.Inline) HRESULT {
return @ptrCast(*const IPartsList.VTable, self.vtable).GetPart(@ptrCast(*const IPartsList, self), nIndex, ppPart);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IPart_Value = Guid.initString("ae2de0e4-5bca-4f2d-aa46-5d13f8fdb3a9");
pub const IID_IPart = &IID_IPart_Value;
pub const IPart = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetName: fn(
self: *const IPart,
ppwstrName: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLocalId: fn(
self: *const IPart,
pnId: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGlobalId: fn(
self: *const IPart,
ppwstrGlobalId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPartType: fn(
self: *const IPart,
pPartType: ?*PartType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSubType: fn(
self: *const IPart,
pSubType: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetControlInterfaceCount: fn(
self: *const IPart,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetControlInterface: fn(
self: *const IPart,
nIndex: u32,
ppInterfaceDesc: ?*?*IControlInterface,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumPartsIncoming: fn(
self: *const IPart,
ppParts: ?*?*IPartsList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumPartsOutgoing: fn(
self: *const IPart,
ppParts: ?*?*IPartsList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTopologyObject: fn(
self: *const IPart,
ppTopology: ?*?*IDeviceTopology,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Activate: fn(
self: *const IPart,
dwClsContext: u32,
refiid: ?*const Guid,
ppvObject: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterControlChangeCallback: fn(
self: *const IPart,
riid: ?*const Guid,
pNotify: ?*IControlChangeNotify,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterControlChangeCallback: fn(
self: *const IPart,
pNotify: ?*IControlChangeNotify,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetName(self: *const T, ppwstrName: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetName(@ptrCast(*const IPart, self), ppwstrName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetLocalId(self: *const T, pnId: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetLocalId(@ptrCast(*const IPart, self), pnId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetGlobalId(self: *const T, ppwstrGlobalId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetGlobalId(@ptrCast(*const IPart, self), ppwstrGlobalId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetPartType(self: *const T, pPartType: ?*PartType) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetPartType(@ptrCast(*const IPart, self), pPartType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetSubType(self: *const T, pSubType: ?*Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetSubType(@ptrCast(*const IPart, self), pSubType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetControlInterfaceCount(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetControlInterfaceCount(@ptrCast(*const IPart, self), pCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetControlInterface(self: *const T, nIndex: u32, ppInterfaceDesc: ?*?*IControlInterface) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetControlInterface(@ptrCast(*const IPart, self), nIndex, ppInterfaceDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_EnumPartsIncoming(self: *const T, ppParts: ?*?*IPartsList) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).EnumPartsIncoming(@ptrCast(*const IPart, self), ppParts);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_EnumPartsOutgoing(self: *const T, ppParts: ?*?*IPartsList) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).EnumPartsOutgoing(@ptrCast(*const IPart, self), ppParts);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_GetTopologyObject(self: *const T, ppTopology: ?*?*IDeviceTopology) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).GetTopologyObject(@ptrCast(*const IPart, self), ppTopology);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_Activate(self: *const T, dwClsContext: u32, refiid: ?*const Guid, ppvObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).Activate(@ptrCast(*const IPart, self), dwClsContext, refiid, ppvObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_RegisterControlChangeCallback(self: *const T, riid: ?*const Guid, pNotify: ?*IControlChangeNotify) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).RegisterControlChangeCallback(@ptrCast(*const IPart, self), riid, pNotify);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPart_UnregisterControlChangeCallback(self: *const T, pNotify: ?*IControlChangeNotify) callconv(.Inline) HRESULT {
return @ptrCast(*const IPart.VTable, self.vtable).UnregisterControlChangeCallback(@ptrCast(*const IPart, self), pNotify);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IConnector_Value = Guid.initString("9c2c4058-23f5-41de-877a-df3af236a09e");
pub const IID_IConnector = &IID_IConnector_Value;
pub const IConnector = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetType: fn(
self: *const IConnector,
pType: ?*ConnectorType,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDataFlow: fn(
self: *const IConnector,
pFlow: ?*DataFlow,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConnectTo: fn(
self: *const IConnector,
pConnectTo: ?*IConnector,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Disconnect: fn(
self: *const IConnector,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsConnected: fn(
self: *const IConnector,
pbConnected: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConnectedTo: fn(
self: *const IConnector,
ppConTo: ?*?*IConnector,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConnectorIdConnectedTo: fn(
self: *const IConnector,
ppwstrConnectorId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceIdConnectedTo: fn(
self: *const IConnector,
ppwstrDeviceId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_GetType(self: *const T, pType: ?*ConnectorType) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).GetType(@ptrCast(*const IConnector, self), pType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_GetDataFlow(self: *const T, pFlow: ?*DataFlow) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).GetDataFlow(@ptrCast(*const IConnector, self), pFlow);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_ConnectTo(self: *const T, pConnectTo: ?*IConnector) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).ConnectTo(@ptrCast(*const IConnector, self), pConnectTo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_Disconnect(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).Disconnect(@ptrCast(*const IConnector, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_IsConnected(self: *const T, pbConnected: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).IsConnected(@ptrCast(*const IConnector, self), pbConnected);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_GetConnectedTo(self: *const T, ppConTo: ?*?*IConnector) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).GetConnectedTo(@ptrCast(*const IConnector, self), ppConTo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_GetConnectorIdConnectedTo(self: *const T, ppwstrConnectorId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).GetConnectorIdConnectedTo(@ptrCast(*const IConnector, self), ppwstrConnectorId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IConnector_GetDeviceIdConnectedTo(self: *const T, ppwstrDeviceId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IConnector.VTable, self.vtable).GetDeviceIdConnectedTo(@ptrCast(*const IConnector, self), ppwstrDeviceId);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_ISubunit_Value = Guid.initString("82149a85-dba6-4487-86bb-ea8f7fefcc71");
pub const IID_ISubunit = &IID_ISubunit_Value;
pub const ISubunit = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IControlInterface_Value = Guid.initString("45d37c3f-5140-444a-ae24-400789f3cbf3");
pub const IID_IControlInterface = &IID_IControlInterface_Value;
pub const IControlInterface = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetName: fn(
self: *const IControlInterface,
ppwstrName: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIID: fn(
self: *const IControlInterface,
pIID: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IControlInterface_GetName(self: *const T, ppwstrName: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IControlInterface.VTable, self.vtable).GetName(@ptrCast(*const IControlInterface, self), ppwstrName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IControlInterface_GetIID(self: *const T, pIID: ?*Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IControlInterface.VTable, self.vtable).GetIID(@ptrCast(*const IControlInterface, self), pIID);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IControlChangeNotify_Value = Guid.initString("a09513ed-c709-4d21-bd7b-5f34c47f3947");
pub const IID_IControlChangeNotify = &IID_IControlChangeNotify_Value;
pub const IControlChangeNotify = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnNotify: fn(
self: *const IControlChangeNotify,
dwSenderProcessId: u32,
pguidEventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IControlChangeNotify_OnNotify(self: *const T, dwSenderProcessId: u32, pguidEventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IControlChangeNotify.VTable, self.vtable).OnNotify(@ptrCast(*const IControlChangeNotify, self), dwSenderProcessId, pguidEventContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IDeviceTopology_Value = Guid.initString("2a07407e-6497-4a18-9787-32f79bd0d98f");
pub const IID_IDeviceTopology = &IID_IDeviceTopology_Value;
pub const IDeviceTopology = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetConnectorCount: fn(
self: *const IDeviceTopology,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConnector: fn(
self: *const IDeviceTopology,
nIndex: u32,
ppConnector: ?*?*IConnector,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSubunitCount: fn(
self: *const IDeviceTopology,
pCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSubunit: fn(
self: *const IDeviceTopology,
nIndex: u32,
ppSubunit: ?*?*ISubunit,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPartById: fn(
self: *const IDeviceTopology,
nId: u32,
ppPart: ?*?*IPart,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceId: fn(
self: *const IDeviceTopology,
ppwstrDeviceId: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSignalPath: fn(
self: *const IDeviceTopology,
pIPartFrom: ?*IPart,
pIPartTo: ?*IPart,
bRejectMixedPaths: BOOL,
ppParts: ?*?*IPartsList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetConnectorCount(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetConnectorCount(@ptrCast(*const IDeviceTopology, self), pCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetConnector(self: *const T, nIndex: u32, ppConnector: ?*?*IConnector) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetConnector(@ptrCast(*const IDeviceTopology, self), nIndex, ppConnector);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetSubunitCount(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetSubunitCount(@ptrCast(*const IDeviceTopology, self), pCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetSubunit(self: *const T, nIndex: u32, ppSubunit: ?*?*ISubunit) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetSubunit(@ptrCast(*const IDeviceTopology, self), nIndex, ppSubunit);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetPartById(self: *const T, nId: u32, ppPart: ?*?*IPart) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetPartById(@ptrCast(*const IDeviceTopology, self), nId, ppPart);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetDeviceId(self: *const T, ppwstrDeviceId: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetDeviceId(@ptrCast(*const IDeviceTopology, self), ppwstrDeviceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IDeviceTopology_GetSignalPath(self: *const T, pIPartFrom: ?*IPart, pIPartTo: ?*IPart, bRejectMixedPaths: BOOL, ppParts: ?*?*IPartsList) callconv(.Inline) HRESULT {
return @ptrCast(*const IDeviceTopology.VTable, self.vtable).GetSignalPath(@ptrCast(*const IDeviceTopology, self), pIPartFrom, pIPartTo, bRejectMixedPaths, ppParts);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const AudioSessionDisconnectReason = enum(i32) {
DeviceRemoval = 0,
ServerShutdown = 1,
FormatChanged = 2,
SessionLogoff = 3,
SessionDisconnected = 4,
ExclusiveModeOverride = 5,
};
pub const DisconnectReasonDeviceRemoval = AudioSessionDisconnectReason.DeviceRemoval;
pub const DisconnectReasonServerShutdown = AudioSessionDisconnectReason.ServerShutdown;
pub const DisconnectReasonFormatChanged = AudioSessionDisconnectReason.FormatChanged;
pub const DisconnectReasonSessionLogoff = AudioSessionDisconnectReason.SessionLogoff;
pub const DisconnectReasonSessionDisconnected = AudioSessionDisconnectReason.SessionDisconnected;
pub const DisconnectReasonExclusiveModeOverride = AudioSessionDisconnectReason.ExclusiveModeOverride;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioSessionEvents_Value = Guid.initString("24918acc-64b3-37c1-8ca9-74a66e9957a8");
pub const IID_IAudioSessionEvents = &IID_IAudioSessionEvents_Value;
pub const IAudioSessionEvents = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnDisplayNameChanged: fn(
self: *const IAudioSessionEvents,
NewDisplayName: ?[*:0]const u16,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnIconPathChanged: fn(
self: *const IAudioSessionEvents,
NewIconPath: ?[*:0]const u16,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnSimpleVolumeChanged: fn(
self: *const IAudioSessionEvents,
NewVolume: f32,
NewMute: BOOL,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnChannelVolumeChanged: fn(
self: *const IAudioSessionEvents,
ChannelCount: u32,
NewChannelVolumeArray: [*]f32,
ChangedChannel: u32,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnGroupingParamChanged: fn(
self: *const IAudioSessionEvents,
NewGroupingParam: ?*const Guid,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnStateChanged: fn(
self: *const IAudioSessionEvents,
NewState: AudioSessionState,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnSessionDisconnected: fn(
self: *const IAudioSessionEvents,
DisconnectReason: AudioSessionDisconnectReason,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnDisplayNameChanged(self: *const T, NewDisplayName: ?[*:0]const u16, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnDisplayNameChanged(@ptrCast(*const IAudioSessionEvents, self), NewDisplayName, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnIconPathChanged(self: *const T, NewIconPath: ?[*:0]const u16, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnIconPathChanged(@ptrCast(*const IAudioSessionEvents, self), NewIconPath, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnSimpleVolumeChanged(self: *const T, NewVolume: f32, NewMute: BOOL, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnSimpleVolumeChanged(@ptrCast(*const IAudioSessionEvents, self), NewVolume, NewMute, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnChannelVolumeChanged(self: *const T, ChannelCount: u32, NewChannelVolumeArray: [*]f32, ChangedChannel: u32, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnChannelVolumeChanged(@ptrCast(*const IAudioSessionEvents, self), ChannelCount, NewChannelVolumeArray, ChangedChannel, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnGroupingParamChanged(self: *const T, NewGroupingParam: ?*const Guid, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnGroupingParamChanged(@ptrCast(*const IAudioSessionEvents, self), NewGroupingParam, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnStateChanged(self: *const T, NewState: AudioSessionState) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnStateChanged(@ptrCast(*const IAudioSessionEvents, self), NewState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEvents_OnSessionDisconnected(self: *const T, DisconnectReason: AudioSessionDisconnectReason) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEvents.VTable, self.vtable).OnSessionDisconnected(@ptrCast(*const IAudioSessionEvents, self), DisconnectReason);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioSessionControl_Value = Guid.initString("f4b1a599-7266-4319-a8ca-e70acb11e8cd");
pub const IID_IAudioSessionControl = &IID_IAudioSessionControl_Value;
pub const IAudioSessionControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetState: fn(
self: *const IAudioSessionControl,
pRetVal: ?*AudioSessionState,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDisplayName: fn(
self: *const IAudioSessionControl,
pRetVal: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDisplayName: fn(
self: *const IAudioSessionControl,
Value: ?[*:0]const u16,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIconPath: fn(
self: *const IAudioSessionControl,
pRetVal: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetIconPath: fn(
self: *const IAudioSessionControl,
Value: ?[*:0]const u16,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGroupingParam: fn(
self: *const IAudioSessionControl,
pRetVal: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetGroupingParam: fn(
self: *const IAudioSessionControl,
Override: ?*const Guid,
EventContext: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterAudioSessionNotification: fn(
self: *const IAudioSessionControl,
NewNotifications: ?*IAudioSessionEvents,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterAudioSessionNotification: fn(
self: *const IAudioSessionControl,
NewNotifications: ?*IAudioSessionEvents,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_GetState(self: *const T, pRetVal: ?*AudioSessionState) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).GetState(@ptrCast(*const IAudioSessionControl, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_GetDisplayName(self: *const T, pRetVal: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).GetDisplayName(@ptrCast(*const IAudioSessionControl, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_SetDisplayName(self: *const T, Value: ?[*:0]const u16, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).SetDisplayName(@ptrCast(*const IAudioSessionControl, self), Value, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_GetIconPath(self: *const T, pRetVal: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).GetIconPath(@ptrCast(*const IAudioSessionControl, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_SetIconPath(self: *const T, Value: ?[*:0]const u16, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).SetIconPath(@ptrCast(*const IAudioSessionControl, self), Value, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_GetGroupingParam(self: *const T, pRetVal: ?*Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).GetGroupingParam(@ptrCast(*const IAudioSessionControl, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_SetGroupingParam(self: *const T, Override: ?*const Guid, EventContext: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).SetGroupingParam(@ptrCast(*const IAudioSessionControl, self), Override, EventContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_RegisterAudioSessionNotification(self: *const T, NewNotifications: ?*IAudioSessionEvents) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).RegisterAudioSessionNotification(@ptrCast(*const IAudioSessionControl, self), NewNotifications);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl_UnregisterAudioSessionNotification(self: *const T, NewNotifications: ?*IAudioSessionEvents) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl.VTable, self.vtable).UnregisterAudioSessionNotification(@ptrCast(*const IAudioSessionControl, self), NewNotifications);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioSessionControl2_Value = Guid.initString("bfb7ff88-7239-4fc9-8fa2-07c950be9c6d");
pub const IID_IAudioSessionControl2 = &IID_IAudioSessionControl2_Value;
pub const IAudioSessionControl2 = extern struct {
pub const VTable = extern struct {
base: IAudioSessionControl.VTable,
GetSessionIdentifier: fn(
self: *const IAudioSessionControl2,
pRetVal: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSessionInstanceIdentifier: fn(
self: *const IAudioSessionControl2,
pRetVal: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetProcessId: fn(
self: *const IAudioSessionControl2,
pRetVal: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsSystemSoundsSession: fn(
self: *const IAudioSessionControl2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDuckingPreference: fn(
self: *const IAudioSessionControl2,
optOut: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IAudioSessionControl.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl2_GetSessionIdentifier(self: *const T, pRetVal: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl2.VTable, self.vtable).GetSessionIdentifier(@ptrCast(*const IAudioSessionControl2, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl2_GetSessionInstanceIdentifier(self: *const T, pRetVal: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl2.VTable, self.vtable).GetSessionInstanceIdentifier(@ptrCast(*const IAudioSessionControl2, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl2_GetProcessId(self: *const T, pRetVal: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl2.VTable, self.vtable).GetProcessId(@ptrCast(*const IAudioSessionControl2, self), pRetVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl2_IsSystemSoundsSession(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl2.VTable, self.vtable).IsSystemSoundsSession(@ptrCast(*const IAudioSessionControl2, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionControl2_SetDuckingPreference(self: *const T, optOut: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionControl2.VTable, self.vtable).SetDuckingPreference(@ptrCast(*const IAudioSessionControl2, self), optOut);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IAudioSessionManager_Value = Guid.initString("bfa971f1-4d5e-40bb-935e-967039bfbee4");
pub const IID_IAudioSessionManager = &IID_IAudioSessionManager_Value;
pub const IAudioSessionManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetAudioSessionControl: fn(
self: *const IAudioSessionManager,
AudioSessionGuid: ?*const Guid,
StreamFlags: u32,
SessionControl: ?*?*IAudioSessionControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSimpleAudioVolume: fn(
self: *const IAudioSessionManager,
AudioSessionGuid: ?*const Guid,
StreamFlags: u32,
AudioVolume: ?*?*ISimpleAudioVolume,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager_GetAudioSessionControl(self: *const T, AudioSessionGuid: ?*const Guid, StreamFlags: u32, SessionControl: ?*?*IAudioSessionControl) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager.VTable, self.vtable).GetAudioSessionControl(@ptrCast(*const IAudioSessionManager, self), AudioSessionGuid, StreamFlags, SessionControl);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager_GetSimpleAudioVolume(self: *const T, AudioSessionGuid: ?*const Guid, StreamFlags: u32, AudioVolume: ?*?*ISimpleAudioVolume) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager.VTable, self.vtable).GetSimpleAudioVolume(@ptrCast(*const IAudioSessionManager, self), AudioSessionGuid, StreamFlags, AudioVolume);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioVolumeDuckNotification_Value = Guid.initString("c3b284d4-6d39-4359-b3cf-b56ddb3bb39c");
pub const IID_IAudioVolumeDuckNotification = &IID_IAudioVolumeDuckNotification_Value;
pub const IAudioVolumeDuckNotification = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnVolumeDuckNotification: fn(
self: *const IAudioVolumeDuckNotification,
sessionID: ?[*:0]const u16,
countCommunicationSessions: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnVolumeUnduckNotification: fn(
self: *const IAudioVolumeDuckNotification,
sessionID: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioVolumeDuckNotification_OnVolumeDuckNotification(self: *const T, sessionID: ?[*:0]const u16, countCommunicationSessions: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioVolumeDuckNotification.VTable, self.vtable).OnVolumeDuckNotification(@ptrCast(*const IAudioVolumeDuckNotification, self), sessionID, countCommunicationSessions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioVolumeDuckNotification_OnVolumeUnduckNotification(self: *const T, sessionID: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioVolumeDuckNotification.VTable, self.vtable).OnVolumeUnduckNotification(@ptrCast(*const IAudioVolumeDuckNotification, self), sessionID);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioSessionNotification_Value = Guid.initString("641dd20b-4d41-49cc-aba3-174b9477bb08");
pub const IID_IAudioSessionNotification = &IID_IAudioSessionNotification_Value;
pub const IAudioSessionNotification = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OnSessionCreated: fn(
self: *const IAudioSessionNotification,
NewSession: ?*IAudioSessionControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionNotification_OnSessionCreated(self: *const T, NewSession: ?*IAudioSessionControl) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionNotification.VTable, self.vtable).OnSessionCreated(@ptrCast(*const IAudioSessionNotification, self), NewSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioSessionEnumerator_Value = Guid.initString("e2f5bb11-0570-40ca-acdd-3aa01277dee8");
pub const IID_IAudioSessionEnumerator = &IID_IAudioSessionEnumerator_Value;
pub const IAudioSessionEnumerator = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCount: fn(
self: *const IAudioSessionEnumerator,
SessionCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSession: fn(
self: *const IAudioSessionEnumerator,
SessionCount: i32,
Session: ?*?*IAudioSessionControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEnumerator_GetCount(self: *const T, SessionCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEnumerator.VTable, self.vtable).GetCount(@ptrCast(*const IAudioSessionEnumerator, self), SessionCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionEnumerator_GetSession(self: *const T, SessionCount: i32, Session: ?*?*IAudioSessionControl) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionEnumerator.VTable, self.vtable).GetSession(@ptrCast(*const IAudioSessionEnumerator, self), SessionCount, Session);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_IAudioSessionManager2_Value = Guid.initString("77aa99a0-1bd6-484f-8bc7-2c654c9a9b6f");
pub const IID_IAudioSessionManager2 = &IID_IAudioSessionManager2_Value;
pub const IAudioSessionManager2 = extern struct {
pub const VTable = extern struct {
base: IAudioSessionManager.VTable,
GetSessionEnumerator: fn(
self: *const IAudioSessionManager2,
SessionEnum: ?*?*IAudioSessionEnumerator,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterSessionNotification: fn(
self: *const IAudioSessionManager2,
SessionNotification: ?*IAudioSessionNotification,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterSessionNotification: fn(
self: *const IAudioSessionManager2,
SessionNotification: ?*IAudioSessionNotification,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterDuckNotification: fn(
self: *const IAudioSessionManager2,
sessionID: ?[*:0]const u16,
duckNotification: ?*IAudioVolumeDuckNotification,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterDuckNotification: fn(
self: *const IAudioSessionManager2,
duckNotification: ?*IAudioVolumeDuckNotification,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IAudioSessionManager.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager2_GetSessionEnumerator(self: *const T, SessionEnum: ?*?*IAudioSessionEnumerator) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager2.VTable, self.vtable).GetSessionEnumerator(@ptrCast(*const IAudioSessionManager2, self), SessionEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager2_RegisterSessionNotification(self: *const T, SessionNotification: ?*IAudioSessionNotification) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager2.VTable, self.vtable).RegisterSessionNotification(@ptrCast(*const IAudioSessionManager2, self), SessionNotification);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager2_UnregisterSessionNotification(self: *const T, SessionNotification: ?*IAudioSessionNotification) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager2.VTable, self.vtable).UnregisterSessionNotification(@ptrCast(*const IAudioSessionManager2, self), SessionNotification);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager2_RegisterDuckNotification(self: *const T, sessionID: ?[*:0]const u16, duckNotification: ?*IAudioVolumeDuckNotification) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager2.VTable, self.vtable).RegisterDuckNotification(@ptrCast(*const IAudioSessionManager2, self), sessionID, duckNotification);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioSessionManager2_UnregisterDuckNotification(self: *const T, duckNotification: ?*IAudioVolumeDuckNotification) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioSessionManager2.VTable, self.vtable).UnregisterDuckNotification(@ptrCast(*const IAudioSessionManager2, self), duckNotification);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const SpatialAudioMetadataWriterOverflowMode = enum(i32) {
Fail = 0,
MergeWithNew = 1,
MergeWithLast = 2,
};
pub const SpatialAudioMetadataWriterOverflow_Fail = SpatialAudioMetadataWriterOverflowMode.Fail;
pub const SpatialAudioMetadataWriterOverflow_MergeWithNew = SpatialAudioMetadataWriterOverflowMode.MergeWithNew;
pub const SpatialAudioMetadataWriterOverflow_MergeWithLast = SpatialAudioMetadataWriterOverflowMode.MergeWithLast;
pub const SpatialAudioMetadataCopyMode = enum(i32) {
Overwrite = 0,
Append = 1,
AppendMergeWithLast = 2,
AppendMergeWithFirst = 3,
};
pub const SpatialAudioMetadataCopy_Overwrite = SpatialAudioMetadataCopyMode.Overwrite;
pub const SpatialAudioMetadataCopy_Append = SpatialAudioMetadataCopyMode.Append;
pub const SpatialAudioMetadataCopy_AppendMergeWithLast = SpatialAudioMetadataCopyMode.AppendMergeWithLast;
pub const SpatialAudioMetadataCopy_AppendMergeWithFirst = SpatialAudioMetadataCopyMode.AppendMergeWithFirst;
pub const SpatialAudioMetadataItemsInfo = packed struct {
FrameCount: u16,
ItemCount: u16,
MaxItemCount: u16,
MaxValueBufferLength: u32,
};
pub const SpatialAudioObjectRenderStreamForMetadataActivationParams = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
MetadataFormatId: Guid,
MaxMetadataItemCount: u16,
MetadataActivationParams: ?*const PROPVARIANT,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
};
pub const SpatialAudioObjectRenderStreamForMetadataActivationParams2 = packed struct {
ObjectFormat: ?*const WAVEFORMATEX,
StaticObjectTypeMask: AudioObjectType,
MinDynamicObjectCount: u32,
MaxDynamicObjectCount: u32,
Category: AUDIO_STREAM_CATEGORY,
EventHandle: ?HANDLE,
MetadataFormatId: Guid,
MaxMetadataItemCount: u32,
MetadataActivationParams: ?*const PROPVARIANT,
NotifyObject: ?*ISpatialAudioObjectRenderStreamNotify,
Options: SPATIAL_AUDIO_STREAM_OPTIONS,
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataItems_Value = Guid.initString("bcd7c78f-3098-4f22-b547-a2f25a381269");
pub const IID_ISpatialAudioMetadataItems = &IID_ISpatialAudioMetadataItems_Value;
pub const ISpatialAudioMetadataItems = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetFrameCount: fn(
self: *const ISpatialAudioMetadataItems,
frameCount: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetItemCount: fn(
self: *const ISpatialAudioMetadataItems,
itemCount: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaxItemCount: fn(
self: *const ISpatialAudioMetadataItems,
maxItemCount: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaxValueBufferLength: fn(
self: *const ISpatialAudioMetadataItems,
maxValueBufferLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInfo: fn(
self: *const ISpatialAudioMetadataItems,
info: ?*SpatialAudioMetadataItemsInfo,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItems_GetFrameCount(self: *const T, frameCount: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItems.VTable, self.vtable).GetFrameCount(@ptrCast(*const ISpatialAudioMetadataItems, self), frameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItems_GetItemCount(self: *const T, itemCount: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItems.VTable, self.vtable).GetItemCount(@ptrCast(*const ISpatialAudioMetadataItems, self), itemCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItems_GetMaxItemCount(self: *const T, maxItemCount: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItems.VTable, self.vtable).GetMaxItemCount(@ptrCast(*const ISpatialAudioMetadataItems, self), maxItemCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItems_GetMaxValueBufferLength(self: *const T, maxValueBufferLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItems.VTable, self.vtable).GetMaxValueBufferLength(@ptrCast(*const ISpatialAudioMetadataItems, self), maxValueBufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItems_GetInfo(self: *const T, info: ?*SpatialAudioMetadataItemsInfo) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItems.VTable, self.vtable).GetInfo(@ptrCast(*const ISpatialAudioMetadataItems, self), info);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataWriter_Value = Guid.initString("1b17ca01-2955-444d-a430-537dc589a844");
pub const IID_ISpatialAudioMetadataWriter = &IID_ISpatialAudioMetadataWriter_Value;
pub const ISpatialAudioMetadataWriter = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const ISpatialAudioMetadataWriter,
metadataItems: ?*ISpatialAudioMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteNextItem: fn(
self: *const ISpatialAudioMetadataWriter,
frameOffset: u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteNextItemCommand: fn(
self: *const ISpatialAudioMetadataWriter,
commandID: u8,
// TODO: what to do with BytesParamIndex 2?
valueBuffer: ?*const anyopaque,
valueBufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const ISpatialAudioMetadataWriter,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataWriter_Open(self: *const T, metadataItems: ?*ISpatialAudioMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataWriter.VTable, self.vtable).Open(@ptrCast(*const ISpatialAudioMetadataWriter, self), metadataItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataWriter_WriteNextItem(self: *const T, frameOffset: u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataWriter.VTable, self.vtable).WriteNextItem(@ptrCast(*const ISpatialAudioMetadataWriter, self), frameOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataWriter_WriteNextItemCommand(self: *const T, commandID: u8, valueBuffer: ?*const anyopaque, valueBufferLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataWriter.VTable, self.vtable).WriteNextItemCommand(@ptrCast(*const ISpatialAudioMetadataWriter, self), commandID, valueBuffer, valueBufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataWriter_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataWriter.VTable, self.vtable).Close(@ptrCast(*const ISpatialAudioMetadataWriter, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataReader_Value = Guid.initString("b78e86a2-31d9-4c32-94d2-7df40fc7ebec");
pub const IID_ISpatialAudioMetadataReader = &IID_ISpatialAudioMetadataReader_Value;
pub const ISpatialAudioMetadataReader = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const ISpatialAudioMetadataReader,
metadataItems: ?*ISpatialAudioMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadNextItem: fn(
self: *const ISpatialAudioMetadataReader,
commandCount: ?*u8,
frameOffset: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadNextItemCommand: fn(
self: *const ISpatialAudioMetadataReader,
commandID: ?*u8,
// TODO: what to do with BytesParamIndex 2?
valueBuffer: ?*anyopaque,
maxValueBufferLength: u32,
valueBufferLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const ISpatialAudioMetadataReader,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataReader_Open(self: *const T, metadataItems: ?*ISpatialAudioMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataReader.VTable, self.vtable).Open(@ptrCast(*const ISpatialAudioMetadataReader, self), metadataItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataReader_ReadNextItem(self: *const T, commandCount: ?*u8, frameOffset: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataReader.VTable, self.vtable).ReadNextItem(@ptrCast(*const ISpatialAudioMetadataReader, self), commandCount, frameOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataReader_ReadNextItemCommand(self: *const T, commandID: ?*u8, valueBuffer: ?*anyopaque, maxValueBufferLength: u32, valueBufferLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataReader.VTable, self.vtable).ReadNextItemCommand(@ptrCast(*const ISpatialAudioMetadataReader, self), commandID, valueBuffer, maxValueBufferLength, valueBufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataReader_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataReader.VTable, self.vtable).Close(@ptrCast(*const ISpatialAudioMetadataReader, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataCopier_Value = Guid.initString("d224b233-e251-4fd0-9ca2-d5ecf9a68404");
pub const IID_ISpatialAudioMetadataCopier = &IID_ISpatialAudioMetadataCopier_Value;
pub const ISpatialAudioMetadataCopier = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const ISpatialAudioMetadataCopier,
metadataItems: ?*ISpatialAudioMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CopyMetadataForFrames: fn(
self: *const ISpatialAudioMetadataCopier,
copyFrameCount: u16,
copyMode: SpatialAudioMetadataCopyMode,
dstMetadataItems: ?*ISpatialAudioMetadataItems,
itemsCopied: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const ISpatialAudioMetadataCopier,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataCopier_Open(self: *const T, metadataItems: ?*ISpatialAudioMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataCopier.VTable, self.vtable).Open(@ptrCast(*const ISpatialAudioMetadataCopier, self), metadataItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataCopier_CopyMetadataForFrames(self: *const T, copyFrameCount: u16, copyMode: SpatialAudioMetadataCopyMode, dstMetadataItems: ?*ISpatialAudioMetadataItems, itemsCopied: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataCopier.VTable, self.vtable).CopyMetadataForFrames(@ptrCast(*const ISpatialAudioMetadataCopier, self), copyFrameCount, copyMode, dstMetadataItems, itemsCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataCopier_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataCopier.VTable, self.vtable).Close(@ptrCast(*const ISpatialAudioMetadataCopier, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataItemsBuffer_Value = Guid.initString("42640a16-e1bd-42d9-9ff6-031ab71a2dba");
pub const IID_ISpatialAudioMetadataItemsBuffer = &IID_ISpatialAudioMetadataItemsBuffer_Value;
pub const ISpatialAudioMetadataItemsBuffer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AttachToBuffer: fn(
self: *const ISpatialAudioMetadataItemsBuffer,
// TODO: what to do with BytesParamIndex 1?
buffer: ?*u8,
bufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AttachToPopulatedBuffer: fn(
self: *const ISpatialAudioMetadataItemsBuffer,
// TODO: what to do with BytesParamIndex 1?
buffer: ?*u8,
bufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DetachBuffer: fn(
self: *const ISpatialAudioMetadataItemsBuffer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItemsBuffer_AttachToBuffer(self: *const T, buffer: ?*u8, bufferLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItemsBuffer.VTable, self.vtable).AttachToBuffer(@ptrCast(*const ISpatialAudioMetadataItemsBuffer, self), buffer, bufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItemsBuffer_AttachToPopulatedBuffer(self: *const T, buffer: ?*u8, bufferLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItemsBuffer.VTable, self.vtable).AttachToPopulatedBuffer(@ptrCast(*const ISpatialAudioMetadataItemsBuffer, self), buffer, bufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataItemsBuffer_DetachBuffer(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataItemsBuffer.VTable, self.vtable).DetachBuffer(@ptrCast(*const ISpatialAudioMetadataItemsBuffer, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioMetadataClient_Value = Guid.initString("777d4a3b-f6ff-4a26-85dc-68d7cdeda1d4");
pub const IID_ISpatialAudioMetadataClient = &IID_ISpatialAudioMetadataClient_Value;
pub const ISpatialAudioMetadataClient = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ActivateSpatialAudioMetadataItems: fn(
self: *const ISpatialAudioMetadataClient,
maxItemCount: u16,
frameCount: u16,
metadataItemsBuffer: ?*?*ISpatialAudioMetadataItemsBuffer,
metadataItems: ?*?*ISpatialAudioMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpatialAudioMetadataItemsBufferLength: fn(
self: *const ISpatialAudioMetadataClient,
maxItemCount: u16,
bufferLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateSpatialAudioMetadataWriter: fn(
self: *const ISpatialAudioMetadataClient,
overflowMode: SpatialAudioMetadataWriterOverflowMode,
metadataWriter: ?*?*ISpatialAudioMetadataWriter,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateSpatialAudioMetadataCopier: fn(
self: *const ISpatialAudioMetadataClient,
metadataCopier: ?*?*ISpatialAudioMetadataCopier,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateSpatialAudioMetadataReader: fn(
self: *const ISpatialAudioMetadataClient,
metadataReader: ?*?*ISpatialAudioMetadataReader,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataClient_ActivateSpatialAudioMetadataItems(self: *const T, maxItemCount: u16, frameCount: u16, metadataItemsBuffer: ?*?*ISpatialAudioMetadataItemsBuffer, metadataItems: ?*?*ISpatialAudioMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataClient.VTable, self.vtable).ActivateSpatialAudioMetadataItems(@ptrCast(*const ISpatialAudioMetadataClient, self), maxItemCount, frameCount, metadataItemsBuffer, metadataItems);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataClient_GetSpatialAudioMetadataItemsBufferLength(self: *const T, maxItemCount: u16, bufferLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataClient.VTable, self.vtable).GetSpatialAudioMetadataItemsBufferLength(@ptrCast(*const ISpatialAudioMetadataClient, self), maxItemCount, bufferLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataClient_ActivateSpatialAudioMetadataWriter(self: *const T, overflowMode: SpatialAudioMetadataWriterOverflowMode, metadataWriter: ?*?*ISpatialAudioMetadataWriter) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataClient.VTable, self.vtable).ActivateSpatialAudioMetadataWriter(@ptrCast(*const ISpatialAudioMetadataClient, self), overflowMode, metadataWriter);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataClient_ActivateSpatialAudioMetadataCopier(self: *const T, metadataCopier: ?*?*ISpatialAudioMetadataCopier) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataClient.VTable, self.vtable).ActivateSpatialAudioMetadataCopier(@ptrCast(*const ISpatialAudioMetadataClient, self), metadataCopier);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioMetadataClient_ActivateSpatialAudioMetadataReader(self: *const T, metadataReader: ?*?*ISpatialAudioMetadataReader) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioMetadataClient.VTable, self.vtable).ActivateSpatialAudioMetadataReader(@ptrCast(*const ISpatialAudioMetadataClient, self), metadataReader);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectForMetadataCommands_Value = Guid.initString("0df2c94b-f5f9-472d-af6b-c46e0ac9cd05");
pub const IID_ISpatialAudioObjectForMetadataCommands = &IID_ISpatialAudioObjectForMetadataCommands_Value;
pub const ISpatialAudioObjectForMetadataCommands = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectBase.VTable,
WriteNextMetadataCommand: fn(
self: *const ISpatialAudioObjectForMetadataCommands,
commandID: u8,
// TODO: what to do with BytesParamIndex 2?
valueBuffer: ?*anyopaque,
valueBufferLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForMetadataCommands_WriteNextMetadataCommand(self: *const T, commandID: u8, valueBuffer: ?*anyopaque, valueBufferLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForMetadataCommands.VTable, self.vtable).WriteNextMetadataCommand(@ptrCast(*const ISpatialAudioObjectForMetadataCommands, self), commandID, valueBuffer, valueBufferLength);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectForMetadataItems_Value = Guid.initString("ddea49ff-3bc0-4377-8aad-9fbcfd808566");
pub const IID_ISpatialAudioObjectForMetadataItems = &IID_ISpatialAudioObjectForMetadataItems_Value;
pub const ISpatialAudioObjectForMetadataItems = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectBase.VTable,
GetSpatialAudioMetadataItems: fn(
self: *const ISpatialAudioObjectForMetadataItems,
metadataItems: ?*?*ISpatialAudioMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectForMetadataItems_GetSpatialAudioMetadataItems(self: *const T, metadataItems: ?*?*ISpatialAudioMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectForMetadataItems.VTable, self.vtable).GetSpatialAudioMetadataItems(@ptrCast(*const ISpatialAudioObjectForMetadataItems, self), metadataItems);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.15063'
const IID_ISpatialAudioObjectRenderStreamForMetadata_Value = Guid.initString("bbc9c907-48d5-4a2e-a0c7-f7f0d67c1fb1");
pub const IID_ISpatialAudioObjectRenderStreamForMetadata = &IID_ISpatialAudioObjectRenderStreamForMetadata_Value;
pub const ISpatialAudioObjectRenderStreamForMetadata = extern struct {
pub const VTable = extern struct {
base: ISpatialAudioObjectRenderStreamBase.VTable,
ActivateSpatialAudioObjectForMetadataCommands: fn(
self: *const ISpatialAudioObjectRenderStreamForMetadata,
type: AudioObjectType,
audioObject: ?*?*ISpatialAudioObjectForMetadataCommands,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ActivateSpatialAudioObjectForMetadataItems: fn(
self: *const ISpatialAudioObjectRenderStreamForMetadata,
type: AudioObjectType,
audioObject: ?*?*ISpatialAudioObjectForMetadataItems,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISpatialAudioObjectRenderStreamBase.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamForMetadata_ActivateSpatialAudioObjectForMetadataCommands(self: *const T, type_: AudioObjectType, audioObject: ?*?*ISpatialAudioObjectForMetadataCommands) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamForMetadata.VTable, self.vtable).ActivateSpatialAudioObjectForMetadataCommands(@ptrCast(*const ISpatialAudioObjectRenderStreamForMetadata, self), type_, audioObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISpatialAudioObjectRenderStreamForMetadata_ActivateSpatialAudioObjectForMetadataItems(self: *const T, type_: AudioObjectType, audioObject: ?*?*ISpatialAudioObjectForMetadataItems) callconv(.Inline) HRESULT {
return @ptrCast(*const ISpatialAudioObjectRenderStreamForMetadata.VTable, self.vtable).ActivateSpatialAudioObjectForMetadataItems(@ptrCast(*const ISpatialAudioObjectRenderStreamForMetadata, self), type_, audioObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const PROCESS_LOOPBACK_MODE = enum(i32) {
INCLUDE_TARGET_PROCESS_TREE = 0,
EXCLUDE_TARGET_PROCESS_TREE = 1,
};
pub const PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE = PROCESS_LOOPBACK_MODE.INCLUDE_TARGET_PROCESS_TREE;
pub const PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE = PROCESS_LOOPBACK_MODE.EXCLUDE_TARGET_PROCESS_TREE;
pub const AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS = extern struct {
TargetProcessId: u32,
ProcessLoopbackMode: PROCESS_LOOPBACK_MODE,
};
pub const AUDIOCLIENT_ACTIVATION_TYPE = enum(i32) {
DEFAULT = 0,
PROCESS_LOOPBACK = 1,
};
pub const AUDIOCLIENT_ACTIVATION_TYPE_DEFAULT = AUDIOCLIENT_ACTIVATION_TYPE.DEFAULT;
pub const AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK = AUDIOCLIENT_ACTIVATION_TYPE.PROCESS_LOOPBACK;
pub const AUDIOCLIENT_ACTIVATION_PARAMS = extern struct {
ActivationType: AUDIOCLIENT_ACTIVATION_TYPE,
Anonymous: extern union {
ProcessLoopbackParams: AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS,
},
};
pub const PAudioStateMonitorCallback = fn(
audioStateMonitor: ?*IAudioStateMonitor,
context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
pub const AudioStateMonitorSoundLevel = enum(i32) {
Muted = 0,
Low = 1,
Full = 2,
};
pub const Muted = AudioStateMonitorSoundLevel.Muted;
pub const Low = AudioStateMonitorSoundLevel.Low;
pub const Full = AudioStateMonitorSoundLevel.Full;
const IID_IAudioStateMonitor_Value = Guid.initString("63bd8738-e30d-4c77-bf5c-834e87c657e2");
pub const IID_IAudioStateMonitor = &IID_IAudioStateMonitor_Value;
pub const IAudioStateMonitor = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
RegisterCallback: fn(
self: *const IAudioStateMonitor,
callback: ?PAudioStateMonitorCallback,
context: ?*anyopaque,
registration: ?*i64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterCallback: fn(
self: *const IAudioStateMonitor,
registration: i64,
) callconv(@import("std").os.windows.WINAPI) void,
GetSoundLevel: fn(
self: *const IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) AudioStateMonitorSoundLevel,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStateMonitor_RegisterCallback(self: *const T, callback: ?PAudioStateMonitorCallback, context: ?*anyopaque, registration: ?*i64) callconv(.Inline) HRESULT {
return @ptrCast(*const IAudioStateMonitor.VTable, self.vtable).RegisterCallback(@ptrCast(*const IAudioStateMonitor, self), callback, context, registration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStateMonitor_UnregisterCallback(self: *const T, registration: i64) callconv(.Inline) void {
return @ptrCast(*const IAudioStateMonitor.VTable, self.vtable).UnregisterCallback(@ptrCast(*const IAudioStateMonitor, self), registration);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IAudioStateMonitor_GetSoundLevel(self: *const T) callconv(.Inline) AudioStateMonitorSoundLevel {
return @ptrCast(*const IAudioStateMonitor.VTable, self.vtable).GetSoundLevel(@ptrCast(*const IAudioStateMonitor, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const ACMDRIVERENUMCB = fn(
hadid: ?HACMDRIVERID,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const LPACMDRIVERPROC = fn(
param0: usize,
param1: ?HACMDRIVERID,
param2: u32,
param3: LPARAM,
param4: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub const ACMDRIVERDETAILSA = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
wMid: u16,
wPid: u16,
vdwACM: u32,
vdwDriver: u32,
fdwSupport: u32,
cFormatTags: u32,
cFilterTags: u32,
hicon: ?HICON,
szShortName: [32]CHAR,
szLongName: [128]CHAR,
szCopyright: [80]CHAR,
szLicensing: [128]CHAR,
szFeatures: [512]CHAR,
};
pub const ACMDRIVERDETAILSW = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
wMid: u16,
wPid: u16,
vdwACM: u32,
vdwDriver: u32,
fdwSupport: u32,
cFormatTags: u32,
cFilterTags: u32,
hicon: ?HICON,
szShortName: [32]u16,
szLongName: [128]u16,
szCopyright: [80]u16,
szLicensing: [128]u16,
szFeatures: [512]u16,
};
pub const ACMFORMATTAGDETAILSA = packed struct {
cbStruct: u32,
dwFormatTagIndex: u32,
dwFormatTag: u32,
cbFormatSize: u32,
fdwSupport: u32,
cStandardFormats: u32,
szFormatTag: [48]CHAR,
};
pub const ACMFORMATTAGDETAILSW = packed struct {
cbStruct: u32,
dwFormatTagIndex: u32,
dwFormatTag: u32,
cbFormatSize: u32,
fdwSupport: u32,
cStandardFormats: u32,
szFormatTag: [48]u16,
};
pub const ACMFORMATTAGENUMCBA = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFORMATTAGDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATTAGENUMCBW = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFORMATTAGDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATDETAILSA = packed struct {
cbStruct: u32,
dwFormatIndex: u32,
dwFormatTag: u32,
fdwSupport: u32,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
szFormat: [128]CHAR,
};
pub const tACMFORMATDETAILSW = packed struct {
cbStruct: u32,
dwFormatIndex: u32,
dwFormatTag: u32,
fdwSupport: u32,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
szFormat: [128]u16,
};
pub const ACMFORMATENUMCBA = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFORMATDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATENUMCBW = fn(
hadid: ?HACMDRIVERID,
pafd: ?*tACMFORMATDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFORMATCHOOSEHOOKPROCA = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFORMATCHOOSEHOOKPROCW = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFORMATCHOOSEA = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
pszTitle: ?[*:0]const u8,
szFormatTag: [48]CHAR,
szFormat: [128]CHAR,
pszName: ?PSTR,
cchName: u32,
fdwEnum: u32,
pwfxEnum: ?*WAVEFORMATEX,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u8,
lCustData: LPARAM,
pfnHook: ?ACMFORMATCHOOSEHOOKPROCA,
};
pub const ACMFORMATCHOOSEW = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfx: ?*WAVEFORMATEX,
cbwfx: u32,
pszTitle: ?[*:0]const u16,
szFormatTag: [48]u16,
szFormat: [128]u16,
pszName: ?PWSTR,
cchName: u32,
fdwEnum: u32,
pwfxEnum: ?*WAVEFORMATEX,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u16,
lCustData: LPARAM,
pfnHook: ?ACMFORMATCHOOSEHOOKPROCW,
};
pub const ACMFILTERTAGDETAILSA = packed struct {
cbStruct: u32,
dwFilterTagIndex: u32,
dwFilterTag: u32,
cbFilterSize: u32,
fdwSupport: u32,
cStandardFilters: u32,
szFilterTag: [48]CHAR,
};
pub const ACMFILTERTAGDETAILSW = packed struct {
cbStruct: u32,
dwFilterTagIndex: u32,
dwFilterTag: u32,
cbFilterSize: u32,
fdwSupport: u32,
cStandardFilters: u32,
szFilterTag: [48]u16,
};
pub const ACMFILTERTAGENUMCBA = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFILTERTAGDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERTAGENUMCBW = fn(
hadid: ?HACMDRIVERID,
paftd: ?*ACMFILTERTAGDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERDETAILSA = packed struct {
cbStruct: u32,
dwFilterIndex: u32,
dwFilterTag: u32,
fdwSupport: u32,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
szFilter: [128]CHAR,
};
pub const ACMFILTERDETAILSW = packed struct {
cbStruct: u32,
dwFilterIndex: u32,
dwFilterTag: u32,
fdwSupport: u32,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
szFilter: [128]u16,
};
pub const ACMFILTERENUMCBA = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFILTERDETAILSA,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERENUMCBW = fn(
hadid: ?HACMDRIVERID,
pafd: ?*ACMFILTERDETAILSW,
dwInstance: usize,
fdwSupport: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const ACMFILTERCHOOSEHOOKPROCA = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFILTERCHOOSEHOOKPROCW = fn(
hwnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const ACMFILTERCHOOSEA = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
pszTitle: ?[*:0]const u8,
szFilterTag: [48]CHAR,
szFilter: [128]CHAR,
pszName: ?PSTR,
cchName: u32,
fdwEnum: u32,
pwfltrEnum: ?*WAVEFILTER,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u8,
lCustData: LPARAM,
pfnHook: ?ACMFILTERCHOOSEHOOKPROCA,
};
pub const ACMFILTERCHOOSEW = packed struct {
cbStruct: u32,
fdwStyle: u32,
hwndOwner: ?HWND,
pwfltr: ?*WAVEFILTER,
cbwfltr: u32,
pszTitle: ?[*:0]const u16,
szFilterTag: [48]u16,
szFilter: [128]u16,
pszName: ?PWSTR,
cchName: u32,
fdwEnum: u32,
pwfltrEnum: ?*WAVEFILTER,
hInstance: ?HINSTANCE,
pszTemplateName: ?[*:0]const u16,
lCustData: LPARAM,
pfnHook: ?ACMFILTERCHOOSEHOOKPROCW,
};
pub const tACMDRVOPENDESCA = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
dwVersion: u32,
dwFlags: u32,
dwError: u32,
pszSectionName: ?[*:0]const u8,
pszAliasName: ?[*:0]const u8,
dnDevNode: u32,
};
pub const tACMDRVOPENDESCW = packed struct {
cbStruct: u32,
fccType: u32,
fccComp: u32,
dwVersion: u32,
dwFlags: u32,
dwError: u32,
pszSectionName: ?[*:0]const u16,
pszAliasName: ?[*:0]const u16,
dnDevNode: u32,
};
pub const ACMDRVSTREAMINSTANCE = packed struct {
cbStruct: u32,
pwfxSrc: ?*WAVEFORMATEX,
pwfxDst: ?*WAVEFORMATEX,
pwfltr: ?*WAVEFILTER,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
fdwDriver: u32,
dwDriver: usize,
has: ?HACMSTREAM,
};
pub const ACMDRVSTREAMHEADER = packed struct {
cbStruct: u32,
fdwStatus: u32,
dwUser: usize,
pbSrc: ?*u8,
cbSrcLength: u32,
cbSrcLengthUsed: u32,
dwSrcUser: usize,
pbDst: ?*u8,
cbDstLength: u32,
cbDstLengthUsed: u32,
dwDstUser: usize,
fdwConvert: u32,
padshNext: ?*ACMDRVSTREAMHEADER,
fdwDriver: u32,
dwDriver: usize,
fdwPrepared: u32,
dwPrepared: usize,
pbPreparedSrc: ?*u8,
cbPreparedSrcLength: u32,
pbPreparedDst: ?*u8,
cbPreparedDstLength: u32,
};
pub const ACMDRVSTREAMSIZE = packed struct {
cbStruct: u32,
fdwSize: u32,
cbSrcLength: u32,
cbDstLength: u32,
};
pub const ACMDRVFORMATSUGGEST = packed struct {
cbStruct: u32,
fdwSuggest: u32,
pwfxSrc: ?*WAVEFORMATEX,
cbwfxSrc: u32,
pwfxDst: ?*WAVEFORMATEX,
cbwfxDst: u32,
};
pub const ACMSTREAMHEADER = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => packed struct {
cbStruct: u32,
fdwStatus: u32,
dwUser: usize,
pbSrc: ?*u8,
cbSrcLength: u32,
cbSrcLengthUsed: u32,
dwSrcUser: usize,
pbDst: ?*u8,
cbDstLength: u32,
cbDstLengthUsed: u32,
dwDstUser: usize,
dwReservedDriver: [15]u32,
},
.X86 => packed struct {
cbStruct: u32,
fdwStatus: u32,
dwUser: usize,
pbSrc: ?*u8,
cbSrcLength: u32,
cbSrcLengthUsed: u32,
dwSrcUser: usize,
pbDst: ?*u8,
cbDstLength: u32,
cbDstLengthUsed: u32,
dwDstUser: usize,
dwReservedDriver: [10]u32,
},
};
//--------------------------------------------------------------------------------
// Section: Functions (158)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.0'
pub extern "OLE32" fn CoRegisterMessageFilter(
lpMessageFilter: ?*IMessageFilter,
lplpMessageFilter: ?*?*IMessageFilter,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "WINMM" fn sndPlaySoundA(
pszSound: ?[*:0]const u8,
fuSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn sndPlaySoundW(
pszSound: ?[*:0]const u16,
fuSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn PlaySoundA(
pszSound: ?[*:0]const u8,
hmod: ?HINSTANCE,
fdwSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINMM" fn PlaySoundW(
pszSound: ?[*:0]const u16,
hmod: ?HINSTANCE,
fdwSound: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetDevCapsA(
uDeviceID: usize,
pwoc: ?*WAVEOUTCAPSA,
cbwoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetDevCapsW(
uDeviceID: usize,
pwoc: ?*WAVEOUTCAPSW,
cbwoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetVolume(
hwo: ?HWAVEOUT,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetVolume(
hwo: ?HWAVEOUT,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveOutGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutOpen(
phwo: ?*?HWAVEOUT,
uDeviceID: u32,
pwfx: ?*WAVEFORMATEX,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutClose(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutPrepareHeader(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutUnprepareHeader(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutWrite(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutPause(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutRestart(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutReset(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutBreakLoop(
hwo: ?HWAVEOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPosition(
hwo: ?HWAVEOUT,
// TODO: what to do with BytesParamIndex 2?
pmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPitch(
hwo: ?HWAVEOUT,
pdwPitch: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetPitch(
hwo: ?HWAVEOUT,
dwPitch: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetPlaybackRate(
hwo: ?HWAVEOUT,
pdwRate: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutSetPlaybackRate(
hwo: ?HWAVEOUT,
dwRate: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutGetID(
hwo: ?HWAVEOUT,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveOutMessage(
hwo: ?HWAVEOUT,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pwic: ?*WAVEINCAPSA,
cbwic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pwic: ?*WAVEINCAPSW,
cbwic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "WINMM" fn waveInGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInOpen(
phwi: ?*?HWAVEIN,
uDeviceID: u32,
pwfx: ?*WAVEFORMATEX,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInClose(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInPrepareHeader(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInUnprepareHeader(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInAddBuffer(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pwh: ?*WAVEHDR,
cbwh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInStart(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInStop(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInReset(
hwi: ?HWAVEIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetPosition(
hwi: ?HWAVEIN,
// TODO: what to do with BytesParamIndex 2?
pmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInGetID(
hwi: ?HWAVEIN,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn waveInMessage(
hwi: ?HWAVEIN,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamOpen(
phms: ?*?HMIDISTRM,
puDeviceID: [*]u32,
cMidi: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamClose(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamProperty(
hms: ?HMIDISTRM,
lppropdata: ?*u8,
dwProperty: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamPosition(
hms: ?HMIDISTRM,
// TODO: what to do with BytesParamIndex 2?
lpmmt: ?*MMTIME,
cbmmt: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamOut(
hms: ?HMIDISTRM,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamPause(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamRestart(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiStreamStop(
hms: ?HMIDISTRM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiConnect(
hmi: ?HMIDI,
hmo: ?HMIDIOUT,
pReserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiDisconnect(
hmi: ?HMIDI,
hmo: ?HMIDIOUT,
pReserved: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmoc: ?*MIDIOUTCAPSA,
cbmoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmoc: ?*MIDIOUTCAPSW,
cbmoc: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetVolume(
hmo: ?HMIDIOUT,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutSetVolume(
hmo: ?HMIDIOUT,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutOpen(
phmo: ?*?HMIDIOUT,
uDeviceID: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutClose(
hmo: ?HMIDIOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutPrepareHeader(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutUnprepareHeader(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutShortMsg(
hmo: ?HMIDIOUT,
dwMsg: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutLongMsg(
hmo: ?HMIDIOUT,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutReset(
hmo: ?HMIDIOUT,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutCachePatches(
hmo: ?HMIDIOUT,
uBank: u32,
pwpa: *[128]u16,
fuCache: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutCacheDrumPatches(
hmo: ?HMIDIOUT,
uPatch: u32,
pwkya: *[128]u16,
fuCache: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutGetID(
hmo: ?HMIDIOUT,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiOutMessage(
hmo: ?HMIDIOUT,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmic: ?*MIDIINCAPSA,
cbmic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pmic: ?*MIDIINCAPSW,
cbmic: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetErrorTextA(
mmrError: u32,
pszText: [*:0]u8,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetErrorTextW(
mmrError: u32,
pszText: [*:0]u16,
cchText: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInOpen(
phmi: ?*?HMIDIIN,
uDeviceID: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: MIDI_WAVE_OPEN_TYPE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInClose(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInPrepareHeader(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInUnprepareHeader(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInAddBuffer(
hmi: ?HMIDIIN,
// TODO: what to do with BytesParamIndex 2?
pmh: ?*MIDIHDR,
cbmh: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInStart(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInStop(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInReset(
hmi: ?HMIDIIN,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInGetID(
hmi: ?HMIDIIN,
puDeviceID: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn midiInMessage(
hmi: ?HMIDIIN,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetDevCapsA(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pac: ?*AUXCAPSA,
cbac: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetDevCapsW(
uDeviceID: usize,
// TODO: what to do with BytesParamIndex 2?
pac: ?*AUXCAPSW,
cbac: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxSetVolume(
uDeviceID: u32,
dwVolume: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxGetVolume(
uDeviceID: u32,
pdwVolume: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn auxOutMessage(
uDeviceID: u32,
uMsg: u32,
dw1: usize,
dw2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetNumDevs(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetDevCapsA(
uMxId: usize,
// TODO: what to do with BytesParamIndex 2?
pmxcaps: ?*MIXERCAPSA,
cbmxcaps: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetDevCapsW(
uMxId: usize,
// TODO: what to do with BytesParamIndex 2?
pmxcaps: ?*MIXERCAPSW,
cbmxcaps: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerOpen(
phmx: ?*isize,
uMxId: u32,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerClose(
hmx: ?HMIXER,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerMessage(
hmx: ?HMIXER,
uMsg: u32,
dwParam1: usize,
dwParam2: usize,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineInfoA(
hmxobj: ?HMIXEROBJ,
pmxl: ?*MIXERLINEA,
fdwInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineInfoW(
hmxobj: ?HMIXEROBJ,
pmxl: ?*MIXERLINEW,
fdwInfo: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetID(
hmxobj: ?HMIXEROBJ,
puMxId: ?*u32,
fdwId: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineControlsA(
hmxobj: ?HMIXEROBJ,
pmxlc: ?*MIXERLINECONTROLSA,
fdwControls: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetLineControlsW(
hmxobj: ?HMIXEROBJ,
pmxlc: ?*MIXERLINECONTROLSW,
fdwControls: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetControlDetailsA(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerGetControlDetailsW(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "WINMM" fn mixerSetControlDetails(
hmxobj: ?HMIXEROBJ,
pmxcd: ?*MIXERCONTROLDETAILS,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "MMDevAPI" fn ActivateAudioInterfaceAsync(
deviceInterfacePath: ?[*:0]const u16,
riid: ?*const Guid,
activationParams: ?*PROPVARIANT,
completionHandler: ?*IActivateAudioInterfaceCompletionHandler,
activationOperation: ?*?*IActivateAudioInterfaceAsyncOperation,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateRenderAudioStateMonitor(
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateRenderAudioStateMonitorForCategory(
category: AUDIO_STREAM_CATEGORY,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateRenderAudioStateMonitorForCategoryAndDeviceRole(
category: AUDIO_STREAM_CATEGORY,
role: ERole,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateRenderAudioStateMonitorForCategoryAndDeviceId(
category: AUDIO_STREAM_CATEGORY,
deviceId: ?[*:0]const u16,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateCaptureAudioStateMonitor(
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateCaptureAudioStateMonitorForCategory(
category: AUDIO_STREAM_CATEGORY,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateCaptureAudioStateMonitorForCategoryAndDeviceRole(
category: AUDIO_STREAM_CATEGORY,
role: ERole,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "Windows.Media.MediaControl" fn CreateCaptureAudioStateMonitorForCategoryAndDeviceId(
category: AUDIO_STREAM_CATEGORY,
deviceId: ?[*:0]const u16,
audioStateMonitor: ?*?*IAudioStateMonitor,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmGetVersion(
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmMetrics(
hao: ?HACMOBJ,
uMetric: u32,
pMetric: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverEnum(
fnCallback: ?ACMDRIVERENUMCB,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverID(
hao: ?HACMOBJ,
phadid: ?*isize,
fdwDriverID: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverAddA(
phadid: ?*isize,
hinstModule: ?HINSTANCE,
lParam: LPARAM,
dwPriority: u32,
fdwAdd: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverAddW(
phadid: ?*isize,
hinstModule: ?HINSTANCE,
lParam: LPARAM,
dwPriority: u32,
fdwAdd: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverRemove(
hadid: ?HACMDRIVERID,
fdwRemove: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverOpen(
phad: ?*isize,
hadid: ?HACMDRIVERID,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverClose(
had: ?HACMDRIVER,
fdwClose: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverMessage(
had: ?HACMDRIVER,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverPriority(
hadid: ?HACMDRIVERID,
dwPriority: u32,
fdwPriority: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverDetailsA(
hadid: ?HACMDRIVERID,
padd: ?*ACMDRIVERDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmDriverDetailsW(
hadid: ?HACMDRIVERID,
padd: ?*ACMDRIVERDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagDetailsA(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagDetailsW(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagEnumA(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSA,
fnCallback: ?ACMFORMATTAGENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatTagEnumW(
had: ?HACMDRIVER,
paftd: ?*ACMFORMATTAGDETAILSW,
fnCallback: ?ACMFORMATTAGENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatDetailsA(
had: ?HACMDRIVER,
pafd: ?*ACMFORMATDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatDetailsW(
had: ?HACMDRIVER,
pafd: ?*tACMFORMATDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatEnumA(
had: ?HACMDRIVER,
pafd: ?*ACMFORMATDETAILSA,
fnCallback: ?ACMFORMATENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatEnumW(
had: ?HACMDRIVER,
pafd: ?*tACMFORMATDETAILSW,
fnCallback: ?ACMFORMATENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatSuggest(
had: ?HACMDRIVER,
pwfxSrc: ?*WAVEFORMATEX,
pwfxDst: ?*WAVEFORMATEX,
cbwfxDst: u32,
fdwSuggest: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatChooseA(
pafmtc: ?*ACMFORMATCHOOSEA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFormatChooseW(
pafmtc: ?*ACMFORMATCHOOSEW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagDetailsA(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagDetailsW(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagEnumA(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSA,
fnCallback: ?ACMFILTERTAGENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterTagEnumW(
had: ?HACMDRIVER,
paftd: ?*ACMFILTERTAGDETAILSW,
fnCallback: ?ACMFILTERTAGENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterDetailsA(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSA,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterDetailsW(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSW,
fdwDetails: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterEnumA(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSA,
fnCallback: ?ACMFILTERENUMCBA,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterEnumW(
had: ?HACMDRIVER,
pafd: ?*ACMFILTERDETAILSW,
fnCallback: ?ACMFILTERENUMCBW,
dwInstance: usize,
fdwEnum: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterChooseA(
pafltrc: ?*ACMFILTERCHOOSEA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmFilterChooseW(
pafltrc: ?*ACMFILTERCHOOSEW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamOpen(
phas: ?*isize,
had: ?HACMDRIVER,
pwfxSrc: ?*WAVEFORMATEX,
pwfxDst: ?*WAVEFORMATEX,
pwfltr: ?*WAVEFILTER,
dwCallback: usize,
dwInstance: usize,
fdwOpen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamClose(
has: ?HACMSTREAM,
fdwClose: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamSize(
has: ?HACMSTREAM,
cbInput: u32,
pdwOutputBytes: ?*u32,
fdwSize: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamReset(
has: ?HACMSTREAM,
fdwReset: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamMessage(
has: ?HACMSTREAM,
uMsg: u32,
lParam1: LPARAM,
lParam2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamConvert(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwConvert: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamPrepareHeader(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwPrepare: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "MSACM32" fn acmStreamUnprepareHeader(
has: ?HACMSTREAM,
pash: ?*ACMSTREAMHEADER,
fdwUnprepare: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (56)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
pub const WAVEOUTCAPS = thismodule.WAVEOUTCAPSA;
pub const WAVEOUTCAPS2 = thismodule.WAVEOUTCAPS2A;
pub const WAVEINCAPS = thismodule.WAVEINCAPSA;
pub const WAVEINCAPS2 = thismodule.WAVEINCAPS2A;
pub const MIDIOUTCAPS = thismodule.MIDIOUTCAPSA;
pub const MIDIOUTCAPS2 = thismodule.MIDIOUTCAPS2A;
pub const MIDIINCAPS = thismodule.MIDIINCAPSA;
pub const MIDIINCAPS2 = thismodule.MIDIINCAPS2A;
pub const AUXCAPS = thismodule.AUXCAPSA;
pub const AUXCAPS2 = thismodule.AUXCAPS2A;
pub const MIXERCAPS = thismodule.MIXERCAPSA;
pub const MIXERCAPS2 = thismodule.MIXERCAPS2A;
pub const MIXERLINE = thismodule.MIXERLINEA;
pub const MIXERCONTROL = thismodule.MIXERCONTROLA;
pub const MIXERLINECONTROLS = thismodule.MIXERLINECONTROLSA;
pub const MIXERCONTROLDETAILS_LISTTEXT = thismodule.MIXERCONTROLDETAILS_LISTTEXTA;
pub const ACMDRIVERDETAILS = thismodule.ACMDRIVERDETAILSA;
pub const ACMFORMATTAGDETAILS = thismodule.ACMFORMATTAGDETAILSA;
pub const ACMFORMATTAGENUMCB = thismodule.ACMFORMATTAGENUMCBA;
pub const ACMFORMATENUMCB = thismodule.ACMFORMATENUMCBA;
pub const ACMFORMATCHOOSEHOOKPROC = thismodule.ACMFORMATCHOOSEHOOKPROCA;
pub const ACMFORMATCHOOSE = thismodule.ACMFORMATCHOOSEA;
pub const ACMFILTERTAGDETAILS = thismodule.ACMFILTERTAGDETAILSA;
pub const ACMFILTERTAGENUMCB = thismodule.ACMFILTERTAGENUMCBA;
pub const ACMFILTERDETAILS = thismodule.ACMFILTERDETAILSA;
pub const ACMFILTERENUMCB = thismodule.ACMFILTERENUMCBA;
pub const ACMFILTERCHOOSEHOOKPROC = thismodule.ACMFILTERCHOOSEHOOKPROCA;
pub const ACMFILTERCHOOSE = thismodule.ACMFILTERCHOOSEA;
pub const tACMDRVOPENDESC = thismodule.tACMDRVOPENDESCA;
pub const sndPlaySound = thismodule.sndPlaySoundA;
pub const PlaySound = thismodule.PlaySoundA;
pub const waveOutGetDevCaps = thismodule.waveOutGetDevCapsA;
pub const waveOutGetErrorText = thismodule.waveOutGetErrorTextA;
pub const waveInGetDevCaps = thismodule.waveInGetDevCapsA;
pub const waveInGetErrorText = thismodule.waveInGetErrorTextA;
pub const midiOutGetDevCaps = thismodule.midiOutGetDevCapsA;
pub const midiOutGetErrorText = thismodule.midiOutGetErrorTextA;
pub const midiInGetDevCaps = thismodule.midiInGetDevCapsA;
pub const midiInGetErrorText = thismodule.midiInGetErrorTextA;
pub const auxGetDevCaps = thismodule.auxGetDevCapsA;
pub const mixerGetDevCaps = thismodule.mixerGetDevCapsA;
pub const mixerGetLineInfo = thismodule.mixerGetLineInfoA;
pub const mixerGetLineControls = thismodule.mixerGetLineControlsA;
pub const mixerGetControlDetails = thismodule.mixerGetControlDetailsA;
pub const acmDriverAdd = thismodule.acmDriverAddA;
pub const acmDriverDetails = thismodule.acmDriverDetailsA;
pub const acmFormatTagDetails = thismodule.acmFormatTagDetailsA;
pub const acmFormatTagEnum = thismodule.acmFormatTagEnumA;
pub const acmFormatDetails = thismodule.acmFormatDetailsA;
pub const acmFormatEnum = thismodule.acmFormatEnumA;
pub const acmFormatChoose = thismodule.acmFormatChooseA;
pub const acmFilterTagDetails = thismodule.acmFilterTagDetailsA;
pub const acmFilterTagEnum = thismodule.acmFilterTagEnumA;
pub const acmFilterDetails = thismodule.acmFilterDetailsA;
pub const acmFilterEnum = thismodule.acmFilterEnumA;
pub const acmFilterChoose = thismodule.acmFilterChooseA;
},
.wide => struct {
pub const WAVEOUTCAPS = thismodule.WAVEOUTCAPSW;
pub const WAVEOUTCAPS2 = thismodule.WAVEOUTCAPS2W;
pub const WAVEINCAPS = thismodule.WAVEINCAPSW;
pub const WAVEINCAPS2 = thismodule.WAVEINCAPS2W;
pub const MIDIOUTCAPS = thismodule.MIDIOUTCAPSW;
pub const MIDIOUTCAPS2 = thismodule.MIDIOUTCAPS2W;
pub const MIDIINCAPS = thismodule.MIDIINCAPSW;
pub const MIDIINCAPS2 = thismodule.MIDIINCAPS2W;
pub const AUXCAPS = thismodule.AUXCAPSW;
pub const AUXCAPS2 = thismodule.AUXCAPS2W;
pub const MIXERCAPS = thismodule.MIXERCAPSW;
pub const MIXERCAPS2 = thismodule.MIXERCAPS2W;
pub const MIXERLINE = thismodule.MIXERLINEW;
pub const MIXERCONTROL = thismodule.MIXERCONTROLW;
pub const MIXERLINECONTROLS = thismodule.MIXERLINECONTROLSW;
pub const MIXERCONTROLDETAILS_LISTTEXT = thismodule.MIXERCONTROLDETAILS_LISTTEXTW;
pub const ACMDRIVERDETAILS = thismodule.ACMDRIVERDETAILSW;
pub const ACMFORMATTAGDETAILS = thismodule.ACMFORMATTAGDETAILSW;
pub const ACMFORMATTAGENUMCB = thismodule.ACMFORMATTAGENUMCBW;
pub const ACMFORMATENUMCB = thismodule.ACMFORMATENUMCBW;
pub const ACMFORMATCHOOSEHOOKPROC = thismodule.ACMFORMATCHOOSEHOOKPROCW;
pub const ACMFORMATCHOOSE = thismodule.ACMFORMATCHOOSEW;
pub const ACMFILTERTAGDETAILS = thismodule.ACMFILTERTAGDETAILSW;
pub const ACMFILTERTAGENUMCB = thismodule.ACMFILTERTAGENUMCBW;
pub const ACMFILTERDETAILS = thismodule.ACMFILTERDETAILSW;
pub const ACMFILTERENUMCB = thismodule.ACMFILTERENUMCBW;
pub const ACMFILTERCHOOSEHOOKPROC = thismodule.ACMFILTERCHOOSEHOOKPROCW;
pub const ACMFILTERCHOOSE = thismodule.ACMFILTERCHOOSEW;
pub const tACMDRVOPENDESC = thismodule.tACMDRVOPENDESCW;
pub const sndPlaySound = thismodule.sndPlaySoundW;
pub const PlaySound = thismodule.PlaySoundW;
pub const waveOutGetDevCaps = thismodule.waveOutGetDevCapsW;
pub const waveOutGetErrorText = thismodule.waveOutGetErrorTextW;
pub const waveInGetDevCaps = thismodule.waveInGetDevCapsW;
pub const waveInGetErrorText = thismodule.waveInGetErrorTextW;
pub const midiOutGetDevCaps = thismodule.midiOutGetDevCapsW;
pub const midiOutGetErrorText = thismodule.midiOutGetErrorTextW;
pub const midiInGetDevCaps = thismodule.midiInGetDevCapsW;
pub const midiInGetErrorText = thismodule.midiInGetErrorTextW;
pub const auxGetDevCaps = thismodule.auxGetDevCapsW;
pub const mixerGetDevCaps = thismodule.mixerGetDevCapsW;
pub const mixerGetLineInfo = thismodule.mixerGetLineInfoW;
pub const mixerGetLineControls = thismodule.mixerGetLineControlsW;
pub const mixerGetControlDetails = thismodule.mixerGetControlDetailsW;
pub const acmDriverAdd = thismodule.acmDriverAddW;
pub const acmDriverDetails = thismodule.acmDriverDetailsW;
pub const acmFormatTagDetails = thismodule.acmFormatTagDetailsW;
pub const acmFormatTagEnum = thismodule.acmFormatTagEnumW;
pub const acmFormatDetails = thismodule.acmFormatDetailsW;
pub const acmFormatEnum = thismodule.acmFormatEnumW;
pub const acmFormatChoose = thismodule.acmFormatChooseW;
pub const acmFilterTagDetails = thismodule.acmFilterTagDetailsW;
pub const acmFilterTagEnum = thismodule.acmFilterTagEnumW;
pub const acmFilterDetails = thismodule.acmFilterDetailsW;
pub const acmFilterEnum = thismodule.acmFilterEnumW;
pub const acmFilterChoose = thismodule.acmFilterChooseW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const WAVEOUTCAPS = *opaque{};
pub const WAVEOUTCAPS2 = *opaque{};
pub const WAVEINCAPS = *opaque{};
pub const WAVEINCAPS2 = *opaque{};
pub const MIDIOUTCAPS = *opaque{};
pub const MIDIOUTCAPS2 = *opaque{};
pub const MIDIINCAPS = *opaque{};
pub const MIDIINCAPS2 = *opaque{};
pub const AUXCAPS = *opaque{};
pub const AUXCAPS2 = *opaque{};
pub const MIXERCAPS = *opaque{};
pub const MIXERCAPS2 = *opaque{};
pub const MIXERLINE = *opaque{};
pub const MIXERCONTROL = *opaque{};
pub const MIXERLINECONTROLS = *opaque{};
pub const MIXERCONTROLDETAILS_LISTTEXT = *opaque{};
pub const ACMDRIVERDETAILS = *opaque{};
pub const ACMFORMATTAGDETAILS = *opaque{};
pub const ACMFORMATTAGENUMCB = *opaque{};
pub const ACMFORMATENUMCB = *opaque{};
pub const ACMFORMATCHOOSEHOOKPROC = *opaque{};
pub const ACMFORMATCHOOSE = *opaque{};
pub const ACMFILTERTAGDETAILS = *opaque{};
pub const ACMFILTERTAGENUMCB = *opaque{};
pub const ACMFILTERDETAILS = *opaque{};
pub const ACMFILTERENUMCB = *opaque{};
pub const ACMFILTERCHOOSEHOOKPROC = *opaque{};
pub const ACMFILTERCHOOSE = *opaque{};
pub const tACMDRVOPENDESC = *opaque{};
pub const sndPlaySound = *opaque{};
pub const PlaySound = *opaque{};
pub const waveOutGetDevCaps = *opaque{};
pub const waveOutGetErrorText = *opaque{};
pub const waveInGetDevCaps = *opaque{};
pub const waveInGetErrorText = *opaque{};
pub const midiOutGetDevCaps = *opaque{};
pub const midiOutGetErrorText = *opaque{};
pub const midiInGetDevCaps = *opaque{};
pub const midiInGetErrorText = *opaque{};
pub const auxGetDevCaps = *opaque{};
pub const mixerGetDevCaps = *opaque{};
pub const mixerGetLineInfo = *opaque{};
pub const mixerGetLineControls = *opaque{};
pub const mixerGetControlDetails = *opaque{};
pub const acmDriverAdd = *opaque{};
pub const acmDriverDetails = *opaque{};
pub const acmFormatTagDetails = *opaque{};
pub const acmFormatTagEnum = *opaque{};
pub const acmFormatDetails = *opaque{};
pub const acmFormatEnum = *opaque{};
pub const acmFormatChoose = *opaque{};
pub const acmFilterTagDetails = *opaque{};
pub const acmFilterTagEnum = *opaque{};
pub const acmFilterDetails = *opaque{};
pub const acmFilterEnum = *opaque{};
pub const acmFilterChoose = *opaque{};
} else struct {
pub const WAVEOUTCAPS = @compileError("'WAVEOUTCAPS' requires that UNICODE be set to true or false in the root module");
pub const WAVEOUTCAPS2 = @compileError("'WAVEOUTCAPS2' requires that UNICODE be set to true or false in the root module");
pub const WAVEINCAPS = @compileError("'WAVEINCAPS' requires that UNICODE be set to true or false in the root module");
pub const WAVEINCAPS2 = @compileError("'WAVEINCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIDIOUTCAPS = @compileError("'MIDIOUTCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIDIOUTCAPS2 = @compileError("'MIDIOUTCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIDIINCAPS = @compileError("'MIDIINCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIDIINCAPS2 = @compileError("'MIDIINCAPS2' requires that UNICODE be set to true or false in the root module");
pub const AUXCAPS = @compileError("'AUXCAPS' requires that UNICODE be set to true or false in the root module");
pub const AUXCAPS2 = @compileError("'AUXCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIXERCAPS = @compileError("'MIXERCAPS' requires that UNICODE be set to true or false in the root module");
pub const MIXERCAPS2 = @compileError("'MIXERCAPS2' requires that UNICODE be set to true or false in the root module");
pub const MIXERLINE = @compileError("'MIXERLINE' requires that UNICODE be set to true or false in the root module");
pub const MIXERCONTROL = @compileError("'MIXERCONTROL' requires that UNICODE be set to true or false in the root module");
pub const MIXERLINECONTROLS = @compileError("'MIXERLINECONTROLS' requires that UNICODE be set to true or false in the root module");
pub const MIXERCONTROLDETAILS_LISTTEXT = @compileError("'MIXERCONTROLDETAILS_LISTTEXT' requires that UNICODE be set to true or false in the root module");
pub const ACMDRIVERDETAILS = @compileError("'ACMDRIVERDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATTAGDETAILS = @compileError("'ACMFORMATTAGDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATTAGENUMCB = @compileError("'ACMFORMATTAGENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATENUMCB = @compileError("'ACMFORMATENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATCHOOSEHOOKPROC = @compileError("'ACMFORMATCHOOSEHOOKPROC' requires that UNICODE be set to true or false in the root module");
pub const ACMFORMATCHOOSE = @compileError("'ACMFORMATCHOOSE' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERTAGDETAILS = @compileError("'ACMFILTERTAGDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERTAGENUMCB = @compileError("'ACMFILTERTAGENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERDETAILS = @compileError("'ACMFILTERDETAILS' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERENUMCB = @compileError("'ACMFILTERENUMCB' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERCHOOSEHOOKPROC = @compileError("'ACMFILTERCHOOSEHOOKPROC' requires that UNICODE be set to true or false in the root module");
pub const ACMFILTERCHOOSE = @compileError("'ACMFILTERCHOOSE' requires that UNICODE be set to true or false in the root module");
pub const tACMDRVOPENDESC = @compileError("'tACMDRVOPENDESC' requires that UNICODE be set to true or false in the root module");
pub const sndPlaySound = @compileError("'sndPlaySound' requires that UNICODE be set to true or false in the root module");
pub const PlaySound = @compileError("'PlaySound' requires that UNICODE be set to true or false in the root module");
pub const waveOutGetDevCaps = @compileError("'waveOutGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const waveOutGetErrorText = @compileError("'waveOutGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const waveInGetDevCaps = @compileError("'waveInGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const waveInGetErrorText = @compileError("'waveInGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const midiOutGetDevCaps = @compileError("'midiOutGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const midiOutGetErrorText = @compileError("'midiOutGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const midiInGetDevCaps = @compileError("'midiInGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const midiInGetErrorText = @compileError("'midiInGetErrorText' requires that UNICODE be set to true or false in the root module");
pub const auxGetDevCaps = @compileError("'auxGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const mixerGetDevCaps = @compileError("'mixerGetDevCaps' requires that UNICODE be set to true or false in the root module");
pub const mixerGetLineInfo = @compileError("'mixerGetLineInfo' requires that UNICODE be set to true or false in the root module");
pub const mixerGetLineControls = @compileError("'mixerGetLineControls' requires that UNICODE be set to true or false in the root module");
pub const mixerGetControlDetails = @compileError("'mixerGetControlDetails' requires that UNICODE be set to true or false in the root module");
pub const acmDriverAdd = @compileError("'acmDriverAdd' requires that UNICODE be set to true or false in the root module");
pub const acmDriverDetails = @compileError("'acmDriverDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatTagDetails = @compileError("'acmFormatTagDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatTagEnum = @compileError("'acmFormatTagEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFormatDetails = @compileError("'acmFormatDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFormatEnum = @compileError("'acmFormatEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFormatChoose = @compileError("'acmFormatChoose' requires that UNICODE be set to true or false in the root module");
pub const acmFilterTagDetails = @compileError("'acmFilterTagDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFilterTagEnum = @compileError("'acmFilterTagEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFilterDetails = @compileError("'acmFilterDetails' requires that UNICODE be set to true or false in the root module");
pub const acmFilterEnum = @compileError("'acmFilterEnum' requires that UNICODE be set to true or false in the root module");
pub const acmFilterChoose = @compileError("'acmFilterChoose' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (21)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const CHAR = @import("../foundation.zig").CHAR;
const HANDLE = @import("../foundation.zig").HANDLE;
const HDRVR = @import("../media/multimedia.zig").HDRVR;
const HICON = @import("../ui/windows_and_messaging.zig").HICON;
const HINSTANCE = @import("../foundation.zig").HINSTANCE;
const HRESULT = @import("../foundation.zig").HRESULT;
const HTASK = @import("../media.zig").HTASK;
const HWND = @import("../foundation.zig").HWND;
const INTERFACEINFO = @import("../system/com.zig").INTERFACEINFO;
const IPropertyStore = @import("../ui/shell/properties_system.zig").IPropertyStore;
const IUnknown = @import("../system/com.zig").IUnknown;
const LPARAM = @import("../foundation.zig").LPARAM;
const LRESULT = @import("../foundation.zig").LRESULT;
const MMTIME = @import("../media.zig").MMTIME;
const PROPERTYKEY = @import("../ui/shell/properties_system.zig").PROPERTYKEY;
const PROPVARIANT = @import("../system/com/structured_storage.zig").PROPVARIANT;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const WPARAM = @import("../foundation.zig").WPARAM;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "LPWAVECALLBACK")) { _ = LPWAVECALLBACK; }
if (@hasDecl(@This(), "LPMIDICALLBACK")) { _ = LPMIDICALLBACK; }
if (@hasDecl(@This(), "PAudioStateMonitorCallback")) { _ = PAudioStateMonitorCallback; }
if (@hasDecl(@This(), "ACMDRIVERENUMCB")) { _ = ACMDRIVERENUMCB; }
if (@hasDecl(@This(), "LPACMDRIVERPROC")) { _ = LPACMDRIVERPROC; }
if (@hasDecl(@This(), "ACMFORMATTAGENUMCBA")) { _ = ACMFORMATTAGENUMCBA; }
if (@hasDecl(@This(), "ACMFORMATTAGENUMCBW")) { _ = ACMFORMATTAGENUMCBW; }
if (@hasDecl(@This(), "ACMFORMATENUMCBA")) { _ = ACMFORMATENUMCBA; }
if (@hasDecl(@This(), "ACMFORMATENUMCBW")) { _ = ACMFORMATENUMCBW; }
if (@hasDecl(@This(), "ACMFORMATCHOOSEHOOKPROCA")) { _ = ACMFORMATCHOOSEHOOKPROCA; }
if (@hasDecl(@This(), "ACMFORMATCHOOSEHOOKPROCW")) { _ = ACMFORMATCHOOSEHOOKPROCW; }
if (@hasDecl(@This(), "ACMFILTERTAGENUMCBA")) { _ = ACMFILTERTAGENUMCBA; }
if (@hasDecl(@This(), "ACMFILTERTAGENUMCBW")) { _ = ACMFILTERTAGENUMCBW; }
if (@hasDecl(@This(), "ACMFILTERENUMCBA")) { _ = ACMFILTERENUMCBA; }
if (@hasDecl(@This(), "ACMFILTERENUMCBW")) { _ = ACMFILTERENUMCBW; }
if (@hasDecl(@This(), "ACMFILTERCHOOSEHOOKPROCA")) { _ = ACMFILTERCHOOSEHOOKPROCA; }
if (@hasDecl(@This(), "ACMFILTERCHOOSEHOOKPROCW")) { _ = ACMFILTERCHOOSEHOOKPROCW; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
}
//--------------------------------------------------------------------------------
// Section: SubModules (5)
//--------------------------------------------------------------------------------
pub const apo = @import("audio/apo.zig");
pub const direct_music = @import("audio/direct_music.zig");
pub const direct_sound = @import("audio/direct_sound.zig");
pub const endpoints = @import("audio/endpoints.zig");
pub const xaudio2 = @import("audio/xaudio2.zig"); | win32/media/audio.zig |
const std = @import("std");
const Image = @This();
const colormap_len = 0x100;
width: u32,
height: u32,
pixels: []u8,
colormap: ?[]u8 = null,
allocator: *std.mem.Allocator,
pub fn initFromFile(allocator: *std.mem.Allocator, file_path: []const u8) !Image {
var image_width: u32 = undefined;
var image_height: u32 = undefined;
var colormap_entries: u32 = undefined;
const c_file_path = try std.cstr.addNullByte(allocator, file_path);
defer allocator.free(c_file_path);
var err = readPngFileInfo(c_file_path, &image_width, &image_height, &colormap_entries);
if (err != 0) return error.ReadInfoFail;
const bytes_per_channel: u32 = if (colormap_entries > 0) 1 else 4; // indexed or rgba
const image_size = bytes_per_channel * image_width * image_height;
var self: Image = Image{
.width = image_width,
.height = image_height,
.pixels = try allocator.alloc(u8, image_size),
.allocator = allocator,
};
errdefer self.deinit();
if (colormap_entries > 0) self.colormap = try allocator.alloc(u8, 4 * colormap_len);
err = readPngFile(c_file_path, self.pixels.ptr, if (self.colormap) |colormap| colormap.ptr else null);
if (err != 0) return error.ReadPngFail;
return self;
}
pub fn initFromMemory(allocator: *std.mem.Allocator, memory: []const u8) !Image {
var image_width: u32 = undefined;
var image_height: u32 = undefined;
var colormap_entries: u32 = undefined;
var err = readPngMemoryInfo(memory.ptr, memory.len, &image_width, &image_height, &colormap_entries);
if (err != 0) return error.ReadInfoFail;
const bytes_per_channel: u32 = if (colormap_entries > 0) 1 else 4; // indexed or rgba
const image_size = bytes_per_channel * image_width * image_height;
var self: Image = Image{
.width = image_width,
.height = image_height,
.pixels = try allocator.alloc(u8, image_size),
.allocator = allocator,
};
errdefer self.deinit();
if (colormap_entries > 0) self.colormap = try allocator.alloc(u8, 4 * colormap_len);
err = readPngMemory(memory.ptr, memory.len, self.pixels.ptr, if (self.colormap) |colormap| colormap.ptr else null);
if (err != 0) return error.ReadPngFail;
return self;
}
pub fn deinit(self: *Image) void {
self.allocator.free(self.pixels);
if (self.colormap) |colormap| self.allocator.free(colormap);
}
pub fn writeToFile(self:Image, file_path: []const u8) !void {
const colormap: [*c]const u8 = if (self.colormap) |colormap| colormap.ptr else null;
const c_file_path = try std.cstr.addNullByte(self.allocator, file_path);
defer self.allocator.free(c_file_path);
const err = writePngFile(c_file_path, self.width, self.height, self.pixels.ptr, colormap, colormap_len);
if (err != 0) return error.WritePngFail;
}
pub fn writeToMemory(self: Image, allocator: *std.mem.Allocator) ![]const u8 {
const colormap: [*c]const u8 = if (self.colormap) |colormap| colormap.ptr else null;
var mem_len: usize = undefined;
var err = writePngMemory(null, &mem_len, self.width, self.height, self.pixels.ptr, colormap, colormap_len);
if (err != 0) return error.WritePngDetermineSizeFail;
const mem = try allocator.alloc(u8, mem_len);
errdefer allocator.free(mem);
err = writePngMemory(mem.ptr, &mem_len, self.width, self.height, self.pixels.ptr, colormap, colormap_len);
if (err != 0) return error.WritePngFail;
return mem;
}
// implementation in c/png_image.c
extern fn readPngFileInfo(file_path: [*c]const u8, width: [*c]u32, height: [*c]u32, colormap_entries: [*c]u32) callconv(.C) c_int;
extern fn readPngFile(file_path: [*c]const u8, pixels: [*c]const u8, colormap: [*c]const u8) callconv(.C) c_int;
extern fn readPngMemoryInfo(memory: [*c]const u8, len: usize, width: [*c]u32, height: [*c]u32, colormap_entries: [*c]u32) callconv(.C) c_int;
extern fn readPngMemory(memory: [*c]const u8, len: usize, pixels: [*c]const u8, colormap: [*c]const u8) callconv(.C) c_int;
extern fn writePngFile(file_path: [*c]const u8, width: u32, height: u32, pixels: [*c]const u8, colormap: [*c]const u8, colormap_entries: u32) callconv(.C) c_int;
extern fn writePngMemory(memory: [*c]const u8, len: [*c]usize, width: u32, height: u32, pixels: [*c]const u8, colormap: [*c]const u8, colormap_entries: u32) callconv(.C) c_int; | src/Image.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const gui = @import("gui");
const nvg = @import("nanovg");
const Rect = @import("gui/geometry.zig").Rect;
const Point = @import("gui/geometry.zig").Point;
const ColorForegroundBackgroundWidget = @This();
pub const ColorType = enum {
foreground,
background,
};
widget: gui.Widget,
allocator: *Allocator,
active: ColorType = .foreground,
colors: [2][4]u8 = [_][4]u8{
[_]u8{ 0, 0, 0, 0xff }, // foregorund
[_]u8{0xff} ** 4, // background
},
rects: [2]Rect(f32),
background_image: nvg.Image,
onChangedFn: ?fn (*Self) void = null,
const pad = 5;
const Self = @This();
pub fn init(allocator: *Allocator, rect: Rect(f32)) !*Self {
const rect_size = 32;
const rect_offset = 14;
var self = try allocator.create(Self);
self.* = Self{
.widget = gui.Widget.init(allocator, rect),
.allocator = allocator,
.rects = [_]Rect(f32){
Rect(f32).make(2 * pad, 2 * pad, rect_size, rect_size),
Rect(f32).make(2 * pad + rect_offset, 2 * pad + rect_offset, rect_size, rect_size),
},
.background_image = nvg.createImageRgba(2, 2, .{ .repeat_x = true, .repeat_y = true, .nearest = true }, &.{
0x66, 0x66, 0x66, 0xFF, 0x99, 0x99, 0x99, 0xFF,
0x99, 0x99, 0x99, 0xFF, 0x66, 0x66, 0x66, 0xFF,
}),
};
self.widget.onMouseDownFn = onMouseDown;
self.widget.drawFn = draw;
return self;
}
pub fn deinit(self: *Self) void {
nvg.deleteImage(self.background_image);
self.widget.deinit();
self.allocator.destroy(self);
}
pub fn setActive(self: *Self, active: ColorType) void {
if (self.active != active) {
self.active = active;
if (self.onChangedFn) |onChanged| onChanged(self);
}
}
pub fn swap(self: *Self) void {
std.mem.swap([4]u8, &self.colors[0], &self.colors[1]);
if (self.onChangedFn) |onChanged| onChanged(self);
}
pub fn getRgba(self: Self, color_type: ColorType) [4]u8 {
return self.colors[@enumToInt(color_type)];
}
pub fn setRgba(self: *Self, color_type: ColorType, color: [4]u8) void {
const t = @enumToInt(color_type);
if (!std.mem.eql(u8, self.colors[t][0..], color[0..])) {
std.mem.copy(u8, self.colors[t][0..], color[0..]);
if (self.onChangedFn) |onChanged| onChanged(self);
}
}
pub fn getActiveRgba(self: Self) [4]u8 {
return self.getRgba(self.active);
}
pub fn setActiveRgba(self: *Self, color: [4]u8) void {
self.setRgba(self.active, color);
}
fn onMouseDown(widget: *gui.Widget, event: *const gui.MouseEvent) void {
if (event.button == .left) {
var self = @fieldParentPtr(Self, "widget", widget);
const point = Point(f32).make(event.x, event.y);
for (self.rects) |rect, i| {
if (rect.contains(point)) {
self.setActive(@intToEnum(ColorType, @intCast(u1, i)));
break;
}
}
}
}
pub fn draw(widget: *gui.Widget) void {
const self = @fieldParentPtr(Self, "widget", widget);
const rect = widget.relative_rect;
nvg.save();
defer nvg.restore();
nvg.translate(rect.x, rect.y);
gui.drawPanel(0, 0, rect.w, rect.h, 1, false, false);
gui.drawPanelInset(pad, pad, 56, 56, 1);
var i: usize = self.colors.len;
while (i > 0) {
i -= 1;
const stroke_width: f32 = if (i == @enumToInt(self.active)) 2 else 1;
const stroke_color = if (i == @enumToInt(self.active)) nvg.rgb(0, 0, 0) else nvg.rgb(66, 66, 66);
nvg.beginPath();
nvg.rect(
self.rects[i].x + 0.5 * stroke_width,
self.rects[i].y + 0.5 * stroke_width,
self.rects[i].w - stroke_width,
self.rects[i].h - stroke_width,
);
nvg.fillPaint(nvg.imagePattern(0, 0, 8, 8, 0, self.background_image, 1));
nvg.fill();
nvg.fillColor(nvg.rgba(self.colors[i][0], self.colors[i][1], self.colors[i][2], self.colors[i][3]));
nvg.fill();
nvg.strokeWidth(stroke_width);
nvg.strokeColor(stroke_color);
nvg.stroke();
nvg.beginPath();
nvg.moveTo(self.rects[i].x + stroke_width, self.rects[i].y + stroke_width);
nvg.lineTo(self.rects[i].x + self.rects[i].w - stroke_width, self.rects[i].y + stroke_width);
nvg.lineTo(self.rects[i].x + stroke_width, self.rects[i].y + self.rects[i].h - stroke_width);
nvg.closePath();
nvg.fillColor(nvg.rgb(self.colors[i][0], self.colors[i][1], self.colors[i][2]));
nvg.fill();
}
} | src/ColorForegroundBackgroundWidget.zig |
const std = @import("std");
const assert = std.debug.assert;
const tools = @import("tools");
fn sum1(mem: []const u8, node_idx: usize) struct { sum: usize, size: usize } {
const child_count = mem[node_idx + 0];
const data_count = mem[node_idx + 1];
var sum: usize = 0;
var idx = node_idx + 2;
var child_index: usize = 0;
while (child_index < child_count) : (child_index += 1) {
const r = sum1(mem, idx);
idx += r.size;
sum += r.sum;
}
for (mem[idx .. idx + data_count]) |it| {
sum += it;
}
return .{ .sum = sum, .size = (idx + data_count) - node_idx };
}
fn sum2(mem: []const u8, node_idx: usize) struct { sum: usize, size: usize } {
const child_count = mem[node_idx + 0];
const data_count = mem[node_idx + 1];
var idx = node_idx + 2;
var sum: usize = 0;
if (child_count > 0) {
var child_sums = [_]usize{0} ** 12;
var child_index: usize = 0;
while (child_index < child_count) : (child_index += 1) {
const r = sum2(mem, idx);
idx += r.size;
child_sums[child_index] = r.sum;
}
for (mem[idx .. idx + data_count]) |it| {
if (it > 0 and it <= child_count)
sum += child_sums[it - 1];
}
} else {
for (mem[idx .. idx + data_count]) |it| {
sum += it;
}
}
return .{ .sum = sum, .size = (idx + data_count) - node_idx };
}
pub fn run(input: []const u8, allocator: std.mem.Allocator) ![2][]const u8 {
var mem = std.ArrayList(u8).init(allocator);
defer mem.deinit();
{
var it = std.mem.tokenize(u8, input, " \t\n\r");
while (it.next()) |val| {
try mem.append(try std.fmt.parseInt(u8, val, 0));
}
}
// part1
const ans1 = sum1(mem.items, 0).sum;
// part2
const ans2 = sum2(mem.items, 0).sum;
return [_][]const u8{
try std.fmt.allocPrint(allocator, "{}", .{ans1}),
try std.fmt.allocPrint(allocator, "{}", .{ans2}),
};
}
pub const main = tools.defaultMain("2018/input_day08.txt", run); | 2018/day08.zig |
const std = @import("std");
const debug = std.debug;
const assert = debug.assert;
const assertError = debug.assertError;
const warn = debug.warn;
/// Array of u1, typically for maximum performance min_num_bits == 2^n in size
pub fn ArrayU1(comptime min_num_bits: usize) type {
const UsizeIdx = switch (@sizeOf(usize)) {
4 => u5,
8 => u6,
else => @compileError("Currently only 4 and 8 byte usize supported for UsizeIdx\n"),
};
const usize_bit_count = @sizeOf(usize) * 8;
const usize_count = (min_num_bits + (usize_bit_count - 1)) / usize_bit_count;
return struct {
const Self = @This();
const Bits = [usize_count]usize;
const num_bits = @sizeOf(Bits) * usize_bit_count;
len: usize,
bits: Bits,
// Initialize the struct to 0 and return it
pub fn init() Self {
var ary = Self{
.len = min_num_bits,
.bits = undefined,
};
var i: usize = 0;
while (i < ary.bits.len) : (i += 1) {
ary.bits[i] = 0;
}
return ary;
}
/// Read a bit as bool
pub fn b(pSelf: *Self, bit_offset: usize) bool {
return pSelf.r(bit_offset) == 1;
}
/// Read a bit
pub fn r(pSelf: *Self, bit_offset: usize) usize {
if (bit_offset >= num_bits) return 0;
var usize_idx = bit_offset / usize_bit_count;
var bit_idx: UsizeIdx = @intCast(UsizeIdx, bit_offset % usize_bit_count);
var bit = (pSelf.bits[usize_idx] & ((usize(1) << bit_idx))) != 0;
return if (bit) usize(1) else usize(0);
}
/// Write a bit
pub fn w(pSelf: *Self, bit_offset: usize, val: usize) void {
if (bit_offset >= num_bits) return;
var usize_idx = bit_offset / usize_bit_count;
var bit_idx: UsizeIdx = @intCast(UsizeIdx, bit_offset % usize_bit_count);
var bit_mask: usize = usize(1) << bit_idx;
if (val == 0) {
pSelf.bits[usize_idx] &= ~bit_mask;
} else {
pSelf.bits[usize_idx] |= bit_mask;
}
}
};
}
test "ArrayU1.basic" {
var a = ArrayU1(1).init();
assert(a.r(0) == 0);
a.w(0, 1);
assert(a.r(0) == 1);
}
test "ArrayU1.bool" {
var a = ArrayU1(1).init();
assert(!a.b(0));
a.w(0, 1);
assert(a.b(0));
}
test "ArrayU1.test.init.all.0" {
var a1 = ArrayU1(1).init();
var bit: usize = 0;
while (bit < a1.len) : (bit += 1) {
assert(a1.r(bit) == 0);
}
var ausize_less_1 = ArrayU1((@sizeOf(usize) * 8) - 1).init();
bit = 0;
while (bit < ausize_less_1.len) : (bit += 1) {
assert(ausize_less_1.r(bit) == 0);
}
var ausize = ArrayU1(@sizeOf(usize) * 8).init();
bit = 0;
while (bit < ausize.len) : (bit += 1) {
assert(ausize.r(bit) == 0);
}
var ausize_usize_plus_1 = ArrayU1(@sizeOf(usize) * 8).init();
bit = 0;
while (bit < ausize_usize_plus_1.len) : (bit += 1) {
assert(ausize_usize_plus_1.r(bit) == 0);
}
}
test "ArrayU1.test.walking_1" {
const WO = struct {
fn walkingOne(comptime bit_count: usize) void {
var ary = ArrayU1(bit_count).init();
var bit: usize = 0;
while (bit < ary.len) : (bit += 1) {
ary.w(bit, 1);
assert(ary.r(bit) == 1);
// Verify one bit changed
var b0: usize = 0;
while (b0 < ary.len) : (b0 += 1) {
var b = ary.r(b0);
assert(b == if (b0 == bit) usize(1) else usize(0));
}
ary.w(bit, 0);
// Verify all are 0
b0 = 0;
while (b0 < ary.len) : (b0 += 1) {
assert(ary.r(b0) == 0);
}
}
}
};
WO.walkingOne(1);
WO.walkingOne((@sizeOf(usize) * 8) - 1);
WO.walkingOne((@sizeOf(usize) * 8));
WO.walkingOne((@sizeOf(usize) * 8) + 1);
}
test "ArrayU1.test.random" {
var bit0_off: usize = 0;
var bit0_on: usize = 0;
var bit1_off: usize = 0;
var bit1_on: usize = 0;
const bit_count: usize = 1024;
const write_count: usize = 512;
const seed: u64 = 4321;
// Create array of bits
var ary = ArrayU1(bit_count).init();
// Write ones
var prng = std.rand.DefaultPrng.init(seed);
var count: usize = write_count;
while (count > 0) : (count -= 1) {
var b = prng.random.scalar(usize) & 1;
ary.w(b, 1);
}
// Read them back
prng = std.rand.DefaultPrng.init(seed);
count = write_count;
while (count > 0) : (count -= 1) {
var b = prng.random.scalar(usize) & 1;
assert(ary.r(b) == 1);
}
} | array-u1.zig |
const std = @import("std");
const debug = std.debug;
const mem = std.mem;
pub fn main() !void {
var allocator = &std.heap.DirectAllocator.init().allocator;
const result1 = try step_dependency_order(allocator, dependency_hierarchy);
defer allocator.free(result1);
debug.warn("07-1: {}\n", result1);
const result2 = try step_completion_time(allocator, dependency_hierarchy, 5, 60);
debug.warn("07-2: {}\n", result2);
}
fn step_completion_time(allocator: *mem.Allocator, rules: []const Rule, num_workers: u32, base_step_time: u32) !u32 {
const step_range = set_of_all_steps(rules);
const largest_letter = step_range[step_range.len - 1];
var workers = try allocator.alloc(Worker, num_workers);
defer allocator.free(workers);
for (workers) |*w| {
w.step = Worker.idle;
w.seconds_worked = 0;
}
var completed_steps = try allocator.alloc(u8, step_range.len);
defer allocator.free(completed_steps);
var num_steps_completed: usize = 0;
var current_second: u32 = 0;
while (num_steps_completed < completed_steps.len) : (current_second += 1) {
//debug.warn("{}: ", current_second);
//for (workers) |w| {
// debug.warn("{c} ", w.step);
//}
//debug.warn("{}\n", completed_steps);
for (workers) |*w| {
// do work for this second
if (w.step != Worker.idle) {
w.seconds_worked += 1;
debug.assert(w.seconds_worked <= step_time(w.step, base_step_time));
// check for completed steps
if (w.seconds_worked == step_time(w.step, base_step_time)) {
completed_steps[num_steps_completed] = w.step;
num_steps_completed += 1;
w.step = Worker.idle;
w.seconds_worked = 0;
}
}
}
const awaiting_steps = try available_steps(allocator, completed_steps[0..num_steps_completed], workers, step_range, rules);
defer allocator.free(awaiting_steps);
var num_awaiting_steps_taken: u32 = 0;
for (workers) |*w| {
if (w.step == Worker.idle) {
if (num_awaiting_steps_taken < awaiting_steps.len) {
w.step = awaiting_steps[num_awaiting_steps_taken];
num_awaiting_steps_taken += 1;
}
}
}
}
return current_second - 1;
}
test "step completion time" {
var allocator = &std.heap.DirectAllocator.init().allocator;
debug.assert(15 == try step_completion_time(allocator, test_hierarchy, 2, 0));
}
fn available_steps(allocator: *mem.Allocator, completed_steps: []u8, workers: []Worker, step_range: []const u8, rules: []const Rule) ![]const u8 {
var steps_to_return = std.ArrayList(u8).init(allocator);
if (completed_steps.len == step_range.len - 1) {
// We've reached the end. There's only one uncompleted step.
for (step_range) |s| {
var step_is_done = false;
for (completed_steps) |done| {
if (done == s) {
step_is_done = true;
}
}
if (!step_is_done) {
try steps_to_return.append(s);
return steps_to_return.toSliceConst();
}
}
}
debug.assert(rules.len < 1000);
var relevant_rules_array = []bool{true} ** 1000;
var relevant_rules = relevant_rules_array[0..rules.len];
// cull irrelevant rules
for (completed_steps) |s| {
for (rules) |r, i| {
if (r.p == s) {
relevant_rules[i] = false;
}
}
}
// Make sure we didn't cull rules inconsistently
for (completed_steps) |s| {
for (rules) |r, i| {
if (relevant_rules[i]) {
debug.assert(r.p != s);
debug.assert(r.c != s);
}
}
}
// an available step is one that:
// - exists in the rules as a parent
// - does not exist in the rules as a child
// - is not the current step of any worker
for(step_range) |step| {
var step_exists_as_parent: bool = false;
var step_exists_as_child: bool = false;
var step_is_being_worked_on: bool = false;
for (rules) |r, i| {
if (relevant_rules[i]) {
if (step == r.p) {
step_exists_as_parent = true;
} else if (step == r.c) {
step_exists_as_child = true;
}
}
}
for (workers) |w| {
if (w.step == step) {
step_is_being_worked_on = true;
}
}
if (step_exists_as_parent and !step_exists_as_child and !step_is_being_worked_on) {
try steps_to_return.append(step);
}
}
return steps_to_return.toSliceConst();
}
const Worker = struct {
step: u8,
seconds_worked: u32,
const idle: u8 = '.';
};
fn step_time(step: u8, base_step_time: u32) u32 {
debug.assert(step >= 'A');
debug.assert(step <= 'Z');
const step_alphabet_number = step - 'A' + 1;
return step_alphabet_number + base_step_time;
}
test "step time" {
debug.assert(61 == step_time('A', 60));
debug.assert(86 == step_time('Z', 60));
debug.assert(1 == step_time('A', 0));
debug.assert(26 == step_time('Z', 0));
}
fn step_dependency_order(allocator: *mem.Allocator, rules: []const Rule) ![]const u8 {
const step_range = set_of_all_steps(rules);
const largest_letter = step_range[step_range.len - 1];
var steps = try allocator.alloc(u8, step_range.len);
for (steps) |*s, i| {
s.* = next_step(steps[0..i], step_range, rules);
}
return steps;
}
test "step dependency order" {
var allocator = &std.heap.DirectAllocator.init().allocator;
debug.assert(mem.eql(u8, "CABDFE", try step_dependency_order(allocator, test_hierarchy)));
}
fn next_step(done_steps: []u8, step_range: []const u8, rules: []const Rule) u8 {
if (done_steps.len == step_range.len - 1) {
// We've reached the end. There's only one undone step.
for (step_range) |s| {
var step_is_done = false;
for (done_steps) |done| {
if (done == s) {
step_is_done = true;
}
}
if (!step_is_done) {
return s;
}
}
}
debug.assert(rules.len < 1000);
var relevant_rules_array = []bool{true} ** 1000;
var relevant_rules = relevant_rules_array[0..rules.len];
// cull irrelevant rules
for (done_steps) |s| {
for (rules) |r, i| {
if (r.p == s) {
relevant_rules[i] = false;
}
}
}
// Make sure we didn't cull rules inconsistently
for (done_steps) |s| {
for (rules) |r, i| {
if (relevant_rules[i]) {
debug.assert(r.p != s);
debug.assert(r.c != s);
}
}
}
{
// the next step is the first one alphabetically that:
// - exists in the rules as a parent
// - does not exist in the rules as a child
var step: u8 = step_range[0];
while (step <= step_range[step_range.len - 1]) : (step += 1) {
var step_exists_as_parent: bool = false;
var step_exists_as_child: bool = false;
for (rules) |r, i| {
if (relevant_rules[i]) {
if (step == r.p) {
step_exists_as_parent = true;
} else if (step == r.c) {
step_exists_as_child = true;
}
}
}
if (step_exists_as_parent and !step_exists_as_child) {
return step;
}
}
}
unreachable;
}
fn set_of_all_steps(rules: []const Rule) []const u8 {
// This assumes no letters in the alphabetical range are skipped
const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var largest_letter: u8 = 'A';
for (rules) |r| {
if (r.p > largest_letter) {
largest_letter = r.p;
}
if (r.c > largest_letter) {
largest_letter = r.c;
}
}
var num_letters = largest_letter - 'A' + 1;
var step_range = letters[0..num_letters];
debug.assert(step_range.len <= 26);
return step_range;
}
const Rule = struct {
p: u8,
c: u8,
};
inline fn rule(parent: u8, child: u8) Rule {
return Rule {
.p = parent,
.c = child,
};
}
const test_hierarchy = []const Rule {
rule('C', 'A'),
rule('C', 'F'),
rule('A', 'B'),
rule('A', 'D'),
rule('B', 'E'),
rule('D', 'E'),
rule('F', 'E'),
};
const dependency_hierarchy = []const Rule {
rule('X', 'C'),
rule('C', 'G'),
rule('F', 'G'),
rule('U', 'Y'),
rule('O', 'S'),
rule('D', 'N'),
rule('M', 'H'),
rule('J', 'Q'),
rule('G', 'R'),
rule('I', 'N'),
rule('R', 'K'),
rule('A', 'Z'),
rule('Y', 'L'),
rule('H', 'P'),
rule('K', 'S'),
rule('Z', 'P'),
rule('T', 'S'),
rule('N', 'P'),
rule('E', 'S'),
rule('S', 'W'),
rule('W', 'V'),
rule('L', 'V'),
rule('P', 'B'),
rule('Q', 'V'),
rule('B', 'V'),
rule('P', 'Q'),
rule('S', 'V'),
rule('C', 'Q'),
rule('I', 'H'),
rule('A', 'E'),
rule('H', 'Q'),
rule('G', 'V'),
rule('N', 'L'),
rule('R', 'Q'),
rule('W', 'L'),
rule('X', 'L'),
rule('X', 'J'),
rule('W', 'P'),
rule('U', 'B'),
rule('P', 'V'),
rule('O', 'P'),
rule('W', 'Q'),
rule('S', 'Q'),
rule('U', 'Z'),
rule('Z', 'T'),
rule('M', 'T'),
rule('A', 'P'),
rule('Z', 'B'),
rule('N', 'S'),
rule('H', 'N'),
rule('J', 'E'),
rule('M', 'J'),
rule('R', 'A'),
rule('A', 'Y'),
rule('F', 'V'),
rule('L', 'P'),
rule('K', 'L'),
rule('F', 'P'),
rule('G', 'L'),
rule('I', 'Q'),
rule('C', 'L'),
rule('I', 'Y'),
rule('G', 'B'),
rule('H', 'L'),
rule('X', 'U'),
rule('I', 'K'),
rule('R', 'N'),
rule('I', 'L'),
rule('M', 'I'),
rule('K', 'V'),
rule('G', 'E'),
rule('F', 'B'),
rule('O', 'Y'),
rule('Y', 'Q'),
rule('F', 'K'),
rule('N', 'W'),
rule('O', 'R'),
rule('N', 'E'),
rule('M', 'V'),
rule('H', 'T'),
rule('Y', 'T'),
rule('F', 'J'),
rule('F', 'O'),
rule('W', 'B'),
rule('T', 'E'),
rule('T', 'P'),
rule('F', 'M'),
rule('U', 'I'),
rule('H', 'S'),
rule('S', 'P'),
rule('T', 'W'),
rule('A', 'N'),
rule('O', 'N'),
rule('L', 'B'),
rule('U', 'K'),
rule('Z', 'W'),
rule('X', 'D'),
rule('Z', 'L'),
rule('I', 'T'),
rule('O', 'W'),
rule('I', 'B'),
}; | 2018/day_07.zig |
const std = @import("std");
const mem = @import("std").mem;
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;
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
pub const gpa = &gpa_impl.allocator;
pub const ReadType = enum {
ArrayList,
Slice,
Library,
};
pub const ReadFileError = error{
TypeNotImplemented,
InvalidInput,
} ;
// Add utility functions here
pub fn parseDay01FileString(allocator: *std.mem.Allocator, readType : ReadType, fileContents : []const u8) ![]u64 {
if (readType == ReadType.ArrayList) {
return parseDay01FileArrayList(allocator, fileContents);
} else if (readType == ReadType.Slice) {
return parseDay01FileSlice(allocator, fileContents);
} else if (readType == ReadType.Library) {
return parseDay01FileLibrary(allocator, fileContents);
}
return ReadFileError.TypeNotImplemented;
}
fn parseDay01FileArrayList(allocator: *std.mem.Allocator, fileContents : []const u8) ![]u64 {
var numberStringBuilder = std.ArrayList(u8).init(allocator);
var parsedNumbers = std.ArrayList(u64).init(allocator);
for (fileContents) |character| {
if (character == '\n') {
var stringAsNumber = try std.fmt.parseInt(u64, numberStringBuilder.items, 10);
try parsedNumbers.append(stringAsNumber);
numberStringBuilder.shrinkRetainingCapacity(0);
} else if (character == '\r') {
continue;
} else {
try numberStringBuilder.append(character);
}
}
return parsedNumbers.items;
}
fn parseDay01FileSlice(allocator: *std.mem.Allocator, fileContents : []const u8) ![]u64 {
var parsedNumbers = std.ArrayList(u64).init(allocator);
var i : usize = 0;
var lineStart: usize = 0;
while (i < fileContents.len) : (i += 1) {
if (fileContents[i] == '\n') {
var stringAsNumber = try std.fmt.parseInt(u64, fileContents[lineStart..i-1], 10);
try parsedNumbers.append(stringAsNumber);
lineStart = i+1;
}
}
return parsedNumbers.items;
}
fn parseDay01FileLibrary(allocator: *std.mem.Allocator, fileContents : []const u8) ![]u64 {
var parsedNumbers = std.ArrayList(u64).init(allocator);
var splitLines = split(u8, fileContents, "\r\n");
while (true) {
if (splitLines.next()) |line| {
if (line.len == 0) {
continue;
}
var stringAsNumber = try std.fmt.parseInt(u64, line, 10);
try parsedNumbers.append(stringAsNumber);
} else {
break;
}
}
return parsedNumbers.items;
}
pub const Direction = enum {
Forward,
Up,
Down,
};
pub const MoveAction = struct {
direction : Direction,
length : u64,
};
pub fn parseDay02FileString(allocator: *std.mem.Allocator, readType : ReadType, fileContents : []const u8) ![]MoveAction {
if (readType != ReadType.ArrayList) {
return ReadFileError.TypeNotImplemented;
}
var lines = try readLinesFromFile(allocator, fileContents);
var actions = try allocator.alloc(MoveAction, lines.len);
var actionIndex : usize = 0;
for (lines) |line| {
const nullable_index = std.mem.indexOfScalar(u8, line, ' ');
if (nullable_index) |index| {
const foundDirection = switch (line[0]) {
102 => Direction.Forward,
117 => Direction.Up,
100 => Direction.Down,
else => unreachable,
};
var lengthAsNumber = try std.fmt.parseInt(u64, line[index+1..], 10);
actions[actionIndex] = MoveAction{
.direction = foundDirection,
.length = lengthAsNumber,
};
actionIndex += 1;
} else {
return ReadFileError.InvalidInput;
}
}
return actions;
}
pub fn readLinesFromFile(allocator: *std.mem.Allocator, fileContents : []const u8) ![][]const u8 {
var allLines = std.ArrayList([]const u8).init(allocator);
var splitLines = split(u8, fileContents, "\r\n");
while (true) {
if (splitLines.next()) |line| {
if (line.len == 0) {
continue;
}
try allLines.append(line);
} else {
break;
}
}
return allLines.items;
}
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const indexOf = std.mem.indexOfScalar;
const indexOfAny = std.mem.indexOfAny;
const indexOfStr = std.mem.indexOfPosLinear;
const lastIndexOf = std.mem.lastIndexOfScalar;
const lastIndexOfAny = std.mem.lastIndexOfAny;
const lastIndexOfStr = std.mem.lastIndexOfLinear;
const trim = std.mem.trim;
const sliceMin = std.mem.min;
const sliceMax = std.mem.max;
const parseInt = std.fmt.parseInt;
const parseFloat = std.fmt.parseFloat;
const min = std.math.min;
const min3 = std.math.min3;
const max = std.math.max;
const max3 = std.math.max3;
const print = std.debug.print;
const assert = std.debug.assert;
const sort = std.sort.sort;
const asc = std.sort.asc;
const desc = std.sort.desc; | src/util.zig |
pub const IOCTL_MTP_CUSTOM_COMMAND = @as(u32, 827348045);
pub const MTP_NEXTPHASE_READ_DATA = @as(u32, 1);
pub const MTP_NEXTPHASE_WRITE_DATA = @as(u32, 2);
pub const MTP_NEXTPHASE_NO_DATA = @as(u32, 3);
pub const RSA_KEY_LEN = @as(u32, 64);
pub const SAC_SESSION_KEYLEN = @as(u32, 8);
pub const SAC_PROTOCOL_WMDM = @as(u32, 1);
pub const SAC_PROTOCOL_V1 = @as(u32, 2);
pub const SAC_CERT_X509 = @as(u32, 1);
pub const SAC_CERT_V1 = @as(u32, 2);
pub const WMDM_DEVICE_PROTOCOL_MTP = Guid.initString("979e54e5-0afc-4604-8d93-dc798a4bcf45");
pub const WMDM_DEVICE_PROTOCOL_RAPI = Guid.initString("2a11ed91-8c8f-41e4-82d1-8386e003561c");
pub const WMDM_DEVICE_PROTOCOL_MSC = Guid.initString("a4d2c26c-a881-44bb-bd5d-1f703c71f7a9");
pub const WMDM_SERVICE_PROVIDER_VENDOR_MICROSOFT = Guid.initString("7de8686d-78ee-43ea-a496-c625ac91cc5d");
pub const WMDMID_LENGTH = @as(u32, 128);
pub const WMDM_MAC_LENGTH = @as(u32, 8);
pub const WMDM_S_NOT_ALL_PROPERTIES_APPLIED = @as(i32, 282625);
pub const WMDM_S_NOT_ALL_PROPERTIES_RETRIEVED = @as(i32, 282626);
pub const WMDM_E_BUSY = @as(i32, -2147201024);
pub const WMDM_E_INTERFACEDEAD = @as(i32, -2147201023);
pub const WMDM_E_INVALIDTYPE = @as(i32, -2147201022);
pub const WMDM_E_PROCESSFAILED = @as(i32, -2147201021);
pub const WMDM_E_NOTSUPPORTED = @as(i32, -2147201020);
pub const WMDM_E_NOTCERTIFIED = @as(i32, -2147201019);
pub const WMDM_E_NORIGHTS = @as(i32, -2147201018);
pub const WMDM_E_CALL_OUT_OF_SEQUENCE = @as(i32, -2147201017);
pub const WMDM_E_BUFFERTOOSMALL = @as(i32, -2147201016);
pub const WMDM_E_MOREDATA = @as(i32, -2147201015);
pub const WMDM_E_MAC_CHECK_FAILED = @as(i32, -2147201014);
pub const WMDM_E_USER_CANCELLED = @as(i32, -2147201013);
pub const WMDM_E_SDMI_TRIGGER = @as(i32, -2147201012);
pub const WMDM_E_SDMI_NOMORECOPIES = @as(i32, -2147201011);
pub const WMDM_E_REVOKED = @as(i32, -2147201010);
pub const WMDM_E_LICENSE_NOTEXIST = @as(i32, -2147201009);
pub const WMDM_E_INCORRECT_APPSEC = @as(i32, -2147201008);
pub const WMDM_E_INCORRECT_RIGHTS = @as(i32, -2147201007);
pub const WMDM_E_LICENSE_EXPIRED = @as(i32, -2147201006);
pub const WMDM_E_CANTOPEN_PMSN_SERVICE_PIPE = @as(i32, -2147201005);
pub const WMDM_E_TOO_MANY_SESSIONS = @as(i32, -2147201005);
pub const WMDM_WMDM_REVOKED = @as(u32, 1);
pub const WMDM_APP_REVOKED = @as(u32, 2);
pub const WMDM_SP_REVOKED = @as(u32, 4);
pub const WMDM_SCP_REVOKED = @as(u32, 8);
pub const WMDM_GET_FORMAT_SUPPORT_AUDIO = @as(u32, 1);
pub const WMDM_GET_FORMAT_SUPPORT_VIDEO = @as(u32, 2);
pub const WMDM_GET_FORMAT_SUPPORT_FILE = @as(u32, 4);
pub const WMDM_RIGHTS_PLAYBACKCOUNT = @as(u32, 1);
pub const WMDM_RIGHTS_EXPIRATIONDATE = @as(u32, 2);
pub const WMDM_RIGHTS_GROUPID = @as(u32, 4);
pub const WMDM_RIGHTS_FREESERIALIDS = @as(u32, 8);
pub const WMDM_RIGHTS_NAMEDSERIALIDS = @as(u32, 16);
pub const WMDM_DEVICE_TYPE_PLAYBACK = @as(u32, 1);
pub const WMDM_DEVICE_TYPE_RECORD = @as(u32, 2);
pub const WMDM_DEVICE_TYPE_DECODE = @as(u32, 4);
pub const WMDM_DEVICE_TYPE_ENCODE = @as(u32, 8);
pub const WMDM_DEVICE_TYPE_STORAGE = @as(u32, 16);
pub const WMDM_DEVICE_TYPE_VIRTUAL = @as(u32, 32);
pub const WMDM_DEVICE_TYPE_SDMI = @as(u32, 64);
pub const WMDM_DEVICE_TYPE_NONSDMI = @as(u32, 128);
pub const WMDM_DEVICE_TYPE_NONREENTRANT = @as(u32, 256);
pub const WMDM_DEVICE_TYPE_FILELISTRESYNC = @as(u32, 512);
pub const WMDM_DEVICE_TYPE_VIEW_PREF_METADATAVIEW = @as(u32, 1024);
pub const WMDM_POWER_CAP_BATTERY = @as(u32, 1);
pub const WMDM_POWER_CAP_EXTERNAL = @as(u32, 2);
pub const WMDM_POWER_IS_BATTERY = @as(u32, 4);
pub const WMDM_POWER_IS_EXTERNAL = @as(u32, 8);
pub const WMDM_POWER_PERCENT_AVAILABLE = @as(u32, 16);
pub const WMDM_STATUS_READY = @as(u32, 1);
pub const WMDM_STATUS_BUSY = @as(u32, 2);
pub const WMDM_STATUS_DEVICE_NOTPRESENT = @as(u32, 4);
pub const WMDM_STATUS_DEVICECONTROL_PLAYING = @as(u32, 8);
pub const WMDM_STATUS_DEVICECONTROL_RECORDING = @as(u32, 16);
pub const WMDM_STATUS_DEVICECONTROL_PAUSED = @as(u32, 32);
pub const WMDM_STATUS_DEVICECONTROL_REMOTE = @as(u32, 64);
pub const WMDM_STATUS_DEVICECONTROL_STREAM = @as(u32, 128);
pub const WMDM_STATUS_STORAGE_NOTPRESENT = @as(u32, 256);
pub const WMDM_STATUS_STORAGE_INITIALIZING = @as(u32, 512);
pub const WMDM_STATUS_STORAGE_BROKEN = @as(u32, 1024);
pub const WMDM_STATUS_STORAGE_NOTSUPPORTED = @as(u32, 2048);
pub const WMDM_STATUS_STORAGE_UNFORMATTED = @as(u32, 4096);
pub const WMDM_STATUS_STORAGECONTROL_INSERTING = @as(u32, 8192);
pub const WMDM_STATUS_STORAGECONTROL_DELETING = @as(u32, 16384);
pub const WMDM_STATUS_STORAGECONTROL_APPENDING = @as(u32, 32768);
pub const WMDM_STATUS_STORAGECONTROL_MOVING = @as(u32, 65536);
pub const WMDM_STATUS_STORAGECONTROL_READING = @as(u32, 131072);
pub const WMDM_DEVICECAP_CANPLAY = @as(u32, 1);
pub const WMDM_DEVICECAP_CANSTREAMPLAY = @as(u32, 2);
pub const WMDM_DEVICECAP_CANRECORD = @as(u32, 4);
pub const WMDM_DEVICECAP_CANSTREAMRECORD = @as(u32, 8);
pub const WMDM_DEVICECAP_CANPAUSE = @as(u32, 16);
pub const WMDM_DEVICECAP_CANRESUME = @as(u32, 32);
pub const WMDM_DEVICECAP_CANSTOP = @as(u32, 64);
pub const WMDM_DEVICECAP_CANSEEK = @as(u32, 128);
pub const WMDM_DEVICECAP_HASSECURECLOCK = @as(u32, 256);
pub const WMDM_SEEK_REMOTECONTROL = @as(u32, 1);
pub const WMDM_SEEK_STREAMINGAUDIO = @as(u32, 2);
pub const WMDM_STORAGE_ATTR_FILESYSTEM = @as(u32, 1);
pub const WMDM_STORAGE_ATTR_REMOVABLE = @as(u32, 2);
pub const WMDM_STORAGE_ATTR_NONREMOVABLE = @as(u32, 4);
pub const WMDM_FILE_ATTR_FOLDER = @as(u32, 8);
pub const WMDM_FILE_ATTR_LINK = @as(u32, 16);
pub const WMDM_FILE_ATTR_FILE = @as(u32, 32);
pub const WMDM_FILE_ATTR_VIDEO = @as(u32, 64);
pub const WMDM_STORAGE_ATTR_CANEDITMETADATA = @as(u32, 128);
pub const WMDM_STORAGE_ATTR_FOLDERS = @as(u32, 256);
pub const WMDM_FILE_ATTR_AUDIO = @as(u32, 4096);
pub const WMDM_FILE_ATTR_DATA = @as(u32, 8192);
pub const WMDM_FILE_ATTR_CANPLAY = @as(u32, 16384);
pub const WMDM_FILE_ATTR_CANDELETE = @as(u32, 32768);
pub const WMDM_FILE_ATTR_CANMOVE = @as(u32, 65536);
pub const WMDM_FILE_ATTR_CANRENAME = @as(u32, 131072);
pub const WMDM_FILE_ATTR_CANREAD = @as(u32, 262144);
pub const WMDM_FILE_ATTR_MUSIC = @as(u32, 524288);
pub const WMDM_FILE_CREATE_OVERWRITE = @as(u32, 1048576);
pub const WMDM_FILE_ATTR_AUDIOBOOK = @as(u32, 2097152);
pub const WMDM_FILE_ATTR_HIDDEN = @as(u32, 4194304);
pub const WMDM_FILE_ATTR_SYSTEM = @as(u32, 8388608);
pub const WMDM_FILE_ATTR_READONLY = @as(u32, 16777216);
pub const WMDM_STORAGE_ATTR_HAS_FOLDERS = @as(u32, 33554432);
pub const WMDM_STORAGE_ATTR_HAS_FILES = @as(u32, 67108864);
pub const WMDM_STORAGE_IS_DEFAULT = @as(u32, 134217728);
pub const WMDM_STORAGE_CONTAINS_DEFAULT = @as(u32, 268435456);
pub const WMDM_STORAGE_ATTR_VIRTUAL = @as(u32, 536870912);
pub const WMDM_STORAGECAP_FOLDERSINROOT = @as(u32, 1);
pub const WMDM_STORAGECAP_FILESINROOT = @as(u32, 2);
pub const WMDM_STORAGECAP_FOLDERSINFOLDERS = @as(u32, 4);
pub const WMDM_STORAGECAP_FILESINFOLDERS = @as(u32, 8);
pub const WMDM_STORAGECAP_FOLDERLIMITEXISTS = @as(u32, 16);
pub const WMDM_STORAGECAP_FILELIMITEXISTS = @as(u32, 32);
pub const WMDM_STORAGECAP_NOT_INITIALIZABLE = @as(u32, 64);
pub const WMDM_MODE_BLOCK = @as(u32, 1);
pub const WMDM_MODE_THREAD = @as(u32, 2);
pub const WMDM_CONTENT_FILE = @as(u32, 4);
pub const WMDM_CONTENT_FOLDER = @as(u32, 8);
pub const WMDM_CONTENT_OPERATIONINTERFACE = @as(u32, 16);
pub const WMDM_MODE_QUERY = @as(u32, 32);
pub const WMDM_MODE_PROGRESS = @as(u32, 64);
pub const WMDM_MODE_TRANSFER_PROTECTED = @as(u32, 128);
pub const WMDM_MODE_TRANSFER_UNPROTECTED = @as(u32, 256);
pub const WMDM_STORAGECONTROL_INSERTBEFORE = @as(u32, 512);
pub const WMDM_STORAGECONTROL_INSERTAFTER = @as(u32, 1024);
pub const WMDM_STORAGECONTROL_INSERTINTO = @as(u32, 2048);
pub const WMDM_MODE_RECURSIVE = @as(u32, 4096);
pub const WMDM_RIGHTS_PLAY_ON_PC = @as(u32, 1);
pub const WMDM_RIGHTS_COPY_TO_NON_SDMI_DEVICE = @as(u32, 2);
pub const WMDM_RIGHTS_COPY_TO_CD = @as(u32, 8);
pub const WMDM_RIGHTS_COPY_TO_SDMI_DEVICE = @as(u32, 16);
pub const WMDM_SEEK_BEGIN = @as(u32, 1);
pub const WMDM_SEEK_CURRENT = @as(u32, 2);
pub const WMDM_SEEK_END = @as(u32, 8);
pub const DO_NOT_VIRTUALIZE_STORAGES_AS_DEVICES = @as(u32, 1);
pub const ALLOW_OUTOFBAND_NOTIFICATION = @as(u32, 2);
pub const MDSP_READ = @as(u32, 1);
pub const MDSP_WRITE = @as(u32, 2);
pub const MDSP_SEEK_BOF = @as(u32, 1);
pub const MDSP_SEEK_CUR = @as(u32, 2);
pub const MDSP_SEEK_EOF = @as(u32, 4);
pub const WMDM_SCP_EXAMINE_EXTENSION = @as(i32, 1);
pub const WMDM_SCP_EXAMINE_DATA = @as(i32, 2);
pub const WMDM_SCP_DECIDE_DATA = @as(i32, 8);
pub const WMDM_SCP_PROTECTED_OUTPUT = @as(i32, 16);
pub const WMDM_SCP_UNPROTECTED_OUTPUT = @as(i32, 32);
pub const WMDM_SCP_RIGHTS_DATA = @as(i32, 64);
pub const WMDM_SCP_TRANSFER_OBJECTDATA = @as(i32, 32);
pub const WMDM_SCP_NO_MORE_CHANGES = @as(i32, 64);
pub const WMDM_SCP_DRMINFO_NOT_DRMPROTECTED = @as(i32, 0);
pub const WMDM_SCP_DRMINFO_V1HEADER = @as(i32, 1);
pub const WMDM_SCP_DRMINFO_V2HEADER = @as(i32, 2);
pub const SCP_EVENTID_ACQSECURECLOCK = Guid.initString("86248cc9-4a59-43e2-9146-48a7f3f4140c");
pub const SCP_EVENTID_NEEDTOINDIV = Guid.initString("87a507c7-b469-4386-b976-d5d1ce538a6f");
pub const SCP_EVENTID_DRMINFO = Guid.initString("213dd287-41d2-432b-9e3f-3b4f7b3581dd");
pub const SCP_PARAMID_DRMVERSION = Guid.initString("41d0155d-7cc7-4217-ada9-005074624da4");
pub const SAC_MAC_LEN = @as(u32, 8);
pub const WMDM_LOG_SEV_INFO = @as(u32, 1);
pub const WMDM_LOG_SEV_WARN = @as(u32, 2);
pub const WMDM_LOG_SEV_ERROR = @as(u32, 4);
pub const WMDM_LOG_NOTIMESTAMP = @as(u32, 16);
pub const g_wszWMDMFileName = "WMDM/FileName";
pub const g_wszWMDMFormatCode = "WMDM/FormatCode";
pub const g_wszWMDMLastModifiedDate = "WMDM/LastModifiedDate";
pub const g_wszWMDMFileCreationDate = "WMDM/FileCreationDate";
pub const g_wszWMDMFileSize = "WMDM/FileSize";
pub const g_wszWMDMFileAttributes = "WMDM/FileAttributes";
pub const g_wszAudioWAVECodec = "WMDM/AudioWAVECodec";
pub const g_wszVideoFourCCCodec = "WMDM/VideoFourCCCodec";
pub const g_wszWMDMTitle = "WMDM/Title";
pub const g_wszWMDMAuthor = "WMDM/Author";
pub const g_wszWMDMDescription = "WMDM/Description";
pub const g_wszWMDMIsProtected = "WMDM/IsProtected";
pub const g_wszWMDMAlbumTitle = "WMDM/AlbumTitle";
pub const g_wszWMDMAlbumArtist = "WMDM/AlbumArtist";
pub const g_wszWMDMTrack = "WMDM/Track";
pub const g_wszWMDMGenre = "WMDM/Genre";
pub const g_wszWMDMTrackMood = "WMDM/TrackMood";
pub const g_wszWMDMAlbumCoverFormat = "WMDM/AlbumCoverFormat";
pub const g_wszWMDMAlbumCoverSize = "WMDM/AlbumCoverSize";
pub const g_wszWMDMAlbumCoverHeight = "WMDM/AlbumCoverHeight";
pub const g_wszWMDMAlbumCoverWidth = "WMDM/AlbumCoverWidth";
pub const g_wszWMDMAlbumCoverDuration = "WMDM/AlbumCoverDuration";
pub const g_wszWMDMAlbumCoverData = "WMDM/AlbumCoverData";
pub const g_wszWMDMYear = "WMDM/Year";
pub const g_wszWMDMComposer = "WMDM/Composer";
pub const g_wszWMDMCodec = "WMDM/Codec";
pub const g_wszWMDMDRMId = "WMDM/DRMId";
pub const g_wszWMDMBitrate = "WMDM/Bitrate";
pub const g_wszWMDMBitRateType = "WMDM/BitRateType";
pub const g_wszWMDMSampleRate = "WMDM/SampleRate";
pub const g_wszWMDMNumChannels = "WMDM/NumChannels";
pub const g_wszWMDMBlockAlignment = "WMDM/BlockAlignment";
pub const g_wszWMDMAudioBitDepth = "WMDM/AudioBitDepth";
pub const g_wszWMDMTotalBitrate = "WMDM/TotalBitrate";
pub const g_wszWMDMVideoBitrate = "WMDM/VideoBitrate";
pub const g_wszWMDMFrameRate = "WMDM/FrameRate";
pub const g_wszWMDMScanType = "WMDM/ScanType";
pub const g_wszWMDMKeyFrameDistance = "WMDM/KeyFrameDistance";
pub const g_wszWMDMBufferSize = "WMDM/BufferSize";
pub const g_wszWMDMQualitySetting = "WMDM/QualitySetting";
pub const g_wszWMDMEncodingProfile = "WMDM/EncodingProfile";
pub const g_wszWMDMDuration = "WMDM/Duration";
pub const g_wszWMDMAlbumArt = "WMDM/AlbumArt";
pub const g_wszWMDMBuyNow = "WMDM/BuyNow";
pub const g_wszWMDMNonConsumable = "WMDM/NonConsumable";
pub const g_wszWMDMediaClassPrimaryID = "WMDM/MediaClassPrimaryID";
pub const g_wszWMDMMediaClassSecondaryID = "WMDM/MediaClassSecondaryID";
pub const g_wszWMDMUserEffectiveRating = "WMDM/UserEffectiveRating";
pub const g_wszWMDMUserRating = "WMDM/UserRating";
pub const g_wszWMDMUserRatingOnDevice = "WMDM/UserRatingOnDevice";
pub const g_wszWMDMPlayCount = "WMDM/PlayCount";
pub const g_wszWMDMDevicePlayCount = "WMDM/DevicePlayCount";
pub const g_wszWMDMAuthorDate = "WMDM/AuthorDate";
pub const g_wszWMDMUserLastPlayTime = "WMDM/UserLastPlayTime";
pub const g_wszWMDMSubTitle = "WMDM/SubTitle";
pub const g_wszWMDMSubTitleDescription = "WMDM/SubTitleDescription";
pub const g_wszWMDMMediaCredits = "WMDM/MediaCredits";
pub const g_wszWMDMMediaStationName = "WMDM/MediaStationName";
pub const g_wszWMDMMediaOriginalChannel = "WMDM/MediaOriginalChannel";
pub const g_wszWMDMMediaOriginalBroadcastDateTime = "WMDM/MediaOriginalBroadcastDateTime";
pub const g_wszWMDMProviderCopyright = "WMDM/ProviderCopyright";
pub const g_wszWMDMSyncID = "WMDM/SyncID";
pub const g_wszWMDMPersistentUniqueID = "WMDM/PersistentUniqueID";
pub const g_wszWMDMWidth = "WMDM/Width";
pub const g_wszWMDMHeight = "WMDM/Height";
pub const g_wszWMDMSyncTime = "WMDM/SyncTime";
pub const g_wszWMDMParentalRating = "WMDM/ParentalRating";
pub const g_wszWMDMMetaGenre = "WMDM/MetaGenre";
pub const g_wszWMDMIsRepeat = "WMDM/IsRepeat";
pub const g_wszWMDMSupportedDeviceProperties = "WMDM/SupportedDeviceProperties";
pub const g_wszWMDMDeviceFriendlyName = "WMDM/DeviceFriendlyName";
pub const g_wszWMDMFormatsSupported = "WMDM/FormatsSupported";
pub const g_wszWMDMFormatsSupportedAreOrdered = "WMDM/FormatsSupportedAreOrdered";
pub const g_wszWMDMSyncRelationshipID = "WMDM/SyncRelationshipID";
pub const g_wszWMDMDeviceModelName = "WMDM/DeviceModelName";
pub const g_wszWMDMDeviceFirmwareVersion = "WMDM/DeviceFirmwareVersion";
pub const g_wszWMDMDeviceVendorExtension = "WMDM/DeviceVendorExtension";
pub const g_wszWMDMDeviceProtocol = "WMDM/DeviceProtocol";
pub const g_wszWMDMDeviceServiceProviderVendor = "WMDM/DeviceServiceProviderVendor";
pub const g_wszWMDMDeviceRevocationInfo = "WMDM/DeviceRevocationInfo";
pub const g_wszWMDMCollectionID = "WMDM/CollectionID";
pub const g_wszWMDMOwner = "WMDM/Owner";
pub const g_wszWMDMEditor = "WMDM/Editor";
pub const g_wszWMDMWebmaster = "WMDM/Webmaster";
pub const g_wszWMDMSourceURL = "WMDM/SourceURL";
pub const g_wszWMDMDestinationURL = "WMDM/DestinationURL";
pub const g_wszWMDMCategory = "WMDM/Category";
pub const g_wszWMDMTimeBookmark = "WMDM/TimeBookmark";
pub const g_wszWMDMObjectBookmark = "WMDM/ObjectBookmark";
pub const g_wszWMDMByteBookmark = "WMDM/ByteBookmark";
pub const g_wszWMDMDataOffset = "WMDM/DataOffset";
pub const g_wszWMDMDataLength = "WMDM/DataLength";
pub const g_wszWMDMDataUnits = "WMDM/DataUnits";
pub const g_wszWMDMTimeToLive = "WMDM/TimeToLive";
pub const g_wszWMDMMediaGuid = "WMDM/MediaGuid";
pub const g_wszWPDPassthroughPropertyValues = "WPD/PassthroughPropertyValues";
pub const EVENT_WMDM_CONTENT_TRANSFER = Guid.initString("339c9bf4-bcfe-4ed8-94df-eaf8c26ab61b");
pub const MTP_COMMAND_MAX_PARAMS = @as(u32, 5);
pub const MTP_RESPONSE_MAX_PARAMS = @as(u32, 5);
pub const MTP_RESPONSE_OK = @as(u16, 8193);
//--------------------------------------------------------------------------------
// Section: Types (91)
//--------------------------------------------------------------------------------
pub const __MACINFO = extern struct {
fUsed: BOOL,
abMacState: [36]u8,
};
const CLSID_MediaDevMgrClassFactory_Value = @import("../zig.zig").Guid.initString("50040c1d-bdbf-4924-b873-f14d6c5bfd66");
pub const CLSID_MediaDevMgrClassFactory = &CLSID_MediaDevMgrClassFactory_Value;
const CLSID_MediaDevMgr_Value = @import("../zig.zig").Guid.initString("25baad81-3560-11d3-8471-00c04f79dbc0");
pub const CLSID_MediaDevMgr = &CLSID_MediaDevMgr_Value;
const CLSID_WMDMDevice_Value = @import("../zig.zig").Guid.initString("807b3cdf-357a-11d3-8471-00c04f79dbc0");
pub const CLSID_WMDMDevice = &CLSID_WMDMDevice_Value;
const CLSID_WMDMStorage_Value = @import("../zig.zig").Guid.initString("807b3ce0-357a-11d3-8471-00c04f79dbc0");
pub const CLSID_WMDMStorage = &CLSID_WMDMStorage_Value;
const CLSID_WMDMStorageGlobal_Value = @import("../zig.zig").Guid.initString("807b3ce1-357a-11d3-8471-00c04f79dbc0");
pub const CLSID_WMDMStorageGlobal = &CLSID_WMDMStorageGlobal_Value;
const CLSID_WMDMDeviceEnum_Value = @import("../zig.zig").Guid.initString("430e35af-3971-11d3-8474-00c04f79dbc0");
pub const CLSID_WMDMDeviceEnum = &CLSID_WMDMDeviceEnum_Value;
const CLSID_WMDMStorageEnum_Value = @import("../zig.zig").Guid.initString("eb401a3b-3af7-11d3-8474-00c04f79dbc0");
pub const CLSID_WMDMStorageEnum = &CLSID_WMDMStorageEnum_Value;
pub const WMDM_TAG_DATATYPE = enum(i32) {
DWORD = 0,
STRING = 1,
BINARY = 2,
BOOL = 3,
QWORD = 4,
WORD = 5,
GUID = 6,
DATE = 7,
};
pub const WMDM_TYPE_DWORD = WMDM_TAG_DATATYPE.DWORD;
pub const WMDM_TYPE_STRING = WMDM_TAG_DATATYPE.STRING;
pub const WMDM_TYPE_BINARY = WMDM_TAG_DATATYPE.BINARY;
pub const WMDM_TYPE_BOOL = WMDM_TAG_DATATYPE.BOOL;
pub const WMDM_TYPE_QWORD = WMDM_TAG_DATATYPE.QWORD;
pub const WMDM_TYPE_WORD = WMDM_TAG_DATATYPE.WORD;
pub const WMDM_TYPE_GUID = WMDM_TAG_DATATYPE.GUID;
pub const WMDM_TYPE_DATE = WMDM_TAG_DATATYPE.DATE;
pub const WMDM_SESSION_TYPE = enum(i32) {
NONE = 0,
TRANSFER_TO_DEVICE = 1,
TRANSFER_FROM_DEVICE = 16,
DELETE = 256,
CUSTOM = 4096,
};
pub const WMDM_SESSION_NONE = WMDM_SESSION_TYPE.NONE;
pub const WMDM_SESSION_TRANSFER_TO_DEVICE = WMDM_SESSION_TYPE.TRANSFER_TO_DEVICE;
pub const WMDM_SESSION_TRANSFER_FROM_DEVICE = WMDM_SESSION_TYPE.TRANSFER_FROM_DEVICE;
pub const WMDM_SESSION_DELETE = WMDM_SESSION_TYPE.DELETE;
pub const WMDM_SESSION_CUSTOM = WMDM_SESSION_TYPE.CUSTOM;
pub const _WAVEFORMATEX = extern struct {
wFormatTag: u16,
nChannels: u16,
nSamplesPerSec: u32,
nAvgBytesPerSec: u32,
nBlockAlign: u16,
wBitsPerSample: u16,
cbSize: u16,
};
pub const _BITMAPINFOHEADER = extern struct {
biSize: u32,
biWidth: i32,
biHeight: i32,
biPlanes: u16,
biBitCount: u16,
biCompression: u32,
biSizeImage: u32,
biXPelsPerMeter: i32,
biYPelsPerMeter: i32,
biClrUsed: u32,
biClrImportant: u32,
};
pub const _VIDEOINFOHEADER = extern struct {
rcSource: RECT,
rcTarget: RECT,
dwBitRate: u32,
dwBitErrorRate: u32,
AvgTimePerFrame: i64,
bmiHeader: _BITMAPINFOHEADER,
};
pub const WMFILECAPABILITIES = extern struct {
pwszMimeType: ?PWSTR,
dwReserved: u32,
};
pub const OPAQUECOMMAND = extern struct {
guidCommand: Guid,
dwDataLen: u32,
pData: ?*u8,
abMAC: [20]u8,
};
pub const WMDMID = extern struct {
cbSize: u32,
dwVendorID: u32,
pID: [128]u8,
SerialNumberLength: u32,
};
pub const WMDMDATETIME = extern struct {
wYear: u16,
wMonth: u16,
wDay: u16,
wHour: u16,
wMinute: u16,
wSecond: u16,
};
pub const WMDMRIGHTS = extern struct {
cbSize: u32,
dwContentType: u32,
fuFlags: u32,
fuRights: u32,
dwAppSec: u32,
dwPlaybackCount: u32,
ExpirationDate: WMDMDATETIME,
};
pub const WMDMMetadataView = extern struct {
pwszViewName: ?PWSTR,
nDepth: u32,
ppwszTags: ?*?*u16,
};
pub const WMDM_STORAGE_ENUM_MODE = enum(i32) {
RAW = 0,
USE_DEVICE_PREF = 1,
METADATA_VIEWS = 2,
};
pub const ENUM_MODE_RAW = WMDM_STORAGE_ENUM_MODE.RAW;
pub const ENUM_MODE_USE_DEVICE_PREF = WMDM_STORAGE_ENUM_MODE.USE_DEVICE_PREF;
pub const ENUM_MODE_METADATA_VIEWS = WMDM_STORAGE_ENUM_MODE.METADATA_VIEWS;
pub const WMDM_FORMATCODE = enum(i32) {
NOTUSED = 0,
ALLIMAGES = -1,
UNDEFINED = 12288,
ASSOCIATION = 12289,
SCRIPT = 12290,
EXECUTABLE = 12291,
TEXT = 12292,
HTML = 12293,
DPOF = 12294,
AIFF = 12295,
WAVE = 12296,
MP3 = 12297,
AVI = 12298,
MPEG = 12299,
ASF = 12300,
RESERVED_FIRST = 12301,
RESERVED_LAST = 14335,
IMAGE_UNDEFINED = 14336,
IMAGE_EXIF = 14337,
IMAGE_TIFFEP = 14338,
IMAGE_FLASHPIX = 14339,
IMAGE_BMP = 14340,
IMAGE_CIFF = 14341,
IMAGE_GIF = 14343,
IMAGE_JFIF = 14344,
IMAGE_PCD = 14345,
IMAGE_PICT = 14346,
IMAGE_PNG = 14347,
IMAGE_TIFF = 14349,
IMAGE_TIFFIT = 14350,
IMAGE_JP2 = 14351,
IMAGE_JPX = 14352,
IMAGE_RESERVED_FIRST = 14353,
IMAGE_RESERVED_LAST = 16383,
UNDEFINEDFIRMWARE = 47106,
WBMP = 47107,
JPEGXR = 47108,
WINDOWSIMAGEFORMAT = 47233,
UNDEFINEDAUDIO = 47360,
WMA = 47361,
OGG = 47362,
AAC = 47363,
AUDIBLE = 47364,
FLAC = 47366,
QCELP = 47367,
AMR = 47368,
UNDEFINEDVIDEO = 47488,
WMV = 47489,
MP4 = 47490,
MP2 = 47491,
@"3GP" = 47492,
@"3G2" = 47493,
AVCHD = 47494,
ATSCTS = 47495,
DVBTS = 47496,
MKV = 47497,
MKA = 47498,
MK3D = 47499,
UNDEFINEDCOLLECTION = 47616,
ABSTRACTMULTIMEDIAALBUM = 47617,
ABSTRACTIMAGEALBUM = 47618,
ABSTRACTAUDIOALBUM = 47619,
ABSTRACTVIDEOALBUM = 47620,
ABSTRACTAUDIOVIDEOPLAYLIST = 47621,
ABSTRACTCONTACTGROUP = 47622,
ABSTRACTMESSAGEFOLDER = 47623,
ABSTRACTCHAPTEREDPRODUCTION = 47624,
MEDIA_CAST = 47627,
WPLPLAYLIST = 47632,
M3UPLAYLIST = 47633,
MPLPLAYLIST = 47634,
ASXPLAYLIST = 47635,
PLSPLAYLIST = 47636,
UNDEFINEDDOCUMENT = 47744,
ABSTRACTDOCUMENT = 47745,
XMLDOCUMENT = 47746,
MICROSOFTWORDDOCUMENT = 47747,
MHTCOMPILEDHTMLDOCUMENT = 47748,
MICROSOFTEXCELSPREADSHEET = 47749,
MICROSOFTPOWERPOINTDOCUMENT = 47750,
UNDEFINEDMESSAGE = 47872,
ABSTRACTMESSAGE = 47873,
UNDEFINEDCONTACT = 48000,
ABSTRACTCONTACT = 48001,
VCARD2 = 48002,
VCARD3 = 48003,
UNDEFINEDCALENDARITEM = 48640,
ABSTRACTCALENDARITEM = 48641,
VCALENDAR1 = 48642,
VCALENDAR2 = 48643,
UNDEFINEDWINDOWSEXECUTABLE = 48768,
M4A = 1297101889,
@"3GPA" = 860311617,
@"3G2A" = 860303937,
SECTION = 48770,
};
pub const WMDM_FORMATCODE_NOTUSED = WMDM_FORMATCODE.NOTUSED;
pub const WMDM_FORMATCODE_ALLIMAGES = WMDM_FORMATCODE.ALLIMAGES;
pub const WMDM_FORMATCODE_UNDEFINED = WMDM_FORMATCODE.UNDEFINED;
pub const WMDM_FORMATCODE_ASSOCIATION = WMDM_FORMATCODE.ASSOCIATION;
pub const WMDM_FORMATCODE_SCRIPT = WMDM_FORMATCODE.SCRIPT;
pub const WMDM_FORMATCODE_EXECUTABLE = WMDM_FORMATCODE.EXECUTABLE;
pub const WMDM_FORMATCODE_TEXT = WMDM_FORMATCODE.TEXT;
pub const WMDM_FORMATCODE_HTML = WMDM_FORMATCODE.HTML;
pub const WMDM_FORMATCODE_DPOF = WMDM_FORMATCODE.DPOF;
pub const WMDM_FORMATCODE_AIFF = WMDM_FORMATCODE.AIFF;
pub const WMDM_FORMATCODE_WAVE = WMDM_FORMATCODE.WAVE;
pub const WMDM_FORMATCODE_MP3 = WMDM_FORMATCODE.MP3;
pub const WMDM_FORMATCODE_AVI = WMDM_FORMATCODE.AVI;
pub const WMDM_FORMATCODE_MPEG = WMDM_FORMATCODE.MPEG;
pub const WMDM_FORMATCODE_ASF = WMDM_FORMATCODE.ASF;
pub const WMDM_FORMATCODE_RESERVED_FIRST = WMDM_FORMATCODE.RESERVED_FIRST;
pub const WMDM_FORMATCODE_RESERVED_LAST = WMDM_FORMATCODE.RESERVED_LAST;
pub const WMDM_FORMATCODE_IMAGE_UNDEFINED = WMDM_FORMATCODE.IMAGE_UNDEFINED;
pub const WMDM_FORMATCODE_IMAGE_EXIF = WMDM_FORMATCODE.IMAGE_EXIF;
pub const WMDM_FORMATCODE_IMAGE_TIFFEP = WMDM_FORMATCODE.IMAGE_TIFFEP;
pub const WMDM_FORMATCODE_IMAGE_FLASHPIX = WMDM_FORMATCODE.IMAGE_FLASHPIX;
pub const WMDM_FORMATCODE_IMAGE_BMP = WMDM_FORMATCODE.IMAGE_BMP;
pub const WMDM_FORMATCODE_IMAGE_CIFF = WMDM_FORMATCODE.IMAGE_CIFF;
pub const WMDM_FORMATCODE_IMAGE_GIF = WMDM_FORMATCODE.IMAGE_GIF;
pub const WMDM_FORMATCODE_IMAGE_JFIF = WMDM_FORMATCODE.IMAGE_JFIF;
pub const WMDM_FORMATCODE_IMAGE_PCD = WMDM_FORMATCODE.IMAGE_PCD;
pub const WMDM_FORMATCODE_IMAGE_PICT = WMDM_FORMATCODE.IMAGE_PICT;
pub const WMDM_FORMATCODE_IMAGE_PNG = WMDM_FORMATCODE.IMAGE_PNG;
pub const WMDM_FORMATCODE_IMAGE_TIFF = WMDM_FORMATCODE.IMAGE_TIFF;
pub const WMDM_FORMATCODE_IMAGE_TIFFIT = WMDM_FORMATCODE.IMAGE_TIFFIT;
pub const WMDM_FORMATCODE_IMAGE_JP2 = WMDM_FORMATCODE.IMAGE_JP2;
pub const WMDM_FORMATCODE_IMAGE_JPX = WMDM_FORMATCODE.IMAGE_JPX;
pub const WMDM_FORMATCODE_IMAGE_RESERVED_FIRST = WMDM_FORMATCODE.IMAGE_RESERVED_FIRST;
pub const WMDM_FORMATCODE_IMAGE_RESERVED_LAST = WMDM_FORMATCODE.IMAGE_RESERVED_LAST;
pub const WMDM_FORMATCODE_UNDEFINEDFIRMWARE = WMDM_FORMATCODE.UNDEFINEDFIRMWARE;
pub const WMDM_FORMATCODE_WBMP = WMDM_FORMATCODE.WBMP;
pub const WMDM_FORMATCODE_JPEGXR = WMDM_FORMATCODE.JPEGXR;
pub const WMDM_FORMATCODE_WINDOWSIMAGEFORMAT = WMDM_FORMATCODE.WINDOWSIMAGEFORMAT;
pub const WMDM_FORMATCODE_UNDEFINEDAUDIO = WMDM_FORMATCODE.UNDEFINEDAUDIO;
pub const WMDM_FORMATCODE_WMA = WMDM_FORMATCODE.WMA;
pub const WMDM_FORMATCODE_OGG = WMDM_FORMATCODE.OGG;
pub const WMDM_FORMATCODE_AAC = WMDM_FORMATCODE.AAC;
pub const WMDM_FORMATCODE_AUDIBLE = WMDM_FORMATCODE.AUDIBLE;
pub const WMDM_FORMATCODE_FLAC = WMDM_FORMATCODE.FLAC;
pub const WMDM_FORMATCODE_QCELP = WMDM_FORMATCODE.QCELP;
pub const WMDM_FORMATCODE_AMR = WMDM_FORMATCODE.AMR;
pub const WMDM_FORMATCODE_UNDEFINEDVIDEO = WMDM_FORMATCODE.UNDEFINEDVIDEO;
pub const WMDM_FORMATCODE_WMV = WMDM_FORMATCODE.WMV;
pub const WMDM_FORMATCODE_MP4 = WMDM_FORMATCODE.MP4;
pub const WMDM_FORMATCODE_MP2 = WMDM_FORMATCODE.MP2;
pub const WMDM_FORMATCODE_3GP = WMDM_FORMATCODE.@"3GP";
pub const WMDM_FORMATCODE_3G2 = WMDM_FORMATCODE.@"3G2";
pub const WMDM_FORMATCODE_AVCHD = WMDM_FORMATCODE.AVCHD;
pub const WMDM_FORMATCODE_ATSCTS = WMDM_FORMATCODE.ATSCTS;
pub const WMDM_FORMATCODE_DVBTS = WMDM_FORMATCODE.DVBTS;
pub const WMDM_FORMATCODE_MKV = WMDM_FORMATCODE.MKV;
pub const WMDM_FORMATCODE_MKA = WMDM_FORMATCODE.MKA;
pub const WMDM_FORMATCODE_MK3D = WMDM_FORMATCODE.MK3D;
pub const WMDM_FORMATCODE_UNDEFINEDCOLLECTION = WMDM_FORMATCODE.UNDEFINEDCOLLECTION;
pub const WMDM_FORMATCODE_ABSTRACTMULTIMEDIAALBUM = WMDM_FORMATCODE.ABSTRACTMULTIMEDIAALBUM;
pub const WMDM_FORMATCODE_ABSTRACTIMAGEALBUM = WMDM_FORMATCODE.ABSTRACTIMAGEALBUM;
pub const WMDM_FORMATCODE_ABSTRACTAUDIOALBUM = WMDM_FORMATCODE.ABSTRACTAUDIOALBUM;
pub const WMDM_FORMATCODE_ABSTRACTVIDEOALBUM = WMDM_FORMATCODE.ABSTRACTVIDEOALBUM;
pub const WMDM_FORMATCODE_ABSTRACTAUDIOVIDEOPLAYLIST = WMDM_FORMATCODE.ABSTRACTAUDIOVIDEOPLAYLIST;
pub const WMDM_FORMATCODE_ABSTRACTCONTACTGROUP = WMDM_FORMATCODE.ABSTRACTCONTACTGROUP;
pub const WMDM_FORMATCODE_ABSTRACTMESSAGEFOLDER = WMDM_FORMATCODE.ABSTRACTMESSAGEFOLDER;
pub const WMDM_FORMATCODE_ABSTRACTCHAPTEREDPRODUCTION = WMDM_FORMATCODE.ABSTRACTCHAPTEREDPRODUCTION;
pub const WMDM_FORMATCODE_MEDIA_CAST = WMDM_FORMATCODE.MEDIA_CAST;
pub const WMDM_FORMATCODE_WPLPLAYLIST = WMDM_FORMATCODE.WPLPLAYLIST;
pub const WMDM_FORMATCODE_M3UPLAYLIST = WMDM_FORMATCODE.M3UPLAYLIST;
pub const WMDM_FORMATCODE_MPLPLAYLIST = WMDM_FORMATCODE.MPLPLAYLIST;
pub const WMDM_FORMATCODE_ASXPLAYLIST = WMDM_FORMATCODE.ASXPLAYLIST;
pub const WMDM_FORMATCODE_PLSPLAYLIST = WMDM_FORMATCODE.PLSPLAYLIST;
pub const WMDM_FORMATCODE_UNDEFINEDDOCUMENT = WMDM_FORMATCODE.UNDEFINEDDOCUMENT;
pub const WMDM_FORMATCODE_ABSTRACTDOCUMENT = WMDM_FORMATCODE.ABSTRACTDOCUMENT;
pub const WMDM_FORMATCODE_XMLDOCUMENT = WMDM_FORMATCODE.XMLDOCUMENT;
pub const WMDM_FORMATCODE_MICROSOFTWORDDOCUMENT = WMDM_FORMATCODE.MICROSOFTWORDDOCUMENT;
pub const WMDM_FORMATCODE_MHTCOMPILEDHTMLDOCUMENT = WMDM_FORMATCODE.MHTCOMPILEDHTMLDOCUMENT;
pub const WMDM_FORMATCODE_MICROSOFTEXCELSPREADSHEET = WMDM_FORMATCODE.MICROSOFTEXCELSPREADSHEET;
pub const WMDM_FORMATCODE_MICROSOFTPOWERPOINTDOCUMENT = WMDM_FORMATCODE.MICROSOFTPOWERPOINTDOCUMENT;
pub const WMDM_FORMATCODE_UNDEFINEDMESSAGE = WMDM_FORMATCODE.UNDEFINEDMESSAGE;
pub const WMDM_FORMATCODE_ABSTRACTMESSAGE = WMDM_FORMATCODE.ABSTRACTMESSAGE;
pub const WMDM_FORMATCODE_UNDEFINEDCONTACT = WMDM_FORMATCODE.UNDEFINEDCONTACT;
pub const WMDM_FORMATCODE_ABSTRACTCONTACT = WMDM_FORMATCODE.ABSTRACTCONTACT;
pub const WMDM_FORMATCODE_VCARD2 = WMDM_FORMATCODE.VCARD2;
pub const WMDM_FORMATCODE_VCARD3 = WMDM_FORMATCODE.VCARD3;
pub const WMDM_FORMATCODE_UNDEFINEDCALENDARITEM = WMDM_FORMATCODE.UNDEFINEDCALENDARITEM;
pub const WMDM_FORMATCODE_ABSTRACTCALENDARITEM = WMDM_FORMATCODE.ABSTRACTCALENDARITEM;
pub const WMDM_FORMATCODE_VCALENDAR1 = WMDM_FORMATCODE.VCALENDAR1;
pub const WMDM_FORMATCODE_VCALENDAR2 = WMDM_FORMATCODE.VCALENDAR2;
pub const WMDM_FORMATCODE_UNDEFINEDWINDOWSEXECUTABLE = WMDM_FORMATCODE.UNDEFINEDWINDOWSEXECUTABLE;
pub const WMDM_FORMATCODE_M4A = WMDM_FORMATCODE.M4A;
pub const WMDM_FORMATCODE_3GPA = WMDM_FORMATCODE.@"3GPA";
pub const WMDM_FORMATCODE_3G2A = WMDM_FORMATCODE.@"3G2A";
pub const WMDM_FORMATCODE_SECTION = WMDM_FORMATCODE.SECTION;
pub const WMDM_ENUM_PROP_VALID_VALUES_FORM = enum(i32) {
ANY = 0,
RANGE = 1,
ENUM = 2,
};
pub const WMDM_ENUM_PROP_VALID_VALUES_ANY = WMDM_ENUM_PROP_VALID_VALUES_FORM.ANY;
pub const WMDM_ENUM_PROP_VALID_VALUES_RANGE = WMDM_ENUM_PROP_VALID_VALUES_FORM.RANGE;
pub const WMDM_ENUM_PROP_VALID_VALUES_ENUM = WMDM_ENUM_PROP_VALID_VALUES_FORM.ENUM;
pub const WMDM_PROP_VALUES_RANGE = extern struct {
rangeMin: PROPVARIANT,
rangeMax: PROPVARIANT,
rangeStep: PROPVARIANT,
};
pub const WMDM_PROP_VALUES_ENUM = extern struct {
cEnumValues: u32,
pValues: ?*PROPVARIANT,
};
pub const WMDM_PROP_DESC = extern struct {
pwszPropName: ?PWSTR,
ValidValuesForm: WMDM_ENUM_PROP_VALID_VALUES_FORM,
ValidValues: extern union {
ValidValuesRange: WMDM_PROP_VALUES_RANGE,
EnumeratedValidValues: WMDM_PROP_VALUES_ENUM,
},
};
pub const WMDM_PROP_CONFIG = extern struct {
nPreference: u32,
nPropDesc: u32,
pPropDesc: ?*WMDM_PROP_DESC,
};
pub const WMDM_FORMAT_CAPABILITY = extern struct {
nPropConfig: u32,
pConfigs: ?*WMDM_PROP_CONFIG,
};
pub const WMDM_FIND_SCOPE = enum(i32) {
GLOBAL = 0,
IMMEDIATE_CHILDREN = 1,
};
pub const WMDM_FIND_SCOPE_GLOBAL = WMDM_FIND_SCOPE.GLOBAL;
pub const WMDM_FIND_SCOPE_IMMEDIATE_CHILDREN = WMDM_FIND_SCOPE.IMMEDIATE_CHILDREN;
pub const WMDMMessage = enum(i32) {
DEVICE_ARRIVAL = 0,
DEVICE_REMOVAL = 1,
MEDIA_ARRIVAL = 2,
MEDIA_REMOVAL = 3,
};
pub const WMDM_MSG_DEVICE_ARRIVAL = WMDMMessage.DEVICE_ARRIVAL;
pub const WMDM_MSG_DEVICE_REMOVAL = WMDMMessage.DEVICE_REMOVAL;
pub const WMDM_MSG_MEDIA_ARRIVAL = WMDMMessage.MEDIA_ARRIVAL;
pub const WMDM_MSG_MEDIA_REMOVAL = WMDMMessage.MEDIA_REMOVAL;
const IID_IWMDMMetaData_Value = @import("../zig.zig").Guid.initString("ec3b0663-0951-460a-9a80-0dceed3c043c");
pub const IID_IWMDMMetaData = &IID_IWMDMMetaData_Value;
pub const IWMDMMetaData = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddItem: fn(
self: *const IWMDMMetaData,
Type: WMDM_TAG_DATATYPE,
pwszTagName: ?[*:0]const u16,
pValue: ?[*:0]u8,
iLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
QueryByName: fn(
self: *const IWMDMMetaData,
pwszTagName: ?[*:0]const u16,
pType: ?*WMDM_TAG_DATATYPE,
pValue: ?[*]?*u8,
pcbLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
QueryByIndex: fn(
self: *const IWMDMMetaData,
iIndex: u32,
ppwszName: ?*?*u16,
pType: ?*WMDM_TAG_DATATYPE,
ppValue: ?[*]?*u8,
pcbLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetItemCount: fn(
self: *const IWMDMMetaData,
iCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMMetaData_AddItem(self: *const T, Type: WMDM_TAG_DATATYPE, pwszTagName: ?[*:0]const u16, pValue: ?[*:0]u8, iLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMMetaData.VTable, self.vtable).AddItem(@ptrCast(*const IWMDMMetaData, self), Type, pwszTagName, pValue, iLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMMetaData_QueryByName(self: *const T, pwszTagName: ?[*:0]const u16, pType: ?*WMDM_TAG_DATATYPE, pValue: ?[*]?*u8, pcbLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMMetaData.VTable, self.vtable).QueryByName(@ptrCast(*const IWMDMMetaData, self), pwszTagName, pType, pValue, pcbLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMMetaData_QueryByIndex(self: *const T, iIndex: u32, ppwszName: ?*?*u16, pType: ?*WMDM_TAG_DATATYPE, ppValue: ?[*]?*u8, pcbLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMMetaData.VTable, self.vtable).QueryByIndex(@ptrCast(*const IWMDMMetaData, self), iIndex, ppwszName, pType, ppValue, pcbLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMMetaData_GetItemCount(self: *const T, iCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMMetaData.VTable, self.vtable).GetItemCount(@ptrCast(*const IWMDMMetaData, self), iCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDeviceManager_Value = @import("../zig.zig").Guid.initString("1dcb3a00-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDeviceManager = &IID_IWMDeviceManager_Value;
pub const IWMDeviceManager = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRevision: fn(
self: *const IWMDeviceManager,
pdwRevision: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceCount: fn(
self: *const IWMDeviceManager,
pdwCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumDevices: fn(
self: *const IWMDeviceManager,
ppEnumDevice: ?*?*IWMDMEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager_GetRevision(self: *const T, pdwRevision: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager.VTable, self.vtable).GetRevision(@ptrCast(*const IWMDeviceManager, self), pdwRevision);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager_GetDeviceCount(self: *const T, pdwCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager.VTable, self.vtable).GetDeviceCount(@ptrCast(*const IWMDeviceManager, self), pdwCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager_EnumDevices(self: *const T, ppEnumDevice: ?*?*IWMDMEnumDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager.VTable, self.vtable).EnumDevices(@ptrCast(*const IWMDeviceManager, self), ppEnumDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDeviceManager2_Value = @import("../zig.zig").Guid.initString("923e5249-8731-4c5b-9b1c-b8b60b6e46af");
pub const IID_IWMDeviceManager2 = &IID_IWMDeviceManager2_Value;
pub const IWMDeviceManager2 = extern struct {
pub const VTable = extern struct {
base: IWMDeviceManager.VTable,
GetDeviceFromCanonicalName: fn(
self: *const IWMDeviceManager2,
pwszCanonicalName: ?[*:0]const u16,
ppDevice: ?*?*IWMDMDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumDevices2: fn(
self: *const IWMDeviceManager2,
ppEnumDevice: ?*?*IWMDMEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reinitialize: fn(
self: *const IWMDeviceManager2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDeviceManager.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager2_GetDeviceFromCanonicalName(self: *const T, pwszCanonicalName: ?[*:0]const u16, ppDevice: ?*?*IWMDMDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager2.VTable, self.vtable).GetDeviceFromCanonicalName(@ptrCast(*const IWMDeviceManager2, self), pwszCanonicalName, ppDevice);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager2_EnumDevices2(self: *const T, ppEnumDevice: ?*?*IWMDMEnumDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager2.VTable, self.vtable).EnumDevices2(@ptrCast(*const IWMDeviceManager2, self), ppEnumDevice);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager2_Reinitialize(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager2.VTable, self.vtable).Reinitialize(@ptrCast(*const IWMDeviceManager2, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDeviceManager3_Value = @import("../zig.zig").Guid.initString("af185c41-100d-46ed-be2e-9ce8c44594ef");
pub const IID_IWMDeviceManager3 = &IID_IWMDeviceManager3_Value;
pub const IWMDeviceManager3 = extern struct {
pub const VTable = extern struct {
base: IWMDeviceManager2.VTable,
SetDeviceEnumPreference: fn(
self: *const IWMDeviceManager3,
dwEnumPref: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDeviceManager2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDeviceManager3_SetDeviceEnumPreference(self: *const T, dwEnumPref: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDeviceManager3.VTable, self.vtable).SetDeviceEnumPreference(@ptrCast(*const IWMDeviceManager3, self), dwEnumPref);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorageGlobals_Value = @import("../zig.zig").Guid.initString("1dcb3a07-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMStorageGlobals = &IID_IWMDMStorageGlobals_Value;
pub const IWMDMStorageGlobals = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCapabilities: fn(
self: *const IWMDMStorageGlobals,
pdwCapabilities: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSerialNumber: fn(
self: *const IWMDMStorageGlobals,
pSerialNum: ?*WMDMID,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalSize: fn(
self: *const IWMDMStorageGlobals,
pdwTotalSizeLow: ?*u32,
pdwTotalSizeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalFree: fn(
self: *const IWMDMStorageGlobals,
pdwFreeLow: ?*u32,
pdwFreeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalBad: fn(
self: *const IWMDMStorageGlobals,
pdwBadLow: ?*u32,
pdwBadHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IWMDMStorageGlobals,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Initialize: fn(
self: *const IWMDMStorageGlobals,
fuMode: u32,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetCapabilities(self: *const T, pdwCapabilities: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetCapabilities(@ptrCast(*const IWMDMStorageGlobals, self), pdwCapabilities);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetSerialNumber(self: *const T, pSerialNum: ?*WMDMID, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetSerialNumber(@ptrCast(*const IWMDMStorageGlobals, self), pSerialNum, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetTotalSize(self: *const T, pdwTotalSizeLow: ?*u32, pdwTotalSizeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetTotalSize(@ptrCast(*const IWMDMStorageGlobals, self), pdwTotalSizeLow, pdwTotalSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetTotalFree(self: *const T, pdwFreeLow: ?*u32, pdwFreeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetTotalFree(@ptrCast(*const IWMDMStorageGlobals, self), pdwFreeLow, pdwFreeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetTotalBad(self: *const T, pdwBadLow: ?*u32, pdwBadHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetTotalBad(@ptrCast(*const IWMDMStorageGlobals, self), pdwBadLow, pdwBadHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_GetStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).GetStatus(@ptrCast(*const IWMDMStorageGlobals, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageGlobals_Initialize(self: *const T, fuMode: u32, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageGlobals.VTable, self.vtable).Initialize(@ptrCast(*const IWMDMStorageGlobals, self), fuMode, pProgress);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorage_Value = @import("../zig.zig").Guid.initString("1dcb3a06-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMStorage = &IID_IWMDMStorage_Value;
pub const IWMDMStorage = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetAttributes: fn(
self: *const IWMDMStorage,
dwAttributes: u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStorageGlobals: fn(
self: *const IWMDMStorage,
ppStorageGlobals: ?*?*IWMDMStorageGlobals,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributes: fn(
self: *const IWMDMStorage,
pdwAttributes: ?*u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetName: fn(
self: *const IWMDMStorage,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDate: fn(
self: *const IWMDMStorage,
pDateTimeUTC: ?*WMDMDATETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSize: fn(
self: *const IWMDMStorage,
pdwSizeLow: ?*u32,
pdwSizeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRights: fn(
self: *const IWMDMStorage,
ppRights: ?[*]?*WMDMRIGHTS,
pnRightsCount: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumStorage: fn(
self: *const IWMDMStorage,
pEnumStorage: ?*?*IWMDMEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendOpaqueCommand: fn(
self: *const IWMDMStorage,
pCommand: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_SetAttributes(self: *const T, dwAttributes: u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).SetAttributes(@ptrCast(*const IWMDMStorage, self), dwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetStorageGlobals(self: *const T, ppStorageGlobals: ?*?*IWMDMStorageGlobals) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetStorageGlobals(@ptrCast(*const IWMDMStorage, self), ppStorageGlobals);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetAttributes(self: *const T, pdwAttributes: ?*u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetAttributes(@ptrCast(*const IWMDMStorage, self), pdwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetName(@ptrCast(*const IWMDMStorage, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetDate(self: *const T, pDateTimeUTC: ?*WMDMDATETIME) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetDate(@ptrCast(*const IWMDMStorage, self), pDateTimeUTC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetSize(self: *const T, pdwSizeLow: ?*u32, pdwSizeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetSize(@ptrCast(*const IWMDMStorage, self), pdwSizeLow, pdwSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_GetRights(self: *const T, ppRights: ?[*]?*WMDMRIGHTS, pnRightsCount: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).GetRights(@ptrCast(*const IWMDMStorage, self), ppRights, pnRightsCount, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_EnumStorage(self: *const T, pEnumStorage: ?*?*IWMDMEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).EnumStorage(@ptrCast(*const IWMDMStorage, self), pEnumStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage_SendOpaqueCommand(self: *const T, pCommand: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage.VTable, self.vtable).SendOpaqueCommand(@ptrCast(*const IWMDMStorage, self), pCommand);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorage2_Value = @import("../zig.zig").Guid.initString("1ed5a144-5cd5-4683-9eff-72cbdb2d9533");
pub const IID_IWMDMStorage2 = &IID_IWMDMStorage2_Value;
pub const IWMDMStorage2 = extern struct {
pub const VTable = extern struct {
base: IWMDMStorage.VTable,
GetStorage: fn(
self: *const IWMDMStorage2,
pszStorageName: ?[*:0]const u16,
ppStorage: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAttributes2: fn(
self: *const IWMDMStorage2,
dwAttributes: u32,
dwAttributesEx: u32,
pFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributes2: fn(
self: *const IWMDMStorage2,
pdwAttributes: ?*u32,
pdwAttributesEx: ?*u32,
pAudioFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMStorage.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage2_GetStorage(self: *const T, pszStorageName: ?[*:0]const u16, ppStorage: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage2.VTable, self.vtable).GetStorage(@ptrCast(*const IWMDMStorage2, self), pszStorageName, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage2_SetAttributes2(self: *const T, dwAttributes: u32, dwAttributesEx: u32, pFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage2.VTable, self.vtable).SetAttributes2(@ptrCast(*const IWMDMStorage2, self), dwAttributes, dwAttributesEx, pFormat, pVideoFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage2_GetAttributes2(self: *const T, pdwAttributes: ?*u32, pdwAttributesEx: ?*u32, pAudioFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage2.VTable, self.vtable).GetAttributes2(@ptrCast(*const IWMDMStorage2, self), pdwAttributes, pdwAttributesEx, pAudioFormat, pVideoFormat);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorage3_Value = @import("../zig.zig").Guid.initString("97717eea-926a-464e-96a4-247b0216026e");
pub const IID_IWMDMStorage3 = &IID_IWMDMStorage3_Value;
pub const IWMDMStorage3 = extern struct {
pub const VTable = extern struct {
base: IWMDMStorage2.VTable,
GetMetadata: fn(
self: *const IWMDMStorage3,
ppMetadata: ?*?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMetadata: fn(
self: *const IWMDMStorage3,
pMetadata: ?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateEmptyMetadataObject: fn(
self: *const IWMDMStorage3,
ppMetadata: ?*?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetEnumPreference: fn(
self: *const IWMDMStorage3,
pMode: ?*WMDM_STORAGE_ENUM_MODE,
nViews: u32,
pViews: ?[*]WMDMMetadataView,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMStorage2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage3_GetMetadata(self: *const T, ppMetadata: ?*?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage3.VTable, self.vtable).GetMetadata(@ptrCast(*const IWMDMStorage3, self), ppMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage3_SetMetadata(self: *const T, pMetadata: ?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage3.VTable, self.vtable).SetMetadata(@ptrCast(*const IWMDMStorage3, self), pMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage3_CreateEmptyMetadataObject(self: *const T, ppMetadata: ?*?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage3.VTable, self.vtable).CreateEmptyMetadataObject(@ptrCast(*const IWMDMStorage3, self), ppMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage3_SetEnumPreference(self: *const T, pMode: ?*WMDM_STORAGE_ENUM_MODE, nViews: u32, pViews: ?[*]WMDMMetadataView) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage3.VTable, self.vtable).SetEnumPreference(@ptrCast(*const IWMDMStorage3, self), pMode, nViews, pViews);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorage4_Value = @import("../zig.zig").Guid.initString("c225bac5-a03a-40b8-9a23-91cf478c64a6");
pub const IID_IWMDMStorage4 = &IID_IWMDMStorage4_Value;
pub const IWMDMStorage4 = extern struct {
pub const VTable = extern struct {
base: IWMDMStorage3.VTable,
SetReferences: fn(
self: *const IWMDMStorage4,
dwRefs: u32,
ppIWMDMStorage: ?[*]?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetReferences: fn(
self: *const IWMDMStorage4,
pdwRefs: ?*u32,
pppIWMDMStorage: ?[*]?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRightsWithProgress: fn(
self: *const IWMDMStorage4,
pIProgressCallback: ?*IWMDMProgress3,
ppRights: ?[*]?*WMDMRIGHTS,
pnRightsCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpecifiedMetadata: fn(
self: *const IWMDMStorage4,
cProperties: u32,
ppwszPropNames: [*]?PWSTR,
ppMetadata: ?*?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindStorage: fn(
self: *const IWMDMStorage4,
findScope: WMDM_FIND_SCOPE,
pwszUniqueID: ?[*:0]const u16,
ppStorage: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetParent: fn(
self: *const IWMDMStorage4,
ppStorage: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMStorage3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_SetReferences(self: *const T, dwRefs: u32, ppIWMDMStorage: ?[*]?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).SetReferences(@ptrCast(*const IWMDMStorage4, self), dwRefs, ppIWMDMStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_GetReferences(self: *const T, pdwRefs: ?*u32, pppIWMDMStorage: ?[*]?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).GetReferences(@ptrCast(*const IWMDMStorage4, self), pdwRefs, pppIWMDMStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_GetRightsWithProgress(self: *const T, pIProgressCallback: ?*IWMDMProgress3, ppRights: ?[*]?*WMDMRIGHTS, pnRightsCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).GetRightsWithProgress(@ptrCast(*const IWMDMStorage4, self), pIProgressCallback, ppRights, pnRightsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_GetSpecifiedMetadata(self: *const T, cProperties: u32, ppwszPropNames: [*]?PWSTR, ppMetadata: ?*?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).GetSpecifiedMetadata(@ptrCast(*const IWMDMStorage4, self), cProperties, ppwszPropNames, ppMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_FindStorage(self: *const T, findScope: WMDM_FIND_SCOPE, pwszUniqueID: ?[*:0]const u16, ppStorage: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).FindStorage(@ptrCast(*const IWMDMStorage4, self), findScope, pwszUniqueID, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorage4_GetParent(self: *const T, ppStorage: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorage4.VTable, self.vtable).GetParent(@ptrCast(*const IWMDMStorage4, self), ppStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMOperation_Value = @import("../zig.zig").Guid.initString("1dcb3a0b-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMOperation = &IID_IWMDMOperation_Value;
pub const IWMDMOperation = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
BeginRead: fn(
self: *const IWMDMOperation,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginWrite: fn(
self: *const IWMDMOperation,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectName: fn(
self: *const IWMDMOperation,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetObjectName: fn(
self: *const IWMDMOperation,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectAttributes: fn(
self: *const IWMDMOperation,
pdwAttributes: ?*u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetObjectAttributes: fn(
self: *const IWMDMOperation,
dwAttributes: u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectTotalSize: fn(
self: *const IWMDMOperation,
pdwSize: ?*u32,
pdwSizeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetObjectTotalSize: fn(
self: *const IWMDMOperation,
dwSize: u32,
dwSizeHigh: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TransferObjectData: fn(
self: *const IWMDMOperation,
pData: [*:0]u8,
pdwSize: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End: fn(
self: *const IWMDMOperation,
phCompletionCode: ?*HRESULT,
pNewObject: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_BeginRead(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).BeginRead(@ptrCast(*const IWMDMOperation, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_BeginWrite(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).BeginWrite(@ptrCast(*const IWMDMOperation, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_GetObjectName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).GetObjectName(@ptrCast(*const IWMDMOperation, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_SetObjectName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).SetObjectName(@ptrCast(*const IWMDMOperation, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_GetObjectAttributes(self: *const T, pdwAttributes: ?*u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).GetObjectAttributes(@ptrCast(*const IWMDMOperation, self), pdwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_SetObjectAttributes(self: *const T, dwAttributes: u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).SetObjectAttributes(@ptrCast(*const IWMDMOperation, self), dwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_GetObjectTotalSize(self: *const T, pdwSize: ?*u32, pdwSizeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).GetObjectTotalSize(@ptrCast(*const IWMDMOperation, self), pdwSize, pdwSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_SetObjectTotalSize(self: *const T, dwSize: u32, dwSizeHigh: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).SetObjectTotalSize(@ptrCast(*const IWMDMOperation, self), dwSize, dwSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_TransferObjectData(self: *const T, pData: [*:0]u8, pdwSize: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).TransferObjectData(@ptrCast(*const IWMDMOperation, self), pData, pdwSize, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation_End(self: *const T, phCompletionCode: ?*HRESULT, pNewObject: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation.VTable, self.vtable).End(@ptrCast(*const IWMDMOperation, self), phCompletionCode, pNewObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMOperation2_Value = @import("../zig.zig").Guid.initString("33445b48-7df7-425c-ad8f-0fc6d82f9f75");
pub const IID_IWMDMOperation2 = &IID_IWMDMOperation2_Value;
pub const IWMDMOperation2 = extern struct {
pub const VTable = extern struct {
base: IWMDMOperation.VTable,
SetObjectAttributes2: fn(
self: *const IWMDMOperation2,
dwAttributes: u32,
dwAttributesEx: u32,
pFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectAttributes2: fn(
self: *const IWMDMOperation2,
pdwAttributes: ?*u32,
pdwAttributesEx: ?*u32,
pAudioFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMOperation.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation2_SetObjectAttributes2(self: *const T, dwAttributes: u32, dwAttributesEx: u32, pFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation2.VTable, self.vtable).SetObjectAttributes2(@ptrCast(*const IWMDMOperation2, self), dwAttributes, dwAttributesEx, pFormat, pVideoFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation2_GetObjectAttributes2(self: *const T, pdwAttributes: ?*u32, pdwAttributesEx: ?*u32, pAudioFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation2.VTable, self.vtable).GetObjectAttributes2(@ptrCast(*const IWMDMOperation2, self), pdwAttributes, pdwAttributesEx, pAudioFormat, pVideoFormat);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMOperation3_Value = @import("../zig.zig").Guid.initString("d1f9b46a-9ca8-46d8-9d0f-1ec9bae54919");
pub const IID_IWMDMOperation3 = &IID_IWMDMOperation3_Value;
pub const IWMDMOperation3 = extern struct {
pub const VTable = extern struct {
base: IWMDMOperation.VTable,
TransferObjectDataOnClearChannel: fn(
self: *const IWMDMOperation3,
pData: [*:0]u8,
pdwSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMOperation.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMOperation3_TransferObjectDataOnClearChannel(self: *const T, pData: [*:0]u8, pdwSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMOperation3.VTable, self.vtable).TransferObjectDataOnClearChannel(@ptrCast(*const IWMDMOperation3, self), pData, pdwSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMProgress_Value = @import("../zig.zig").Guid.initString("1dcb3a0c-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMProgress = &IID_IWMDMProgress_Value;
pub const IWMDMProgress = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Begin: fn(
self: *const IWMDMProgress,
dwEstimatedTicks: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Progress: fn(
self: *const IWMDMProgress,
dwTranspiredTicks: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End: fn(
self: *const IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress_Begin(self: *const T, dwEstimatedTicks: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress.VTable, self.vtable).Begin(@ptrCast(*const IWMDMProgress, self), dwEstimatedTicks);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress_Progress(self: *const T, dwTranspiredTicks: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress.VTable, self.vtable).Progress(@ptrCast(*const IWMDMProgress, self), dwTranspiredTicks);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress_End(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress.VTable, self.vtable).End(@ptrCast(*const IWMDMProgress, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMProgress2_Value = @import("../zig.zig").Guid.initString("3a43f550-b383-4e92-b04a-e6bbc660fefc");
pub const IID_IWMDMProgress2 = &IID_IWMDMProgress2_Value;
pub const IWMDMProgress2 = extern struct {
pub const VTable = extern struct {
base: IWMDMProgress.VTable,
End2: fn(
self: *const IWMDMProgress2,
hrCompletionCode: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMProgress.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress2_End2(self: *const T, hrCompletionCode: HRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress2.VTable, self.vtable).End2(@ptrCast(*const IWMDMProgress2, self), hrCompletionCode);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMProgress3_Value = @import("../zig.zig").Guid.initString("21de01cb-3bb4-4929-b21a-17af3f80f658");
pub const IID_IWMDMProgress3 = &IID_IWMDMProgress3_Value;
pub const IWMDMProgress3 = extern struct {
pub const VTable = extern struct {
base: IWMDMProgress2.VTable,
Begin3: fn(
self: *const IWMDMProgress3,
EventId: Guid,
dwEstimatedTicks: u32,
pContext: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Progress3: fn(
self: *const IWMDMProgress3,
EventId: Guid,
dwTranspiredTicks: u32,
pContext: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End3: fn(
self: *const IWMDMProgress3,
EventId: Guid,
hrCompletionCode: HRESULT,
pContext: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMProgress2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress3_Begin3(self: *const T, EventId: Guid, dwEstimatedTicks: u32, pContext: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress3.VTable, self.vtable).Begin3(@ptrCast(*const IWMDMProgress3, self), EventId, dwEstimatedTicks, pContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress3_Progress3(self: *const T, EventId: Guid, dwTranspiredTicks: u32, pContext: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress3.VTable, self.vtable).Progress3(@ptrCast(*const IWMDMProgress3, self), EventId, dwTranspiredTicks, pContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMProgress3_End3(self: *const T, EventId: Guid, hrCompletionCode: HRESULT, pContext: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMProgress3.VTable, self.vtable).End3(@ptrCast(*const IWMDMProgress3, self), EventId, hrCompletionCode, pContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMDevice_Value = @import("../zig.zig").Guid.initString("1dcb3a02-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMDevice = &IID_IWMDMDevice_Value;
pub const IWMDMDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetName: fn(
self: *const IWMDMDevice,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetManufacturer: fn(
self: *const IWMDMDevice,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVersion: fn(
self: *const IWMDMDevice,
pdwVersion: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetType: fn(
self: *const IWMDMDevice,
pdwType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSerialNumber: fn(
self: *const IWMDMDevice,
pSerialNumber: ?*WMDMID,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPowerSource: fn(
self: *const IWMDMDevice,
pdwPowerSource: ?*u32,
pdwPercentRemaining: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IWMDMDevice,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceIcon: fn(
self: *const IWMDMDevice,
hIcon: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumStorage: fn(
self: *const IWMDMDevice,
ppEnumStorage: ?*?*IWMDMEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatSupport: fn(
self: *const IWMDMDevice,
ppFormatEx: ?[*]?*_WAVEFORMATEX,
pnFormatCount: ?*u32,
pppwszMimeType: ?[*]?*?PWSTR,
pnMimeTypeCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendOpaqueCommand: fn(
self: *const IWMDMDevice,
pCommand: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetName(@ptrCast(*const IWMDMDevice, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetManufacturer(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetManufacturer(@ptrCast(*const IWMDMDevice, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetVersion(self: *const T, pdwVersion: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetVersion(@ptrCast(*const IWMDMDevice, self), pdwVersion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetType(self: *const T, pdwType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetType(@ptrCast(*const IWMDMDevice, self), pdwType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetSerialNumber(self: *const T, pSerialNumber: ?*WMDMID, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetSerialNumber(@ptrCast(*const IWMDMDevice, self), pSerialNumber, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetPowerSource(self: *const T, pdwPowerSource: ?*u32, pdwPercentRemaining: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetPowerSource(@ptrCast(*const IWMDMDevice, self), pdwPowerSource, pdwPercentRemaining);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetStatus(@ptrCast(*const IWMDMDevice, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetDeviceIcon(self: *const T, hIcon: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetDeviceIcon(@ptrCast(*const IWMDMDevice, self), hIcon);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_EnumStorage(self: *const T, ppEnumStorage: ?*?*IWMDMEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).EnumStorage(@ptrCast(*const IWMDMDevice, self), ppEnumStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_GetFormatSupport(self: *const T, ppFormatEx: ?[*]?*_WAVEFORMATEX, pnFormatCount: ?*u32, pppwszMimeType: ?[*]?*?PWSTR, pnMimeTypeCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).GetFormatSupport(@ptrCast(*const IWMDMDevice, self), ppFormatEx, pnFormatCount, pppwszMimeType, pnMimeTypeCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice_SendOpaqueCommand(self: *const T, pCommand: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice.VTable, self.vtable).SendOpaqueCommand(@ptrCast(*const IWMDMDevice, self), pCommand);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMDevice2_Value = @import("../zig.zig").Guid.initString("e34f3d37-9d67-4fc1-9252-62d28b2f8b55");
pub const IID_IWMDMDevice2 = &IID_IWMDMDevice2_Value;
pub const IWMDMDevice2 = extern struct {
pub const VTable = extern struct {
base: IWMDMDevice.VTable,
GetStorage: fn(
self: *const IWMDMDevice2,
pszStorageName: ?[*:0]const u16,
ppStorage: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatSupport2: fn(
self: *const IWMDMDevice2,
dwFlags: u32,
ppAudioFormatEx: ?[*]?*_WAVEFORMATEX,
pnAudioFormatCount: ?*u32,
ppVideoFormatEx: ?[*]?*_VIDEOINFOHEADER,
pnVideoFormatCount: ?*u32,
ppFileType: ?[*]?*WMFILECAPABILITIES,
pnFileTypeCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpecifyPropertyPages: fn(
self: *const IWMDMDevice2,
ppSpecifyPropPages: ?*?*ISpecifyPropertyPages,
pppUnknowns: ?[*]?*?*IUnknown,
pcUnks: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCanonicalName: fn(
self: *const IWMDMDevice2,
pwszPnPName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMDevice.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice2_GetStorage(self: *const T, pszStorageName: ?[*:0]const u16, ppStorage: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice2.VTable, self.vtable).GetStorage(@ptrCast(*const IWMDMDevice2, self), pszStorageName, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice2_GetFormatSupport2(self: *const T, dwFlags: u32, ppAudioFormatEx: ?[*]?*_WAVEFORMATEX, pnAudioFormatCount: ?*u32, ppVideoFormatEx: ?[*]?*_VIDEOINFOHEADER, pnVideoFormatCount: ?*u32, ppFileType: ?[*]?*WMFILECAPABILITIES, pnFileTypeCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice2.VTable, self.vtable).GetFormatSupport2(@ptrCast(*const IWMDMDevice2, self), dwFlags, ppAudioFormatEx, pnAudioFormatCount, ppVideoFormatEx, pnVideoFormatCount, ppFileType, pnFileTypeCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice2_GetSpecifyPropertyPages(self: *const T, ppSpecifyPropPages: ?*?*ISpecifyPropertyPages, pppUnknowns: ?[*]?*?*IUnknown, pcUnks: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice2.VTable, self.vtable).GetSpecifyPropertyPages(@ptrCast(*const IWMDMDevice2, self), ppSpecifyPropPages, pppUnknowns, pcUnks);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice2_GetCanonicalName(self: *const T, pwszPnPName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice2.VTable, self.vtable).GetCanonicalName(@ptrCast(*const IWMDMDevice2, self), pwszPnPName, nMaxChars);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMDevice3_Value = @import("../zig.zig").Guid.initString("6c03e4fe-05db-4dda-9e3c-06233a6d5d65");
pub const IID_IWMDMDevice3 = &IID_IWMDMDevice3_Value;
pub const IWMDMDevice3 = extern struct {
pub const VTable = extern struct {
base: IWMDMDevice2.VTable,
GetProperty: fn(
self: *const IWMDMDevice3,
pwszPropName: ?[*:0]const u16,
pValue: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetProperty: fn(
self: *const IWMDMDevice3,
pwszPropName: ?[*:0]const u16,
pValue: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatCapability: fn(
self: *const IWMDMDevice3,
format: WMDM_FORMATCODE,
pFormatSupport: ?*WMDM_FORMAT_CAPABILITY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeviceIoControl: fn(
self: *const IWMDMDevice3,
dwIoControlCode: u32,
lpInBuffer: [*:0]u8,
nInBufferSize: u32,
lpOutBuffer: [*:0]u8,
pnOutBufferSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindStorage: fn(
self: *const IWMDMDevice3,
findScope: WMDM_FIND_SCOPE,
pwszUniqueID: ?[*:0]const u16,
ppStorage: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMDevice2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice3_GetProperty(self: *const T, pwszPropName: ?[*:0]const u16, pValue: ?*PROPVARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice3.VTable, self.vtable).GetProperty(@ptrCast(*const IWMDMDevice3, self), pwszPropName, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice3_SetProperty(self: *const T, pwszPropName: ?[*:0]const u16, pValue: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice3.VTable, self.vtable).SetProperty(@ptrCast(*const IWMDMDevice3, self), pwszPropName, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice3_GetFormatCapability(self: *const T, format: WMDM_FORMATCODE, pFormatSupport: ?*WMDM_FORMAT_CAPABILITY) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice3.VTable, self.vtable).GetFormatCapability(@ptrCast(*const IWMDMDevice3, self), format, pFormatSupport);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice3_DeviceIoControl(self: *const T, dwIoControlCode: u32, lpInBuffer: [*:0]u8, nInBufferSize: u32, lpOutBuffer: [*:0]u8, pnOutBufferSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice3.VTable, self.vtable).DeviceIoControl(@ptrCast(*const IWMDMDevice3, self), dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, pnOutBufferSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDevice3_FindStorage(self: *const T, findScope: WMDM_FIND_SCOPE, pwszUniqueID: ?[*:0]const u16, ppStorage: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDevice3.VTable, self.vtable).FindStorage(@ptrCast(*const IWMDMDevice3, self), findScope, pwszUniqueID, ppStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMDeviceSession_Value = @import("../zig.zig").Guid.initString("82af0a65-9d96-412c-83e5-3c43e4b06cc7");
pub const IID_IWMDMDeviceSession = &IID_IWMDMDeviceSession_Value;
pub const IWMDMDeviceSession = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
BeginSession: fn(
self: *const IWMDMDeviceSession,
type: WMDM_SESSION_TYPE,
pCtx: ?[*:0]u8,
dwSizeCtx: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndSession: fn(
self: *const IWMDMDeviceSession,
type: WMDM_SESSION_TYPE,
pCtx: ?[*:0]u8,
dwSizeCtx: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceSession_BeginSession(self: *const T, type_: WMDM_SESSION_TYPE, pCtx: ?[*:0]u8, dwSizeCtx: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceSession.VTable, self.vtable).BeginSession(@ptrCast(*const IWMDMDeviceSession, self), type_, pCtx, dwSizeCtx);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceSession_EndSession(self: *const T, type_: WMDM_SESSION_TYPE, pCtx: ?[*:0]u8, dwSizeCtx: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceSession.VTable, self.vtable).EndSession(@ptrCast(*const IWMDMDeviceSession, self), type_, pCtx, dwSizeCtx);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMEnumDevice_Value = @import("../zig.zig").Guid.initString("1dcb3a01-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMEnumDevice = &IID_IWMDMEnumDevice_Value;
pub const IWMDMEnumDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Next: fn(
self: *const IWMDMEnumDevice,
celt: u32,
ppDevice: [*]?*IWMDMDevice,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IWMDMEnumDevice,
celt: u32,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IWMDMEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IWMDMEnumDevice,
ppEnumDevice: ?*?*IWMDMEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumDevice_Next(self: *const T, celt: u32, ppDevice: [*]?*IWMDMDevice, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumDevice.VTable, self.vtable).Next(@ptrCast(*const IWMDMEnumDevice, self), celt, ppDevice, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumDevice_Skip(self: *const T, celt: u32, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumDevice.VTable, self.vtable).Skip(@ptrCast(*const IWMDMEnumDevice, self), celt, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumDevice_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumDevice.VTable, self.vtable).Reset(@ptrCast(*const IWMDMEnumDevice, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumDevice_Clone(self: *const T, ppEnumDevice: ?*?*IWMDMEnumDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumDevice.VTable, self.vtable).Clone(@ptrCast(*const IWMDMEnumDevice, self), ppEnumDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMDeviceControl_Value = @import("../zig.zig").Guid.initString("1dcb3a04-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMDeviceControl = &IID_IWMDMDeviceControl_Value;
pub const IWMDMDeviceControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetStatus: fn(
self: *const IWMDMDeviceControl,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCapabilities: fn(
self: *const IWMDMDeviceControl,
pdwCapabilitiesMask: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Play: fn(
self: *const IWMDMDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Record: fn(
self: *const IWMDMDeviceControl,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Pause: fn(
self: *const IWMDMDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Resume: fn(
self: *const IWMDMDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stop: fn(
self: *const IWMDMDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Seek: fn(
self: *const IWMDMDeviceControl,
fuMode: u32,
nOffset: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_GetStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).GetStatus(@ptrCast(*const IWMDMDeviceControl, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_GetCapabilities(self: *const T, pdwCapabilitiesMask: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).GetCapabilities(@ptrCast(*const IWMDMDeviceControl, self), pdwCapabilitiesMask);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Play(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Play(@ptrCast(*const IWMDMDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Record(self: *const T, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Record(@ptrCast(*const IWMDMDeviceControl, self), pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Pause(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Pause(@ptrCast(*const IWMDMDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Resume(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Resume(@ptrCast(*const IWMDMDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Stop(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Stop(@ptrCast(*const IWMDMDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMDeviceControl_Seek(self: *const T, fuMode: u32, nOffset: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMDeviceControl.VTable, self.vtable).Seek(@ptrCast(*const IWMDMDeviceControl, self), fuMode, nOffset);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMEnumStorage_Value = @import("../zig.zig").Guid.initString("1dcb3a05-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMEnumStorage = &IID_IWMDMEnumStorage_Value;
pub const IWMDMEnumStorage = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Next: fn(
self: *const IWMDMEnumStorage,
celt: u32,
ppStorage: [*]?*IWMDMStorage,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IWMDMEnumStorage,
celt: u32,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IWMDMEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IWMDMEnumStorage,
ppEnumStorage: ?*?*IWMDMEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumStorage_Next(self: *const T, celt: u32, ppStorage: [*]?*IWMDMStorage, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumStorage.VTable, self.vtable).Next(@ptrCast(*const IWMDMEnumStorage, self), celt, ppStorage, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumStorage_Skip(self: *const T, celt: u32, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumStorage.VTable, self.vtable).Skip(@ptrCast(*const IWMDMEnumStorage, self), celt, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumStorage_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumStorage.VTable, self.vtable).Reset(@ptrCast(*const IWMDMEnumStorage, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMEnumStorage_Clone(self: *const T, ppEnumStorage: ?*?*IWMDMEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMEnumStorage.VTable, self.vtable).Clone(@ptrCast(*const IWMDMEnumStorage, self), ppEnumStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorageControl_Value = @import("../zig.zig").Guid.initString("1dcb3a08-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMStorageControl = &IID_IWMDMStorageControl_Value;
pub const IWMDMStorageControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Insert: fn(
self: *const IWMDMStorageControl,
fuMode: u32,
pwszFile: ?PWSTR,
pOperation: ?*IWMDMOperation,
pProgress: ?*IWMDMProgress,
ppNewObject: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const IWMDMStorageControl,
fuMode: u32,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Rename: fn(
self: *const IWMDMStorageControl,
fuMode: u32,
pwszNewName: ?PWSTR,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Read: fn(
self: *const IWMDMStorageControl,
fuMode: u32,
pwszFile: ?PWSTR,
pProgress: ?*IWMDMProgress,
pOperation: ?*IWMDMOperation,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Move: fn(
self: *const IWMDMStorageControl,
fuMode: u32,
pTargetObject: ?*IWMDMStorage,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl_Insert(self: *const T, fuMode: u32, pwszFile: ?PWSTR, pOperation: ?*IWMDMOperation, pProgress: ?*IWMDMProgress, ppNewObject: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl.VTable, self.vtable).Insert(@ptrCast(*const IWMDMStorageControl, self), fuMode, pwszFile, pOperation, pProgress, ppNewObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl_Delete(self: *const T, fuMode: u32, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl.VTable, self.vtable).Delete(@ptrCast(*const IWMDMStorageControl, self), fuMode, pProgress);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl_Rename(self: *const T, fuMode: u32, pwszNewName: ?PWSTR, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl.VTable, self.vtable).Rename(@ptrCast(*const IWMDMStorageControl, self), fuMode, pwszNewName, pProgress);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl_Read(self: *const T, fuMode: u32, pwszFile: ?PWSTR, pProgress: ?*IWMDMProgress, pOperation: ?*IWMDMOperation) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl.VTable, self.vtable).Read(@ptrCast(*const IWMDMStorageControl, self), fuMode, pwszFile, pProgress, pOperation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl_Move(self: *const T, fuMode: u32, pTargetObject: ?*IWMDMStorage, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl.VTable, self.vtable).Move(@ptrCast(*const IWMDMStorageControl, self), fuMode, pTargetObject, pProgress);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorageControl2_Value = @import("../zig.zig").Guid.initString("972c2e88-bd6c-4125-8e09-84f837e637b6");
pub const IID_IWMDMStorageControl2 = &IID_IWMDMStorageControl2_Value;
pub const IWMDMStorageControl2 = extern struct {
pub const VTable = extern struct {
base: IWMDMStorageControl.VTable,
Insert2: fn(
self: *const IWMDMStorageControl2,
fuMode: u32,
pwszFileSource: ?PWSTR,
pwszFileDest: ?PWSTR,
pOperation: ?*IWMDMOperation,
pProgress: ?*IWMDMProgress,
pUnknown: ?*IUnknown,
ppNewObject: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMStorageControl.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl2_Insert2(self: *const T, fuMode: u32, pwszFileSource: ?PWSTR, pwszFileDest: ?PWSTR, pOperation: ?*IWMDMOperation, pProgress: ?*IWMDMProgress, pUnknown: ?*IUnknown, ppNewObject: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl2.VTable, self.vtable).Insert2(@ptrCast(*const IWMDMStorageControl2, self), fuMode, pwszFileSource, pwszFileDest, pOperation, pProgress, pUnknown, ppNewObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMStorageControl3_Value = @import("../zig.zig").Guid.initString("b3266365-d4f3-4696-8d53-bd27ec60993a");
pub const IID_IWMDMStorageControl3 = &IID_IWMDMStorageControl3_Value;
pub const IWMDMStorageControl3 = extern struct {
pub const VTable = extern struct {
base: IWMDMStorageControl2.VTable,
Insert3: fn(
self: *const IWMDMStorageControl3,
fuMode: u32,
fuType: u32,
pwszFileSource: ?PWSTR,
pwszFileDest: ?PWSTR,
pOperation: ?*IWMDMOperation,
pProgress: ?*IWMDMProgress,
pMetaData: ?*IWMDMMetaData,
pUnknown: ?*IUnknown,
ppNewObject: ?*?*IWMDMStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWMDMStorageControl2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMStorageControl3_Insert3(self: *const T, fuMode: u32, fuType: u32, pwszFileSource: ?PWSTR, pwszFileDest: ?PWSTR, pOperation: ?*IWMDMOperation, pProgress: ?*IWMDMProgress, pMetaData: ?*IWMDMMetaData, pUnknown: ?*IUnknown, ppNewObject: ?*?*IWMDMStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMStorageControl3.VTable, self.vtable).Insert3(@ptrCast(*const IWMDMStorageControl3, self), fuMode, fuType, pwszFileSource, pwszFileDest, pOperation, pProgress, pMetaData, pUnknown, ppNewObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMObjectInfo_Value = @import("../zig.zig").Guid.initString("1dcb3a09-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IWMDMObjectInfo = &IID_IWMDMObjectInfo_Value;
pub const IWMDMObjectInfo = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetPlayLength: fn(
self: *const IWMDMObjectInfo,
pdwLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPlayLength: fn(
self: *const IWMDMObjectInfo,
dwLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPlayOffset: fn(
self: *const IWMDMObjectInfo,
pdwOffset: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPlayOffset: fn(
self: *const IWMDMObjectInfo,
dwOffset: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalLength: fn(
self: *const IWMDMObjectInfo,
pdwLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLastPlayPosition: fn(
self: *const IWMDMObjectInfo,
pdwLastPos: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLongestPlayPosition: fn(
self: *const IWMDMObjectInfo,
pdwLongestPos: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_GetPlayLength(self: *const T, pdwLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).GetPlayLength(@ptrCast(*const IWMDMObjectInfo, self), pdwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_SetPlayLength(self: *const T, dwLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).SetPlayLength(@ptrCast(*const IWMDMObjectInfo, self), dwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_GetPlayOffset(self: *const T, pdwOffset: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).GetPlayOffset(@ptrCast(*const IWMDMObjectInfo, self), pdwOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_SetPlayOffset(self: *const T, dwOffset: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).SetPlayOffset(@ptrCast(*const IWMDMObjectInfo, self), dwOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_GetTotalLength(self: *const T, pdwLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).GetTotalLength(@ptrCast(*const IWMDMObjectInfo, self), pdwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_GetLastPlayPosition(self: *const T, pdwLastPos: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).GetLastPlayPosition(@ptrCast(*const IWMDMObjectInfo, self), pdwLastPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMObjectInfo_GetLongestPlayPosition(self: *const T, pdwLongestPos: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMObjectInfo.VTable, self.vtable).GetLongestPlayPosition(@ptrCast(*const IWMDMObjectInfo, self), pdwLongestPos);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMRevoked_Value = @import("../zig.zig").Guid.initString("ebeccedb-88ee-4e55-b6a4-8d9f07d696aa");
pub const IID_IWMDMRevoked = &IID_IWMDMRevoked_Value;
pub const IWMDMRevoked = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRevocationURL: fn(
self: *const IWMDMRevoked,
ppwszRevocationURL: ?[*]?PWSTR,
pdwBufferLen: ?*u32,
pdwRevokedBitFlag: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMRevoked_GetRevocationURL(self: *const T, ppwszRevocationURL: ?[*]?PWSTR, pdwBufferLen: ?*u32, pdwRevokedBitFlag: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMRevoked.VTable, self.vtable).GetRevocationURL(@ptrCast(*const IWMDMRevoked, self), ppwszRevocationURL, pdwBufferLen, pdwRevokedBitFlag);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWMDMNotification_Value = @import("../zig.zig").Guid.initString("3f5e95c0-0f43-4ed4-93d2-c89a45d59b81");
pub const IID_IWMDMNotification = &IID_IWMDMNotification_Value;
pub const IWMDMNotification = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
WMDMMessage: fn(
self: *const IWMDMNotification,
dwMessageType: u32,
pwszCanonicalName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMNotification_WMDMMessage(self: *const T, dwMessageType: u32, pwszCanonicalName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMNotification.VTable, self.vtable).WMDMMessage(@ptrCast(*const IWMDMNotification, self), dwMessageType, pwszCanonicalName);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WMDMDetermineMaxPropStringLen = extern union {
sz001: [27]u16,
sz002: [31]u16,
sz003: [14]u16,
sz004: [16]u16,
sz005: [22]u16,
sz006: [14]u16,
sz007: [20]u16,
sz008: [20]u16,
sz009: [22]u16,
sz010: [11]u16,
sz011: [12]u16,
sz012: [17]u16,
sz013: [17]u16,
sz014: [16]u16,
sz015: [17]u16,
sz016: [11]u16,
sz017: [11]u16,
sz018: [15]u16,
sz019: [22]u16,
sz020: [20]u16,
sz021: [22]u16,
sz022: [21]u16,
sz023: [24]u16,
sz024: [20]u16,
sz025: [10]u16,
sz026: [14]u16,
sz027: [11]u16,
sz028: [11]u16,
sz029: [13]u16,
sz030: [17]u16,
sz031: [16]u16,
sz032: [17]u16,
sz033: [20]u16,
sz034: [19]u16,
sz035: [18]u16,
sz036: [18]u16,
sz037: [15]u16,
sz041: [14]u16,
sz043: [22]u16,
sz044: [16]u16,
sz045: [20]u16,
sz046: [14]u16,
sz047: [14]u16,
sz048: [12]u16,
sz049: [25]u16,
sz050: [26]u16,
sz051: [25]u16,
sz052: [16]u16,
sz053: [24]u16,
sz054: [15]u16,
sz055: [21]u16,
sz056: [16]u16,
sz057: [22]u16,
sz058: [14]u16,
sz059: [25]u16,
sz060: [18]u16,
sz061: [22]u16,
sz062: [26]u16,
sz063: [36]u16,
sz064: [23]u16,
sz065: [12]u16,
sz066: [24]u16,
sz067: [11]u16,
sz068: [12]u16,
sz069: [14]u16,
sz070: [20]u16,
sz071: [15]u16,
sz072: [14]u16,
sz073: [31]u16,
sz074: [24]u16,
sz075: [22]u16,
sz076: [24]u16,
sz077: [21]u16,
sz078: [27]u16,
sz079: [27]u16,
sz080: [20]u16,
sz081: [33]u16,
sz082: [21]u16,
sz083: [32]u16,
sz084: [26]u16,
sz085: [18]u16,
sz086: [30]u16,
};
const IID_IMDServiceProvider_Value = @import("../zig.zig").Guid.initString("1dcb3a10-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDServiceProvider = &IID_IMDServiceProvider_Value;
pub const IMDServiceProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDeviceCount: fn(
self: *const IMDServiceProvider,
pdwCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumDevices: fn(
self: *const IMDServiceProvider,
ppEnumDevice: ?*?*IMDSPEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDServiceProvider_GetDeviceCount(self: *const T, pdwCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDServiceProvider.VTable, self.vtable).GetDeviceCount(@ptrCast(*const IMDServiceProvider, self), pdwCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDServiceProvider_EnumDevices(self: *const T, ppEnumDevice: ?*?*IMDSPEnumDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDServiceProvider.VTable, self.vtable).EnumDevices(@ptrCast(*const IMDServiceProvider, self), ppEnumDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDServiceProvider2_Value = @import("../zig.zig").Guid.initString("b2fa24b7-cda3-4694-9862-413ae1a34819");
pub const IID_IMDServiceProvider2 = &IID_IMDServiceProvider2_Value;
pub const IMDServiceProvider2 = extern struct {
pub const VTable = extern struct {
base: IMDServiceProvider.VTable,
CreateDevice: fn(
self: *const IMDServiceProvider2,
pwszDevicePath: ?[*:0]const u16,
pdwCount: ?*u32,
pppDeviceArray: ?[*]?*?*IMDSPDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDServiceProvider.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDServiceProvider2_CreateDevice(self: *const T, pwszDevicePath: ?[*:0]const u16, pdwCount: ?*u32, pppDeviceArray: ?[*]?*?*IMDSPDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDServiceProvider2.VTable, self.vtable).CreateDevice(@ptrCast(*const IMDServiceProvider2, self), pwszDevicePath, pdwCount, pppDeviceArray);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDServiceProvider3_Value = @import("../zig.zig").Guid.initString("4ed13ef3-a971-4d19-9f51-0e1826b2da57");
pub const IID_IMDServiceProvider3 = &IID_IMDServiceProvider3_Value;
pub const IMDServiceProvider3 = extern struct {
pub const VTable = extern struct {
base: IMDServiceProvider2.VTable,
SetDeviceEnumPreference: fn(
self: *const IMDServiceProvider3,
dwEnumPref: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDServiceProvider2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDServiceProvider3_SetDeviceEnumPreference(self: *const T, dwEnumPref: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDServiceProvider3.VTable, self.vtable).SetDeviceEnumPreference(@ptrCast(*const IMDServiceProvider3, self), dwEnumPref);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPEnumDevice_Value = @import("../zig.zig").Guid.initString("1dcb3a11-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPEnumDevice = &IID_IMDSPEnumDevice_Value;
pub const IMDSPEnumDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Next: fn(
self: *const IMDSPEnumDevice,
celt: u32,
ppDevice: [*]?*IMDSPDevice,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IMDSPEnumDevice,
celt: u32,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IMDSPEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IMDSPEnumDevice,
ppEnumDevice: ?*?*IMDSPEnumDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumDevice_Next(self: *const T, celt: u32, ppDevice: [*]?*IMDSPDevice, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumDevice.VTable, self.vtable).Next(@ptrCast(*const IMDSPEnumDevice, self), celt, ppDevice, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumDevice_Skip(self: *const T, celt: u32, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumDevice.VTable, self.vtable).Skip(@ptrCast(*const IMDSPEnumDevice, self), celt, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumDevice_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumDevice.VTable, self.vtable).Reset(@ptrCast(*const IMDSPEnumDevice, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumDevice_Clone(self: *const T, ppEnumDevice: ?*?*IMDSPEnumDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumDevice.VTable, self.vtable).Clone(@ptrCast(*const IMDSPEnumDevice, self), ppEnumDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPDevice_Value = @import("../zig.zig").Guid.initString("1dcb3a12-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPDevice = &IID_IMDSPDevice_Value;
pub const IMDSPDevice = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetName: fn(
self: *const IMDSPDevice,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetManufacturer: fn(
self: *const IMDSPDevice,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVersion: fn(
self: *const IMDSPDevice,
pdwVersion: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetType: fn(
self: *const IMDSPDevice,
pdwType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSerialNumber: fn(
self: *const IMDSPDevice,
pSerialNumber: ?*WMDMID,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPowerSource: fn(
self: *const IMDSPDevice,
pdwPowerSource: ?*u32,
pdwPercentRemaining: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IMDSPDevice,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDeviceIcon: fn(
self: *const IMDSPDevice,
hIcon: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumStorage: fn(
self: *const IMDSPDevice,
ppEnumStorage: ?*?*IMDSPEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatSupport: fn(
self: *const IMDSPDevice,
pFormatEx: ?[*]?*_WAVEFORMATEX,
pnFormatCount: ?*u32,
pppwszMimeType: ?[*]?*?PWSTR,
pnMimeTypeCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendOpaqueCommand: fn(
self: *const IMDSPDevice,
pCommand: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetName(@ptrCast(*const IMDSPDevice, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetManufacturer(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetManufacturer(@ptrCast(*const IMDSPDevice, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetVersion(self: *const T, pdwVersion: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetVersion(@ptrCast(*const IMDSPDevice, self), pdwVersion);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetType(self: *const T, pdwType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetType(@ptrCast(*const IMDSPDevice, self), pdwType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetSerialNumber(self: *const T, pSerialNumber: ?*WMDMID, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetSerialNumber(@ptrCast(*const IMDSPDevice, self), pSerialNumber, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetPowerSource(self: *const T, pdwPowerSource: ?*u32, pdwPercentRemaining: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetPowerSource(@ptrCast(*const IMDSPDevice, self), pdwPowerSource, pdwPercentRemaining);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetStatus(@ptrCast(*const IMDSPDevice, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetDeviceIcon(self: *const T, hIcon: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetDeviceIcon(@ptrCast(*const IMDSPDevice, self), hIcon);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_EnumStorage(self: *const T, ppEnumStorage: ?*?*IMDSPEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).EnumStorage(@ptrCast(*const IMDSPDevice, self), ppEnumStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_GetFormatSupport(self: *const T, pFormatEx: ?[*]?*_WAVEFORMATEX, pnFormatCount: ?*u32, pppwszMimeType: ?[*]?*?PWSTR, pnMimeTypeCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).GetFormatSupport(@ptrCast(*const IMDSPDevice, self), pFormatEx, pnFormatCount, pppwszMimeType, pnMimeTypeCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice_SendOpaqueCommand(self: *const T, pCommand: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice.VTable, self.vtable).SendOpaqueCommand(@ptrCast(*const IMDSPDevice, self), pCommand);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPDevice2_Value = @import("../zig.zig").Guid.initString("420d16ad-c97d-4e00-82aa-00e9f4335ddd");
pub const IID_IMDSPDevice2 = &IID_IMDSPDevice2_Value;
pub const IMDSPDevice2 = extern struct {
pub const VTable = extern struct {
base: IMDSPDevice.VTable,
GetStorage: fn(
self: *const IMDSPDevice2,
pszStorageName: ?[*:0]const u16,
ppStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatSupport2: fn(
self: *const IMDSPDevice2,
dwFlags: u32,
ppAudioFormatEx: ?[*]?*_WAVEFORMATEX,
pnAudioFormatCount: ?*u32,
ppVideoFormatEx: ?[*]?*_VIDEOINFOHEADER,
pnVideoFormatCount: ?*u32,
ppFileType: ?[*]?*WMFILECAPABILITIES,
pnFileTypeCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpecifyPropertyPages: fn(
self: *const IMDSPDevice2,
ppSpecifyPropPages: ?*?*ISpecifyPropertyPages,
pppUnknowns: ?[*]?*?*IUnknown,
pcUnks: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCanonicalName: fn(
self: *const IMDSPDevice2,
pwszPnPName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPDevice.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice2_GetStorage(self: *const T, pszStorageName: ?[*:0]const u16, ppStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice2.VTable, self.vtable).GetStorage(@ptrCast(*const IMDSPDevice2, self), pszStorageName, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice2_GetFormatSupport2(self: *const T, dwFlags: u32, ppAudioFormatEx: ?[*]?*_WAVEFORMATEX, pnAudioFormatCount: ?*u32, ppVideoFormatEx: ?[*]?*_VIDEOINFOHEADER, pnVideoFormatCount: ?*u32, ppFileType: ?[*]?*WMFILECAPABILITIES, pnFileTypeCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice2.VTable, self.vtable).GetFormatSupport2(@ptrCast(*const IMDSPDevice2, self), dwFlags, ppAudioFormatEx, pnAudioFormatCount, ppVideoFormatEx, pnVideoFormatCount, ppFileType, pnFileTypeCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice2_GetSpecifyPropertyPages(self: *const T, ppSpecifyPropPages: ?*?*ISpecifyPropertyPages, pppUnknowns: ?[*]?*?*IUnknown, pcUnks: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice2.VTable, self.vtable).GetSpecifyPropertyPages(@ptrCast(*const IMDSPDevice2, self), ppSpecifyPropPages, pppUnknowns, pcUnks);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice2_GetCanonicalName(self: *const T, pwszPnPName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice2.VTable, self.vtable).GetCanonicalName(@ptrCast(*const IMDSPDevice2, self), pwszPnPName, nMaxChars);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPDevice3_Value = @import("../zig.zig").Guid.initString("1a839845-fc55-487c-976f-ee38ac0e8c4e");
pub const IID_IMDSPDevice3 = &IID_IMDSPDevice3_Value;
pub const IMDSPDevice3 = extern struct {
pub const VTable = extern struct {
base: IMDSPDevice2.VTable,
GetProperty: fn(
self: *const IMDSPDevice3,
pwszPropName: ?[*:0]const u16,
pValue: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetProperty: fn(
self: *const IMDSPDevice3,
pwszPropName: ?[*:0]const u16,
pValue: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFormatCapability: fn(
self: *const IMDSPDevice3,
format: WMDM_FORMATCODE,
pFormatSupport: ?*WMDM_FORMAT_CAPABILITY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeviceIoControl: fn(
self: *const IMDSPDevice3,
dwIoControlCode: u32,
lpInBuffer: [*:0]u8,
nInBufferSize: u32,
lpOutBuffer: [*:0]u8,
pnOutBufferSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindStorage: fn(
self: *const IMDSPDevice3,
findScope: WMDM_FIND_SCOPE,
pwszUniqueID: ?[*:0]const u16,
ppStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPDevice2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice3_GetProperty(self: *const T, pwszPropName: ?[*:0]const u16, pValue: ?*PROPVARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice3.VTable, self.vtable).GetProperty(@ptrCast(*const IMDSPDevice3, self), pwszPropName, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice3_SetProperty(self: *const T, pwszPropName: ?[*:0]const u16, pValue: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice3.VTable, self.vtable).SetProperty(@ptrCast(*const IMDSPDevice3, self), pwszPropName, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice3_GetFormatCapability(self: *const T, format: WMDM_FORMATCODE, pFormatSupport: ?*WMDM_FORMAT_CAPABILITY) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice3.VTable, self.vtable).GetFormatCapability(@ptrCast(*const IMDSPDevice3, self), format, pFormatSupport);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice3_DeviceIoControl(self: *const T, dwIoControlCode: u32, lpInBuffer: [*:0]u8, nInBufferSize: u32, lpOutBuffer: [*:0]u8, pnOutBufferSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice3.VTable, self.vtable).DeviceIoControl(@ptrCast(*const IMDSPDevice3, self), dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, pnOutBufferSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDevice3_FindStorage(self: *const T, findScope: WMDM_FIND_SCOPE, pwszUniqueID: ?[*:0]const u16, ppStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDevice3.VTable, self.vtable).FindStorage(@ptrCast(*const IMDSPDevice3, self), findScope, pwszUniqueID, ppStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPDeviceControl_Value = @import("../zig.zig").Guid.initString("1dcb3a14-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPDeviceControl = &IID_IMDSPDeviceControl_Value;
pub const IMDSPDeviceControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDCStatus: fn(
self: *const IMDSPDeviceControl,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCapabilities: fn(
self: *const IMDSPDeviceControl,
pdwCapabilitiesMask: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Play: fn(
self: *const IMDSPDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Record: fn(
self: *const IMDSPDeviceControl,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Pause: fn(
self: *const IMDSPDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Resume: fn(
self: *const IMDSPDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stop: fn(
self: *const IMDSPDeviceControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Seek: fn(
self: *const IMDSPDeviceControl,
fuMode: u32,
nOffset: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_GetDCStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).GetDCStatus(@ptrCast(*const IMDSPDeviceControl, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_GetCapabilities(self: *const T, pdwCapabilitiesMask: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).GetCapabilities(@ptrCast(*const IMDSPDeviceControl, self), pdwCapabilitiesMask);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Play(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Play(@ptrCast(*const IMDSPDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Record(self: *const T, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Record(@ptrCast(*const IMDSPDeviceControl, self), pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Pause(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Pause(@ptrCast(*const IMDSPDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Resume(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Resume(@ptrCast(*const IMDSPDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Stop(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Stop(@ptrCast(*const IMDSPDeviceControl, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDeviceControl_Seek(self: *const T, fuMode: u32, nOffset: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDeviceControl.VTable, self.vtable).Seek(@ptrCast(*const IMDSPDeviceControl, self), fuMode, nOffset);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPEnumStorage_Value = @import("../zig.zig").Guid.initString("1dcb3a15-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPEnumStorage = &IID_IMDSPEnumStorage_Value;
pub const IMDSPEnumStorage = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Next: fn(
self: *const IMDSPEnumStorage,
celt: u32,
ppStorage: [*]?*IMDSPStorage,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IMDSPEnumStorage,
celt: u32,
pceltFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IMDSPEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IMDSPEnumStorage,
ppEnumStorage: ?*?*IMDSPEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumStorage_Next(self: *const T, celt: u32, ppStorage: [*]?*IMDSPStorage, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumStorage.VTable, self.vtable).Next(@ptrCast(*const IMDSPEnumStorage, self), celt, ppStorage, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumStorage_Skip(self: *const T, celt: u32, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumStorage.VTable, self.vtable).Skip(@ptrCast(*const IMDSPEnumStorage, self), celt, pceltFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumStorage_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumStorage.VTable, self.vtable).Reset(@ptrCast(*const IMDSPEnumStorage, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPEnumStorage_Clone(self: *const T, ppEnumStorage: ?*?*IMDSPEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPEnumStorage.VTable, self.vtable).Clone(@ptrCast(*const IMDSPEnumStorage, self), ppEnumStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPStorage_Value = @import("../zig.zig").Guid.initString("1dcb3a16-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPStorage = &IID_IMDSPStorage_Value;
pub const IMDSPStorage = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetAttributes: fn(
self: *const IMDSPStorage,
dwAttributes: u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStorageGlobals: fn(
self: *const IMDSPStorage,
ppStorageGlobals: ?*?*IMDSPStorageGlobals,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributes: fn(
self: *const IMDSPStorage,
pdwAttributes: ?*u32,
pFormat: ?*_WAVEFORMATEX,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetName: fn(
self: *const IMDSPStorage,
pwszName: [*:0]u16,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDate: fn(
self: *const IMDSPStorage,
pDateTimeUTC: ?*WMDMDATETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSize: fn(
self: *const IMDSPStorage,
pdwSizeLow: ?*u32,
pdwSizeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRights: fn(
self: *const IMDSPStorage,
ppRights: ?[*]?*WMDMRIGHTS,
pnRightsCount: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStorage: fn(
self: *const IMDSPStorage,
dwAttributes: u32,
pFormat: ?*_WAVEFORMATEX,
pwszName: ?PWSTR,
ppNewStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumStorage: fn(
self: *const IMDSPStorage,
ppEnumStorage: ?*?*IMDSPEnumStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendOpaqueCommand: fn(
self: *const IMDSPStorage,
pCommand: ?*OPAQUECOMMAND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_SetAttributes(self: *const T, dwAttributes: u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).SetAttributes(@ptrCast(*const IMDSPStorage, self), dwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetStorageGlobals(self: *const T, ppStorageGlobals: ?*?*IMDSPStorageGlobals) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetStorageGlobals(@ptrCast(*const IMDSPStorage, self), ppStorageGlobals);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetAttributes(self: *const T, pdwAttributes: ?*u32, pFormat: ?*_WAVEFORMATEX) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetAttributes(@ptrCast(*const IMDSPStorage, self), pdwAttributes, pFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetName(self: *const T, pwszName: [*:0]u16, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetName(@ptrCast(*const IMDSPStorage, self), pwszName, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetDate(self: *const T, pDateTimeUTC: ?*WMDMDATETIME) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetDate(@ptrCast(*const IMDSPStorage, self), pDateTimeUTC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetSize(self: *const T, pdwSizeLow: ?*u32, pdwSizeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetSize(@ptrCast(*const IMDSPStorage, self), pdwSizeLow, pdwSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_GetRights(self: *const T, ppRights: ?[*]?*WMDMRIGHTS, pnRightsCount: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).GetRights(@ptrCast(*const IMDSPStorage, self), ppRights, pnRightsCount, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_CreateStorage(self: *const T, dwAttributes: u32, pFormat: ?*_WAVEFORMATEX, pwszName: ?PWSTR, ppNewStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).CreateStorage(@ptrCast(*const IMDSPStorage, self), dwAttributes, pFormat, pwszName, ppNewStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_EnumStorage(self: *const T, ppEnumStorage: ?*?*IMDSPEnumStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).EnumStorage(@ptrCast(*const IMDSPStorage, self), ppEnumStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage_SendOpaqueCommand(self: *const T, pCommand: ?*OPAQUECOMMAND) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage.VTable, self.vtable).SendOpaqueCommand(@ptrCast(*const IMDSPStorage, self), pCommand);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPStorage2_Value = @import("../zig.zig").Guid.initString("0a5e07a5-6454-4451-9c36-1c6ae7e2b1d6");
pub const IID_IMDSPStorage2 = &IID_IMDSPStorage2_Value;
pub const IMDSPStorage2 = extern struct {
pub const VTable = extern struct {
base: IMDSPStorage.VTable,
GetStorage: fn(
self: *const IMDSPStorage2,
pszStorageName: ?[*:0]const u16,
ppStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStorage2: fn(
self: *const IMDSPStorage2,
dwAttributes: u32,
dwAttributesEx: u32,
pAudioFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
pwszName: ?PWSTR,
qwFileSize: u64,
ppNewStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAttributes2: fn(
self: *const IMDSPStorage2,
dwAttributes: u32,
dwAttributesEx: u32,
pAudioFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributes2: fn(
self: *const IMDSPStorage2,
pdwAttributes: ?*u32,
pdwAttributesEx: ?*u32,
pAudioFormat: ?*_WAVEFORMATEX,
pVideoFormat: ?*_VIDEOINFOHEADER,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPStorage.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage2_GetStorage(self: *const T, pszStorageName: ?[*:0]const u16, ppStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage2.VTable, self.vtable).GetStorage(@ptrCast(*const IMDSPStorage2, self), pszStorageName, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage2_CreateStorage2(self: *const T, dwAttributes: u32, dwAttributesEx: u32, pAudioFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER, pwszName: ?PWSTR, qwFileSize: u64, ppNewStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage2.VTable, self.vtable).CreateStorage2(@ptrCast(*const IMDSPStorage2, self), dwAttributes, dwAttributesEx, pAudioFormat, pVideoFormat, pwszName, qwFileSize, ppNewStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage2_SetAttributes2(self: *const T, dwAttributes: u32, dwAttributesEx: u32, pAudioFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage2.VTable, self.vtable).SetAttributes2(@ptrCast(*const IMDSPStorage2, self), dwAttributes, dwAttributesEx, pAudioFormat, pVideoFormat);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage2_GetAttributes2(self: *const T, pdwAttributes: ?*u32, pdwAttributesEx: ?*u32, pAudioFormat: ?*_WAVEFORMATEX, pVideoFormat: ?*_VIDEOINFOHEADER) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage2.VTable, self.vtable).GetAttributes2(@ptrCast(*const IMDSPStorage2, self), pdwAttributes, pdwAttributesEx, pAudioFormat, pVideoFormat);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPStorage3_Value = @import("../zig.zig").Guid.initString("6c669867-97ed-4a67-9706-1c5529d2a414");
pub const IID_IMDSPStorage3 = &IID_IMDSPStorage3_Value;
pub const IMDSPStorage3 = extern struct {
pub const VTable = extern struct {
base: IMDSPStorage2.VTable,
GetMetadata: fn(
self: *const IMDSPStorage3,
pMetadata: ?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMetadata: fn(
self: *const IMDSPStorage3,
pMetadata: ?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPStorage2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage3_GetMetadata(self: *const T, pMetadata: ?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage3.VTable, self.vtable).GetMetadata(@ptrCast(*const IMDSPStorage3, self), pMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage3_SetMetadata(self: *const T, pMetadata: ?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage3.VTable, self.vtable).SetMetadata(@ptrCast(*const IMDSPStorage3, self), pMetadata);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPStorage4_Value = @import("../zig.zig").Guid.initString("3133b2c4-515c-481b-b1ce-39327ecb4f74");
pub const IID_IMDSPStorage4 = &IID_IMDSPStorage4_Value;
pub const IMDSPStorage4 = extern struct {
pub const VTable = extern struct {
base: IMDSPStorage3.VTable,
SetReferences: fn(
self: *const IMDSPStorage4,
dwRefs: u32,
ppISPStorage: ?[*]?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetReferences: fn(
self: *const IMDSPStorage4,
pdwRefs: ?*u32,
pppISPStorage: ?[*]?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStorageWithMetadata: fn(
self: *const IMDSPStorage4,
dwAttributes: u32,
pwszName: ?[*:0]const u16,
pMetadata: ?*IWMDMMetaData,
qwFileSize: u64,
ppNewStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpecifiedMetadata: fn(
self: *const IMDSPStorage4,
cProperties: u32,
ppwszPropNames: [*]?PWSTR,
pMetadata: ?*IWMDMMetaData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindStorage: fn(
self: *const IMDSPStorage4,
findScope: WMDM_FIND_SCOPE,
pwszUniqueID: ?[*:0]const u16,
ppStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetParent: fn(
self: *const IMDSPStorage4,
ppStorage: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPStorage3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_SetReferences(self: *const T, dwRefs: u32, ppISPStorage: ?[*]?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).SetReferences(@ptrCast(*const IMDSPStorage4, self), dwRefs, ppISPStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_GetReferences(self: *const T, pdwRefs: ?*u32, pppISPStorage: ?[*]?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).GetReferences(@ptrCast(*const IMDSPStorage4, self), pdwRefs, pppISPStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_CreateStorageWithMetadata(self: *const T, dwAttributes: u32, pwszName: ?[*:0]const u16, pMetadata: ?*IWMDMMetaData, qwFileSize: u64, ppNewStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).CreateStorageWithMetadata(@ptrCast(*const IMDSPStorage4, self), dwAttributes, pwszName, pMetadata, qwFileSize, ppNewStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_GetSpecifiedMetadata(self: *const T, cProperties: u32, ppwszPropNames: [*]?PWSTR, pMetadata: ?*IWMDMMetaData) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).GetSpecifiedMetadata(@ptrCast(*const IMDSPStorage4, self), cProperties, ppwszPropNames, pMetadata);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_FindStorage(self: *const T, findScope: WMDM_FIND_SCOPE, pwszUniqueID: ?[*:0]const u16, ppStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).FindStorage(@ptrCast(*const IMDSPStorage4, self), findScope, pwszUniqueID, ppStorage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorage4_GetParent(self: *const T, ppStorage: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorage4.VTable, self.vtable).GetParent(@ptrCast(*const IMDSPStorage4, self), ppStorage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPStorageGlobals_Value = @import("../zig.zig").Guid.initString("1dcb3a17-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPStorageGlobals = &IID_IMDSPStorageGlobals_Value;
pub const IMDSPStorageGlobals = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCapabilities: fn(
self: *const IMDSPStorageGlobals,
pdwCapabilities: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSerialNumber: fn(
self: *const IMDSPStorageGlobals,
pSerialNum: ?*WMDMID,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalSize: fn(
self: *const IMDSPStorageGlobals,
pdwTotalSizeLow: ?*u32,
pdwTotalSizeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalFree: fn(
self: *const IMDSPStorageGlobals,
pdwFreeLow: ?*u32,
pdwFreeHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalBad: fn(
self: *const IMDSPStorageGlobals,
pdwBadLow: ?*u32,
pdwBadHigh: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatus: fn(
self: *const IMDSPStorageGlobals,
pdwStatus: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Initialize: fn(
self: *const IMDSPStorageGlobals,
fuMode: u32,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDevice: fn(
self: *const IMDSPStorageGlobals,
ppDevice: ?*?*IMDSPDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRootStorage: fn(
self: *const IMDSPStorageGlobals,
ppRoot: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetCapabilities(self: *const T, pdwCapabilities: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetCapabilities(@ptrCast(*const IMDSPStorageGlobals, self), pdwCapabilities);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetSerialNumber(self: *const T, pSerialNum: ?*WMDMID, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetSerialNumber(@ptrCast(*const IMDSPStorageGlobals, self), pSerialNum, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetTotalSize(self: *const T, pdwTotalSizeLow: ?*u32, pdwTotalSizeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetTotalSize(@ptrCast(*const IMDSPStorageGlobals, self), pdwTotalSizeLow, pdwTotalSizeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetTotalFree(self: *const T, pdwFreeLow: ?*u32, pdwFreeHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetTotalFree(@ptrCast(*const IMDSPStorageGlobals, self), pdwFreeLow, pdwFreeHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetTotalBad(self: *const T, pdwBadLow: ?*u32, pdwBadHigh: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetTotalBad(@ptrCast(*const IMDSPStorageGlobals, self), pdwBadLow, pdwBadHigh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetStatus(self: *const T, pdwStatus: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetStatus(@ptrCast(*const IMDSPStorageGlobals, self), pdwStatus);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_Initialize(self: *const T, fuMode: u32, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).Initialize(@ptrCast(*const IMDSPStorageGlobals, self), fuMode, pProgress);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetDevice(self: *const T, ppDevice: ?*?*IMDSPDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetDevice(@ptrCast(*const IMDSPStorageGlobals, self), ppDevice);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPStorageGlobals_GetRootStorage(self: *const T, ppRoot: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPStorageGlobals.VTable, self.vtable).GetRootStorage(@ptrCast(*const IMDSPStorageGlobals, self), ppRoot);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPObjectInfo_Value = @import("../zig.zig").Guid.initString("1dcb3a19-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPObjectInfo = &IID_IMDSPObjectInfo_Value;
pub const IMDSPObjectInfo = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetPlayLength: fn(
self: *const IMDSPObjectInfo,
pdwLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPlayLength: fn(
self: *const IMDSPObjectInfo,
dwLength: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPlayOffset: fn(
self: *const IMDSPObjectInfo,
pdwOffset: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPlayOffset: fn(
self: *const IMDSPObjectInfo,
dwOffset: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTotalLength: fn(
self: *const IMDSPObjectInfo,
pdwLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLastPlayPosition: fn(
self: *const IMDSPObjectInfo,
pdwLastPos: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLongestPlayPosition: fn(
self: *const IMDSPObjectInfo,
pdwLongestPos: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_GetPlayLength(self: *const T, pdwLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).GetPlayLength(@ptrCast(*const IMDSPObjectInfo, self), pdwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_SetPlayLength(self: *const T, dwLength: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).SetPlayLength(@ptrCast(*const IMDSPObjectInfo, self), dwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_GetPlayOffset(self: *const T, pdwOffset: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).GetPlayOffset(@ptrCast(*const IMDSPObjectInfo, self), pdwOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_SetPlayOffset(self: *const T, dwOffset: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).SetPlayOffset(@ptrCast(*const IMDSPObjectInfo, self), dwOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_GetTotalLength(self: *const T, pdwLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).GetTotalLength(@ptrCast(*const IMDSPObjectInfo, self), pdwLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_GetLastPlayPosition(self: *const T, pdwLastPos: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).GetLastPlayPosition(@ptrCast(*const IMDSPObjectInfo, self), pdwLastPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObjectInfo_GetLongestPlayPosition(self: *const T, pdwLongestPos: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObjectInfo.VTable, self.vtable).GetLongestPlayPosition(@ptrCast(*const IMDSPObjectInfo, self), pdwLongestPos);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPObject_Value = @import("../zig.zig").Guid.initString("1dcb3a18-33ed-11d3-8470-00c04f79dbc0");
pub const IID_IMDSPObject = &IID_IMDSPObject_Value;
pub const IMDSPObject = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const IMDSPObject,
fuMode: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Read: fn(
self: *const IMDSPObject,
pData: [*:0]u8,
pdwSize: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Write: fn(
self: *const IMDSPObject,
pData: [*:0]u8,
pdwSize: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const IMDSPObject,
fuMode: u32,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Seek: fn(
self: *const IMDSPObject,
fuFlags: u32,
dwOffset: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Rename: fn(
self: *const IMDSPObject,
pwszNewName: ?PWSTR,
pProgress: ?*IWMDMProgress,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Move: fn(
self: *const IMDSPObject,
fuMode: u32,
pProgress: ?*IWMDMProgress,
pTarget: ?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const IMDSPObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Open(self: *const T, fuMode: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Open(@ptrCast(*const IMDSPObject, self), fuMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Read(self: *const T, pData: [*:0]u8, pdwSize: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Read(@ptrCast(*const IMDSPObject, self), pData, pdwSize, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Write(self: *const T, pData: [*:0]u8, pdwSize: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Write(@ptrCast(*const IMDSPObject, self), pData, pdwSize, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Delete(self: *const T, fuMode: u32, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Delete(@ptrCast(*const IMDSPObject, self), fuMode, pProgress);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Seek(self: *const T, fuFlags: u32, dwOffset: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Seek(@ptrCast(*const IMDSPObject, self), fuFlags, dwOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Rename(self: *const T, pwszNewName: ?PWSTR, pProgress: ?*IWMDMProgress) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Rename(@ptrCast(*const IMDSPObject, self), pwszNewName, pProgress);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Move(self: *const T, fuMode: u32, pProgress: ?*IWMDMProgress, pTarget: ?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Move(@ptrCast(*const IMDSPObject, self), fuMode, pProgress, pTarget);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject.VTable, self.vtable).Close(@ptrCast(*const IMDSPObject, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPObject2_Value = @import("../zig.zig").Guid.initString("3f34cd3e-5907-4341-9af9-97f4187c3aa5");
pub const IID_IMDSPObject2 = &IID_IMDSPObject2_Value;
pub const IMDSPObject2 = extern struct {
pub const VTable = extern struct {
base: IMDSPObject.VTable,
ReadOnClearChannel: fn(
self: *const IMDSPObject2,
pData: [*:0]u8,
pdwSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteOnClearChannel: fn(
self: *const IMDSPObject2,
pData: [*:0]u8,
pdwSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IMDSPObject.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject2_ReadOnClearChannel(self: *const T, pData: [*:0]u8, pdwSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject2.VTable, self.vtable).ReadOnClearChannel(@ptrCast(*const IMDSPObject2, self), pData, pdwSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPObject2_WriteOnClearChannel(self: *const T, pData: [*:0]u8, pdwSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPObject2.VTable, self.vtable).WriteOnClearChannel(@ptrCast(*const IMDSPObject2, self), pData, pdwSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPDirectTransfer_Value = @import("../zig.zig").Guid.initString("c2fe57a8-9304-478c-9ee4-47e397b912d7");
pub const IID_IMDSPDirectTransfer = &IID_IMDSPDirectTransfer_Value;
pub const IMDSPDirectTransfer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
TransferToDevice: fn(
self: *const IMDSPDirectTransfer,
pwszSourceFilePath: ?[*:0]const u16,
pSourceOperation: ?*IWMDMOperation,
fuFlags: u32,
pwszDestinationName: ?PWSTR,
pSourceMetaData: ?*IWMDMMetaData,
pTransferProgress: ?*IWMDMProgress,
ppNewObject: ?*?*IMDSPStorage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPDirectTransfer_TransferToDevice(self: *const T, pwszSourceFilePath: ?[*:0]const u16, pSourceOperation: ?*IWMDMOperation, fuFlags: u32, pwszDestinationName: ?PWSTR, pSourceMetaData: ?*IWMDMMetaData, pTransferProgress: ?*IWMDMProgress, ppNewObject: ?*?*IMDSPStorage) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPDirectTransfer.VTable, self.vtable).TransferToDevice(@ptrCast(*const IMDSPDirectTransfer, self), pwszSourceFilePath, pSourceOperation, fuFlags, pwszDestinationName, pSourceMetaData, pTransferProgress, ppNewObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IMDSPRevoked_Value = @import("../zig.zig").Guid.initString("a4e8f2d4-3f31-464d-b53d-4fc335998184");
pub const IID_IMDSPRevoked = &IID_IMDSPRevoked_Value;
pub const IMDSPRevoked = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetRevocationURL: fn(
self: *const IMDSPRevoked,
ppwszRevocationURL: ?[*]?PWSTR,
pdwBufferLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMDSPRevoked_GetRevocationURL(self: *const T, ppwszRevocationURL: ?[*]?PWSTR, pdwBufferLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IMDSPRevoked.VTable, self.vtable).GetRevocationURL(@ptrCast(*const IMDSPRevoked, self), ppwszRevocationURL, pdwBufferLen);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureAuthenticate_Value = @import("../zig.zig").Guid.initString("1dcb3a0f-33ed-11d3-8470-00c04f79dbc0");
pub const IID_ISCPSecureAuthenticate = &IID_ISCPSecureAuthenticate_Value;
pub const ISCPSecureAuthenticate = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetSecureQuery: fn(
self: *const ISCPSecureAuthenticate,
ppSecureQuery: ?*?*ISCPSecureQuery,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureAuthenticate_GetSecureQuery(self: *const T, ppSecureQuery: ?*?*ISCPSecureQuery) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureAuthenticate.VTable, self.vtable).GetSecureQuery(@ptrCast(*const ISCPSecureAuthenticate, self), ppSecureQuery);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureAuthenticate2_Value = @import("../zig.zig").Guid.initString("b580cfae-1672-47e2-acaa-44bbecbcae5b");
pub const IID_ISCPSecureAuthenticate2 = &IID_ISCPSecureAuthenticate2_Value;
pub const ISCPSecureAuthenticate2 = extern struct {
pub const VTable = extern struct {
base: ISCPSecureAuthenticate.VTable,
GetSCPSession: fn(
self: *const ISCPSecureAuthenticate2,
ppSCPSession: ?*?*ISCPSession,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISCPSecureAuthenticate.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureAuthenticate2_GetSCPSession(self: *const T, ppSCPSession: ?*?*ISCPSession) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureAuthenticate2.VTable, self.vtable).GetSCPSession(@ptrCast(*const ISCPSecureAuthenticate2, self), ppSCPSession);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureQuery_Value = @import("../zig.zig").Guid.initString("1dcb3a0d-33ed-11d3-8470-00c04f79dbc0");
pub const IID_ISCPSecureQuery = &IID_ISCPSecureQuery_Value;
pub const ISCPSecureQuery = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDataDemands: fn(
self: *const ISCPSecureQuery,
pfuFlags: ?*u32,
pdwMinRightsData: ?*u32,
pdwMinExamineData: ?*u32,
pdwMinDecideData: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExamineData: fn(
self: *const ISCPSecureQuery,
fuFlags: u32,
pwszExtension: ?PWSTR,
pData: [*:0]u8,
dwSize: u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MakeDecision: fn(
self: *const ISCPSecureQuery,
fuFlags: u32,
pData: [*:0]u8,
dwSize: u32,
dwAppSec: u32,
pbSPSessionKey: [*:0]u8,
dwSessionKeyLen: u32,
pStorageGlobals: ?*IMDSPStorageGlobals,
ppExchange: ?*?*ISCPSecureExchange,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRights: fn(
self: *const ISCPSecureQuery,
pData: [*:0]u8,
dwSize: u32,
pbSPSessionKey: [*:0]u8,
dwSessionKeyLen: u32,
pStgGlobals: ?*IMDSPStorageGlobals,
ppRights: ?[*]?*WMDMRIGHTS,
pnRightsCount: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery_GetDataDemands(self: *const T, pfuFlags: ?*u32, pdwMinRightsData: ?*u32, pdwMinExamineData: ?*u32, pdwMinDecideData: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery.VTable, self.vtable).GetDataDemands(@ptrCast(*const ISCPSecureQuery, self), pfuFlags, pdwMinRightsData, pdwMinExamineData, pdwMinDecideData, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery_ExamineData(self: *const T, fuFlags: u32, pwszExtension: ?PWSTR, pData: [*:0]u8, dwSize: u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery.VTable, self.vtable).ExamineData(@ptrCast(*const ISCPSecureQuery, self), fuFlags, pwszExtension, pData, dwSize, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery_MakeDecision(self: *const T, fuFlags: u32, pData: [*:0]u8, dwSize: u32, dwAppSec: u32, pbSPSessionKey: [*:0]u8, dwSessionKeyLen: u32, pStorageGlobals: ?*IMDSPStorageGlobals, ppExchange: ?*?*ISCPSecureExchange, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery.VTable, self.vtable).MakeDecision(@ptrCast(*const ISCPSecureQuery, self), fuFlags, pData, dwSize, dwAppSec, pbSPSessionKey, dwSessionKeyLen, pStorageGlobals, ppExchange, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery_GetRights(self: *const T, pData: [*:0]u8, dwSize: u32, pbSPSessionKey: [*:0]u8, dwSessionKeyLen: u32, pStgGlobals: ?*IMDSPStorageGlobals, ppRights: ?[*]?*WMDMRIGHTS, pnRightsCount: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery.VTable, self.vtable).GetRights(@ptrCast(*const ISCPSecureQuery, self), pData, dwSize, pbSPSessionKey, dwSessionKeyLen, pStgGlobals, ppRights, pnRightsCount, abMac);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureQuery2_Value = @import("../zig.zig").Guid.initString("ebe17e25-4fd7-4632-af46-6d93d4fcc72e");
pub const IID_ISCPSecureQuery2 = &IID_ISCPSecureQuery2_Value;
pub const ISCPSecureQuery2 = extern struct {
pub const VTable = extern struct {
base: ISCPSecureQuery.VTable,
MakeDecision2: fn(
self: *const ISCPSecureQuery2,
fuFlags: u32,
pData: [*:0]u8,
dwSize: u32,
dwAppSec: u32,
pbSPSessionKey: [*:0]u8,
dwSessionKeyLen: u32,
pStorageGlobals: ?*IMDSPStorageGlobals,
pAppCertApp: [*:0]u8,
dwAppCertAppLen: u32,
pAppCertSP: [*:0]u8,
dwAppCertSPLen: u32,
pszRevocationURL: ?[*]?PWSTR,
pdwRevocationURLLen: ?*u32,
pdwRevocationBitFlag: ?*u32,
pqwFileSize: ?*u64,
pUnknown: ?*IUnknown,
ppExchange: ?*?*ISCPSecureExchange,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISCPSecureQuery.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery2_MakeDecision2(self: *const T, fuFlags: u32, pData: [*:0]u8, dwSize: u32, dwAppSec: u32, pbSPSessionKey: [*:0]u8, dwSessionKeyLen: u32, pStorageGlobals: ?*IMDSPStorageGlobals, pAppCertApp: [*:0]u8, dwAppCertAppLen: u32, pAppCertSP: [*:0]u8, dwAppCertSPLen: u32, pszRevocationURL: ?[*]?PWSTR, pdwRevocationURLLen: ?*u32, pdwRevocationBitFlag: ?*u32, pqwFileSize: ?*u64, pUnknown: ?*IUnknown, ppExchange: ?*?*ISCPSecureExchange, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery2.VTable, self.vtable).MakeDecision2(@ptrCast(*const ISCPSecureQuery2, self), fuFlags, pData, dwSize, dwAppSec, pbSPSessionKey, dwSessionKeyLen, pStorageGlobals, pAppCertApp, dwAppCertAppLen, pAppCertSP, dwAppCertSPLen, pszRevocationURL, pdwRevocationURLLen, pdwRevocationBitFlag, pqwFileSize, pUnknown, ppExchange, abMac);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureExchange_Value = @import("../zig.zig").Guid.initString("1dcb3a0e-33ed-11d3-8470-00c04f79dbc0");
pub const IID_ISCPSecureExchange = &IID_ISCPSecureExchange_Value;
pub const ISCPSecureExchange = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
TransferContainerData: fn(
self: *const ISCPSecureExchange,
pData: [*:0]u8,
dwSize: u32,
pfuReadyFlags: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ObjectData: fn(
self: *const ISCPSecureExchange,
pData: [*:0]u8,
pdwSize: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TransferComplete: fn(
self: *const ISCPSecureExchange,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange_TransferContainerData(self: *const T, pData: [*:0]u8, dwSize: u32, pfuReadyFlags: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange.VTable, self.vtable).TransferContainerData(@ptrCast(*const ISCPSecureExchange, self), pData, dwSize, pfuReadyFlags, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange_ObjectData(self: *const T, pData: [*:0]u8, pdwSize: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange.VTable, self.vtable).ObjectData(@ptrCast(*const ISCPSecureExchange, self), pData, pdwSize, abMac);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange_TransferComplete(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange.VTable, self.vtable).TransferComplete(@ptrCast(*const ISCPSecureExchange, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureExchange2_Value = @import("../zig.zig").Guid.initString("6c62fc7b-2690-483f-9d44-0a20cb35577c");
pub const IID_ISCPSecureExchange2 = &IID_ISCPSecureExchange2_Value;
pub const ISCPSecureExchange2 = extern struct {
pub const VTable = extern struct {
base: ISCPSecureExchange.VTable,
TransferContainerData2: fn(
self: *const ISCPSecureExchange2,
pData: [*:0]u8,
dwSize: u32,
pProgressCallback: ?*IWMDMProgress3,
pfuReadyFlags: ?*u32,
abMac: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISCPSecureExchange.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange2_TransferContainerData2(self: *const T, pData: [*:0]u8, dwSize: u32, pProgressCallback: ?*IWMDMProgress3, pfuReadyFlags: ?*u32, abMac: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange2.VTable, self.vtable).TransferContainerData2(@ptrCast(*const ISCPSecureExchange2, self), pData, dwSize, pProgressCallback, pfuReadyFlags, abMac);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureExchange3_Value = @import("../zig.zig").Guid.initString("ab4e77e4-8908-4b17-bd2a-b1dbe6dd69e1");
pub const IID_ISCPSecureExchange3 = &IID_ISCPSecureExchange3_Value;
pub const ISCPSecureExchange3 = extern struct {
pub const VTable = extern struct {
base: ISCPSecureExchange2.VTable,
TransferContainerDataOnClearChannel: fn(
self: *const ISCPSecureExchange3,
pDevice: ?*IMDSPDevice,
pData: [*:0]u8,
dwSize: u32,
pProgressCallback: ?*IWMDMProgress3,
pfuReadyFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectDataOnClearChannel: fn(
self: *const ISCPSecureExchange3,
pDevice: ?*IMDSPDevice,
pData: [*:0]u8,
pdwSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TransferCompleteForDevice: fn(
self: *const ISCPSecureExchange3,
pDevice: ?*IMDSPDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISCPSecureExchange2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange3_TransferContainerDataOnClearChannel(self: *const T, pDevice: ?*IMDSPDevice, pData: [*:0]u8, dwSize: u32, pProgressCallback: ?*IWMDMProgress3, pfuReadyFlags: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange3.VTable, self.vtable).TransferContainerDataOnClearChannel(@ptrCast(*const ISCPSecureExchange3, self), pDevice, pData, dwSize, pProgressCallback, pfuReadyFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange3_GetObjectDataOnClearChannel(self: *const T, pDevice: ?*IMDSPDevice, pData: [*:0]u8, pdwSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange3.VTable, self.vtable).GetObjectDataOnClearChannel(@ptrCast(*const ISCPSecureExchange3, self), pDevice, pData, pdwSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureExchange3_TransferCompleteForDevice(self: *const T, pDevice: ?*IMDSPDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureExchange3.VTable, self.vtable).TransferCompleteForDevice(@ptrCast(*const ISCPSecureExchange3, self), pDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSession_Value = @import("../zig.zig").Guid.initString("88a3e6ed-eee4-4619-bbb3-fd4fb62715d1");
pub const IID_ISCPSession = &IID_ISCPSession_Value;
pub const ISCPSession = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
BeginSession: fn(
self: *const ISCPSession,
pIDevice: ?*IMDSPDevice,
pCtx: [*:0]u8,
dwSizeCtx: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndSession: fn(
self: *const ISCPSession,
pCtx: [*:0]u8,
dwSizeCtx: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSecureQuery: fn(
self: *const ISCPSession,
ppSecureQuery: ?*?*ISCPSecureQuery,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSession_BeginSession(self: *const T, pIDevice: ?*IMDSPDevice, pCtx: [*:0]u8, dwSizeCtx: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSession.VTable, self.vtable).BeginSession(@ptrCast(*const ISCPSession, self), pIDevice, pCtx, dwSizeCtx);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSession_EndSession(self: *const T, pCtx: [*:0]u8, dwSizeCtx: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSession.VTable, self.vtable).EndSession(@ptrCast(*const ISCPSession, self), pCtx, dwSizeCtx);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSession_GetSecureQuery(self: *const T, ppSecureQuery: ?*?*ISCPSecureQuery) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSession.VTable, self.vtable).GetSecureQuery(@ptrCast(*const ISCPSession, self), ppSecureQuery);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISCPSecureQuery3_Value = @import("../zig.zig").Guid.initString("b7edd1a2-4dab-484b-b3c5-ad39b8b4c0b1");
pub const IID_ISCPSecureQuery3 = &IID_ISCPSecureQuery3_Value;
pub const ISCPSecureQuery3 = extern struct {
pub const VTable = extern struct {
base: ISCPSecureQuery2.VTable,
GetRightsOnClearChannel: fn(
self: *const ISCPSecureQuery3,
pData: [*:0]u8,
dwSize: u32,
pbSPSessionKey: [*:0]u8,
dwSessionKeyLen: u32,
pStgGlobals: ?*IMDSPStorageGlobals,
pProgressCallback: ?*IWMDMProgress3,
ppRights: ?[*]?*WMDMRIGHTS,
pnRightsCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MakeDecisionOnClearChannel: fn(
self: *const ISCPSecureQuery3,
fuFlags: u32,
pData: [*:0]u8,
dwSize: u32,
dwAppSec: u32,
pbSPSessionKey: [*:0]u8,
dwSessionKeyLen: u32,
pStorageGlobals: ?*IMDSPStorageGlobals,
pProgressCallback: ?*IWMDMProgress3,
pAppCertApp: [*:0]u8,
dwAppCertAppLen: u32,
pAppCertSP: [*:0]u8,
dwAppCertSPLen: u32,
pszRevocationURL: ?[*]?PWSTR,
pdwRevocationURLLen: ?*u32,
pdwRevocationBitFlag: ?*u32,
pqwFileSize: ?*u64,
pUnknown: ?*IUnknown,
ppExchange: ?*?*ISCPSecureExchange,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISCPSecureQuery2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery3_GetRightsOnClearChannel(self: *const T, pData: [*:0]u8, dwSize: u32, pbSPSessionKey: [*:0]u8, dwSessionKeyLen: u32, pStgGlobals: ?*IMDSPStorageGlobals, pProgressCallback: ?*IWMDMProgress3, ppRights: ?[*]?*WMDMRIGHTS, pnRightsCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery3.VTable, self.vtable).GetRightsOnClearChannel(@ptrCast(*const ISCPSecureQuery3, self), pData, dwSize, pbSPSessionKey, dwSessionKeyLen, pStgGlobals, pProgressCallback, ppRights, pnRightsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISCPSecureQuery3_MakeDecisionOnClearChannel(self: *const T, fuFlags: u32, pData: [*:0]u8, dwSize: u32, dwAppSec: u32, pbSPSessionKey: [*:0]u8, dwSessionKeyLen: u32, pStorageGlobals: ?*IMDSPStorageGlobals, pProgressCallback: ?*IWMDMProgress3, pAppCertApp: [*:0]u8, dwAppCertAppLen: u32, pAppCertSP: [*:0]u8, dwAppCertSPLen: u32, pszRevocationURL: ?[*]?PWSTR, pdwRevocationURLLen: ?*u32, pdwRevocationBitFlag: ?*u32, pqwFileSize: ?*u64, pUnknown: ?*IUnknown, ppExchange: ?*?*ISCPSecureExchange) callconv(.Inline) HRESULT {
return @ptrCast(*const ISCPSecureQuery3.VTable, self.vtable).MakeDecisionOnClearChannel(@ptrCast(*const ISCPSecureQuery3, self), fuFlags, pData, dwSize, dwAppSec, pbSPSessionKey, dwSessionKeyLen, pStorageGlobals, pProgressCallback, pAppCertApp, dwAppCertAppLen, pAppCertSP, dwAppCertSPLen, pszRevocationURL, pdwRevocationURLLen, pdwRevocationBitFlag, pqwFileSize, pUnknown, ppExchange);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IComponentAuthenticate_Value = @import("../zig.zig").Guid.initString("a9889c00-6d2b-11d3-8496-00c04f79dbc0");
pub const IID_IComponentAuthenticate = &IID_IComponentAuthenticate_Value;
pub const IComponentAuthenticate = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SACAuth: fn(
self: *const IComponentAuthenticate,
dwProtocolID: u32,
dwPass: u32,
pbDataIn: [*:0]u8,
dwDataInLen: u32,
ppbDataOut: ?[*]?*u8,
pdwDataOutLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SACGetProtocols: fn(
self: *const IComponentAuthenticate,
ppdwProtocols: ?[*]?*u32,
pdwProtocolCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IComponentAuthenticate_SACAuth(self: *const T, dwProtocolID: u32, dwPass: u32, pbDataIn: [*:0]u8, dwDataInLen: u32, ppbDataOut: ?[*]?*u8, pdwDataOutLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IComponentAuthenticate.VTable, self.vtable).SACAuth(@ptrCast(*const IComponentAuthenticate, self), dwProtocolID, dwPass, pbDataIn, dwDataInLen, ppbDataOut, pdwDataOutLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IComponentAuthenticate_SACGetProtocols(self: *const T, ppdwProtocols: ?[*]?*u32, pdwProtocolCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IComponentAuthenticate.VTable, self.vtable).SACGetProtocols(@ptrCast(*const IComponentAuthenticate, self), ppdwProtocols, pdwProtocolCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_WMDMLogger_Value = @import("../zig.zig").Guid.initString("110a3202-5a79-11d3-8d78-444553540000");
pub const CLSID_WMDMLogger = &CLSID_WMDMLogger_Value;
const IID_IWMDMLogger_Value = @import("../zig.zig").Guid.initString("110a3200-5a79-11d3-8d78-444553540000");
pub const IID_IWMDMLogger = &IID_IWMDMLogger_Value;
pub const IWMDMLogger = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
IsEnabled: fn(
self: *const IWMDMLogger,
pfEnabled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Enable: fn(
self: *const IWMDMLogger,
fEnable: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLogFileName: fn(
self: *const IWMDMLogger,
pszFilename: ?PSTR,
nMaxChars: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLogFileName: fn(
self: *const IWMDMLogger,
pszFilename: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LogString: fn(
self: *const IWMDMLogger,
dwFlags: u32,
pszSrcName: ?PSTR,
pszLog: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LogDword: fn(
self: *const IWMDMLogger,
dwFlags: u32,
pszSrcName: ?PSTR,
pszLogFormat: ?PSTR,
dwLog: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IWMDMLogger,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSizeParams: fn(
self: *const IWMDMLogger,
pdwMaxSize: ?*u32,
pdwShrinkToSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSizeParams: fn(
self: *const IWMDMLogger,
dwMaxSize: u32,
dwShrinkToSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_IsEnabled(self: *const T, pfEnabled: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).IsEnabled(@ptrCast(*const IWMDMLogger, self), pfEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_Enable(self: *const T, fEnable: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).Enable(@ptrCast(*const IWMDMLogger, self), fEnable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_GetLogFileName(self: *const T, pszFilename: ?PSTR, nMaxChars: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).GetLogFileName(@ptrCast(*const IWMDMLogger, self), pszFilename, nMaxChars);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_SetLogFileName(self: *const T, pszFilename: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).SetLogFileName(@ptrCast(*const IWMDMLogger, self), pszFilename);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_LogString(self: *const T, dwFlags: u32, pszSrcName: ?PSTR, pszLog: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).LogString(@ptrCast(*const IWMDMLogger, self), dwFlags, pszSrcName, pszLog);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_LogDword(self: *const T, dwFlags: u32, pszSrcName: ?PSTR, pszLogFormat: ?PSTR, dwLog: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).LogDword(@ptrCast(*const IWMDMLogger, self), dwFlags, pszSrcName, pszLogFormat, dwLog);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).Reset(@ptrCast(*const IWMDMLogger, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_GetSizeParams(self: *const T, pdwMaxSize: ?*u32, pdwShrinkToSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).GetSizeParams(@ptrCast(*const IWMDMLogger, self), pdwMaxSize, pdwShrinkToSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMDMLogger_SetSizeParams(self: *const T, dwMaxSize: u32, dwShrinkToSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMDMLogger.VTable, self.vtable).SetSizeParams(@ptrCast(*const IWMDMLogger, self), dwMaxSize, dwShrinkToSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const MTP_COMMAND_DATA_IN = packed struct {
OpCode: u16,
NumParams: u32,
Params: [5]u32,
NextPhase: u32,
CommandWriteDataSize: u32,
CommandWriteData: [1]u8,
};
pub const MTP_COMMAND_DATA_OUT = packed struct {
ResponseCode: u16,
NumParams: u32,
Params: [5]u32,
CommandReadDataSize: u32,
CommandReadData: [1]u8,
};
//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (9)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const HRESULT = @import("../foundation.zig").HRESULT;
const ISpecifyPropertyPages = @import("../system/ole.zig").ISpecifyPropertyPages;
const IUnknown = @import("../system/com.zig").IUnknown;
const PROPVARIANT = @import("../system/com/structured_storage.zig").PROPVARIANT;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const RECT = @import("../foundation.zig").RECT;
test {
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/media/device_manager.zig |
const std = @import("std");
const print = @import("std").debug.print;
const web = @import("zhp");
const Datetime = web.datetime.Datetime;
const status = @import("handlers/status.zig");
const info = @import("handlers/info.zig");
const threads = @import("threads.zig");
const recording = @import("recording.zig");
pub const routes = [_]web.Route{
web.Route.create("", "/", MainHandler),
web.Route.create("api", "/api", MainHandler),
web.Route.create("api", "/api/", MainHandler),
web.Route.create("api/status", "/api/status", status.Handler),
web.Route.create("api/info", "/api/info", info.Handler),
web.Route.create("api/gnss/pvt", "/api/gnss/pvt", GnssPvtHandler),
web.Route.create("api/recordings", "/api/recordings", RecordingIndexHandler),
web.Route.create("api/recordings", "/api/recordings/last.jpg", RecordingLastHandler),
web.Route.create("api/recordings", "/api/recordings/(.+)", RecordingFileHandler),
web.Route.static("static", "/static/", "static/"),
};
pub const MainHandler = struct {
pub fn get(self: *MainHandler, request: *web.Request, response: *web.Response) !void {
try response.headers.append("Content-Type", "text/plain");
try response.stream.writeAll("");
}
};
pub const GnssPvtHandler = struct {
pub fn get(self: *GnssPvtHandler, request: *web.Request, response: *web.Response) !void {
try response.headers.append("Content-Type", "application/json");
if (threads.gnss_ctx.gnss.last_nav_pvt()) |pvt| {
try std.json.stringify(pvt, std.json.StringifyOptions{
.whitespace = .{ .indent = .{ .Space = 2 } },
}, response.stream);
}
}
};
const FolderListing = struct {
count: usize,
bytes: u64,
files: []FileData,
};
const FileData = struct {
name: []u8,
mtime: i128,
ctime: i128,
size: u64,
};
pub const RecordingIndexHandler = struct {
pub fn get(self: *RecordingIndexHandler, request: *web.Request, response: *web.Response) !void {
try response.headers.append("Content-Type", "application/json");
const ctx = threads.rec_ctx;
if (recording.directory_listing(ctx.allocator, ctx.config.dir)) |listing| {
defer ctx.allocator.free(listing.items);
var list = std.ArrayList(FileData).init(ctx.allocator);
for (listing.items) |elem| {
var buffer = ctx.allocator.alloc(u8, elem.name_length) catch {
std.log.err("failed to allocate memory for entry: {s}", .{elem.name});
response.status = web.responses.INTERNAL_SERVER_ERROR;
try response.stream.print("ERROR: failed to allocate memory for entry: {s}", .{elem.name});
return;
};
var obj = FileData{
.name = buffer,
.size = elem.size,
.mtime = elem.mtime,
.ctime = elem.ctime,
};
std.mem.copy(u8, obj.name, elem.name[0..elem.name_length]);
list.append(obj) catch {
std.log.err("failed to append entry: {s}", .{elem.name});
response.status = web.responses.INTERNAL_SERVER_ERROR;
try response.stream.print("ERROR: failed to append entry: {s}", .{elem.name});
return;
};
}
const out = FolderListing{
.count = listing.count,
.bytes = listing.bytes,
.files = list.items,
};
try std.json.stringify(out, std.json.StringifyOptions{
.whitespace = .{ .indent = .{ .Space = 2 } },
}, response.stream);
defer {
for (list.items) |node| {
ctx.allocator.free(node.name);
}
list.deinit();
}
}
}
};
pub const RecordingLastHandler = struct {
handler: FileHandler = undefined,
pub fn get(self: *RecordingLastHandler, request: *web.Request, response: *web.Response) !void {
const allocator = response.allocator;
const ctx = threads.rec_ctx;
const path = try std.fmt.allocPrint(allocator, "{s}/{s}", .{ ctx.config.dir, ctx.last_file });
self.handler = FileHandler{ .path = path };
return self.handler.dispatch(request, response);
}
pub fn stream(self: *RecordingLastHandler, io: *web.IOStream) !u64 {
return self.handler.stream(io);
}
};
pub const RecordingFileHandler = struct {
handler: FileHandler = undefined,
pub fn get(self: *RecordingFileHandler, request: *web.Request, response: *web.Response) !void {
const allocator = response.allocator;
const ctx = threads.rec_ctx;
const args = request.args.?;
// Replace instances of '%20' in filename with ' ' chars, to handle URI-encoding.
// The new filename might be shorter (in bytes) than the original, so we use that
// new length when creating the full filesystem path later on.
const filename = try allocator.alloc(u8, args[0].?.len);
const spaces = std.mem.replace(u8, args[0].?, "%20", " ", filename[0..]);
const filename_length = filename.len - spaces * 2;
defer allocator.free(filename);
const full_path = try std.fs.path.join(allocator, &[_][]const u8{ ctx.config.dir, filename[0..filename_length] });
self.handler = FileHandler{ .path = full_path };
return self.handler.dispatch(request, response);
}
pub fn stream(self: *RecordingFileHandler, io: *web.IOStream) !u64 {
return self.handler.stream(io);
}
};
pub const FileHandler = struct {
file: ?std.fs.File = null,
start: u64 = 0,
end: u64 = 0,
path: []const u8,
pub fn dispatch(self: *FileHandler, request: *web.Request, response: *web.Response) !void {
const allocator = response.allocator;
const mimetypes = &web.mimetypes.instance.?;
const file = std.fs.cwd().openFile(self.path, .{ .read = true }) catch |err| {
// TODO: Handle debug page
std.log.warn("recording file {s} error {}", .{ self.path, err });
return self.renderNotFound(request, response);
};
errdefer file.close();
// Get file info
var stat = try file.stat();
// File handle is on disk, but it does not have contents yet.
// We need to wait, otherwise assertion at start of stream function will fail.
while (stat.size == 0) {
std.time.sleep(std.time.ns_per_ms * 10);
stat = try file.stat();
}
var modified = Datetime.fromModifiedTime(stat.mtime);
// If the file was not modified, return 304
if (self.checkNotModified(request, modified)) {
response.status = web.responses.NOT_MODIFIED;
file.close();
return;
}
// Set last modified time for caching purposes
// NOTE: The modified result doesn't need freed since the response handles that
var buf = try response.allocator.alloc(u8, 32);
try response.headers.append("Last-Modified", try modified.formatHttpBuf(buf));
self.end = stat.size;
var size: u64 = stat.size;
// Try to get the content type
const content_type = mimetypes.getTypeFromFilename(self.path) orelse "application/octet-stream";
try response.headers.append("Content-Type", content_type);
try response.headers.append("Content-Length", try std.fmt.allocPrint(allocator, "{}", .{size}));
self.file = file;
response.send_stream = true;
}
// Return true if not modified and a 304 can be returned
pub fn checkNotModified(self: *FileHandler, request: *web.Request, mtime: Datetime) bool {
// Check if the file was modified since the header
// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since
const v = request.headers.getDefault("If-Modified-Since", "");
const since = Datetime.parseModifiedSince(v) catch return false;
return since.gte(mtime);
}
// Stream the file
pub fn stream(self: *FileHandler, io: *web.IOStream) !u64 {
std.debug.assert(self.end > self.start);
const total_wrote = self.end - self.start;
var bytes_left: u64 = total_wrote;
if (self.file) |file| {
defer file.close();
// Jump to requested range
if (self.start > 0) {
try file.seekTo(self.start);
}
// Send it
var reader = file.reader();
try io.flush();
while (bytes_left > 0) {
// Read into buffer
const end = std.math.min(bytes_left, io.out_buffer.len);
const n = try reader.read(io.out_buffer[0..end]);
if (n == 0) break; // Unexpected EOF
bytes_left -= n;
try io.flushBuffered(n);
}
}
return total_wrote - bytes_left;
}
pub fn renderNotFound(self: *FileHandler, request: *web.Request, response: *web.Response) !void {
var handler = web.handlers.NotFoundHandler{};
try handler.dispatch(request, response);
}
}; | src/handlers.zig |
const std = @import("std");
const print = @import("std").debug.print;
const led_driver = @import("led_driver.zig");
const gnss = @import("gnss.zig");
const config = @import("config.zig");
const recording = @import("recording.zig");
const exif = @import("exif.zig");
const web = @import("zhp");
pub const GnssContext = struct {
gnss: *gnss.GNSS,
led: led_driver.LP50xx,
rate: u16 = 1000,
};
pub const AppContext = struct {
config: config.Api,
app: *web.Application,
};
pub var gnss_ctx: GnssContext = undefined;
pub const HeartBeatContext = struct {
idx: u8 = 0,
on: u32 = 100,
off: u32 = 900,
color: [3]u8 = [_]u8{ 255, 255, 255 },
led: led_driver.LP50xx,
};
pub var rec_ctx: RecordingContext = undefined;
pub const RecordingContext = struct {
config: config.Recording,
allocator: *std.mem.Allocator,
server: *std.net.StreamServer,
stop: std.atomic.Atomic(bool),
last_file: [28]u8 = [_]u8{'0'} ** 28,
gnss: GnssContext,
};
pub const CameraContext = struct {
config: config.Camera,
socket: []const u8,
allocator: *std.mem.Allocator,
};
pub var camera_ctx: CameraContext = undefined;
const JPEG_SOI = [_]u8{ 0xFF, 0xD8 };
const JPEG_EOI = [_]u8{ 0xFF, 0xD9 };
const PUB = "PUB ";
const EOL = "\r\n";
fn find_som(buffer: []const u8, start: usize, end: usize) ?usize {
return std.mem.indexOf(u8, buffer[start..end], PUB[0..]);
}
pub fn recording_server_thread(ctx: *RecordingContext) void {
while (true) {
const conn = ctx.server.accept() catch |err| {
std.log.err("REC | server accept | ERR {}", .{err});
continue;
};
std.log.info("REC | client connected", .{});
defer conn.stream.close();
var frame = async handle_connection(ctx, conn);
await frame;
}
}
fn handle_connection(ctx: *RecordingContext, conn: std.net.StreamServer.Connection) void {
// Create large buffer for collecting image data into
// Should be larger than the largest image size we expect
var buffer: [1024 * 1024 * 4]u8 = undefined;
std.mem.set(u8, buffer[0..], 0);
// Buffer for incoming UDP data (should be larger than max MTU size)
var incoming: [100000]u8 = undefined;
// Current position within the buffer to write into
var head: usize = 0;
// Current position within the buffer to read from
var read: usize = 0;
// Positions within the image buffer where JPEG start / end bytes are
var idx_start: usize = 0;
var idx_end: usize = 0;
// Flags for JPEG SOF / EOF
var found_start: bool = false;
var found_end: bool = false;
// TODO : detect last frame count on disk and start above that number
var frame_count: usize = 0;
// Error recovery flag -- when non-null the buffers and flags will be reset
var reset_to: ?usize = null;
var topic_name: ?[]const u8 = null;
var message_size: usize = 0;
while (true) {
if (reset_to != null) {
head = reset_to.?;
read = 0;
frame_count += 1;
found_start = false;
found_end = false;
reset_to = null;
}
// std.log.info("SOCK READ SIZE {}", .{ctx.sock.getReadBufferSize()});
const data_len = conn.stream.reader().read(incoming[0..]) catch |err| {
std.log.err("REC RECV | ERR {}", .{err});
continue;
};
if (data_len == 0) {
std.log.info("REC RECV | client disconnected", .{});
break;
}
// std.log.info("head {} data_len {}", .{ head, data_len });
if (head + data_len > buffer.len) {
std.log.err("REC RECV | buffer will overflow. reset.", .{});
std.mem.set(u8, incoming[0..], 0);
reset_to = 0;
continue;
}
std.mem.copy(u8, buffer[head .. head + data_len], incoming[0..data_len]);
if (!found_start) {
// Using read as start of search space as PUB might be split across UDP packets
// and head.. might skip over start of sequence.
// if (std.mem.indexOf(u8, buffer[read..head+data_len], PUB[0..])) |idx_msg_start| {
if (find_som(&buffer, read, head + data_len)) |idx_msg_start| {
const idx_topic_start = idx_msg_start + PUB.len;
if (std.mem.indexOf(u8, buffer[idx_topic_start .. idx_topic_start + 20], " ")) |idx_space| {
topic_name = buffer[idx_topic_start .. idx_topic_start + idx_space];
// std.log.info(". idx_msg_start {}", .{idx_msg_start});
// std.log.info(". idx_space {}", .{idx_space});
// std.log.info(". topic {s}", .{topic_name});
if (std.mem.indexOf(u8, buffer[idx_topic_start .. idx_topic_start + 20], "\r\n")) |idx_eol| {
if (std.fmt.parseInt(usize, buffer[idx_topic_start + idx_space + 1 .. idx_topic_start + idx_eol], 10)) |value| {
message_size = value;
// std.log.info(". size {}", .{message_size});
// Advance read to end of PUB line (including line break)
read += idx_topic_start + idx_eol + 2;
if (buffer[read] == JPEG_SOI[0] and buffer[read + 1] == JPEG_SOI[1]) {
idx_start = read;
// std.log.info(". idx_start {}", .{idx_start});
found_start = true;
} else {
std.log.err("REC RECV | did not find start of JPEG data at {}", .{read});
reset_to = 0;
continue;
}
} else |err| {
std.log.err("REC RECV | cannot parse message size : {s}", .{buffer[idx_topic_start + idx_space + 1 .. idx_topic_start + idx_eol]});
reset_to = 0;
continue;
}
}
}
}
}
// std.log.info("acculum {} to {}", .{ read, head + data_len });
if (found_start and !found_end and (head + data_len - read) >= message_size + 2) {
// std.log.info("buffer start {s}", .{std.fmt.fmtSliceHexUpper(buffer[0 .. read + 20])});
// std.log.info("buffer end {s}", .{std.fmt.fmtSliceHexUpper(buffer[read + message_size - 4 .. read + message_size + 4])});
// Check for the EOL bytes and for the valid end of a JPEG frame
if (buffer[read + message_size - 2] == JPEG_EOI[0] and
buffer[read + message_size - 1] == JPEG_EOI[1] and
buffer[read + message_size] == EOL[0] and
buffer[read + message_size + 1] == EOL[1])
{
idx_end = read + message_size;
// std.log.info("idx_end {}", .{idx_end});
found_end = true;
} else {
if (std.mem.indexOf(u8, buffer[idx_start..], PUB[0..])) |value| {
std.log.info("REC RECV | NO EOL. FOUND PUB at {}", .{idx_start + value});
const length: usize = head + data_len - (value + idx_start);
std.mem.copy(u8, buffer[0..length], buffer[idx_start + value .. head + data_len]);
std.mem.set(u8, buffer[length..], 0);
reset_to = length;
continue;
} else {
std.log.info("REC RECV | NO EOL | HARD RESET", .{});
std.mem.set(u8, buffer[0..], 0);
reset_to = 0;
continue;
}
}
}
head += data_len;
if (found_start and found_end) {
std.log.info("REC RECV | Frame {} is {} from {} to {}", .{ frame_count, idx_end - idx_start, idx_start, idx_end });
var pvt = ctx.gnss.gnss.last_nav_pvt();
var filename = alloc_filename(ctx, pvt) catch |err| {
std.log.err("REC RECV | could not create filename", .{});
reset_to = 0;
continue;
};
defer ctx.allocator.free(filename);
var file = std.fs.cwd().createFile(filename, .{}) catch |err| {
std.log.err("REC RECV | could not create file : {}", .{err});
reset_to = 0;
continue;
};
defer file.close();
write_image(ctx, file, buffer[idx_start..idx_end], pvt) catch |err| {
std.log.err("REC RECV | could write image : {}", .{err});
reset_to = 0;
continue;
};
std.mem.copy(u8, ctx.last_file[0..], filename[filename.len - 28 ..]);
// Copy any partial data we have to the start of the acculumation buffer
if (idx_end + 2 < head) {
std.log.info("REC RECV | copy tail bytes : {} {}", .{ idx_end, head });
std.mem.copy(u8, buffer[0 .. head - idx_end - 2], buffer[idx_end + 2 .. head]);
reset_to = head - idx_end - 2;
} else {
reset_to = 0;
}
}
}
}
fn alloc_filename(ctx: *RecordingContext, pvt: ?gnss.NAV_PVT) ![]u8 {
if (pvt) |value| {
const temp = try std.fmt.allocPrint(ctx.allocator, "{s}/{s}.jpg", .{ ctx.config.dir, value.timestamp });
defer ctx.allocator.free(temp);
const filename = try ctx.allocator.alloc(u8, temp.len);
_ = std.mem.replace(u8, temp, ":", "-", filename[0..]);
return filename;
} else {
return std.fmt.allocPrint(ctx.allocator, "{s}/1970-01-01T00-00-00.000Z.jpg", .{ctx.config.dir});
}
}
fn write_image(ctx: *RecordingContext, file: std.fs.File, buffer: []const u8, pvt: ?gnss.NAV_PVT) !void {
var buf_stream = std.io.bufferedWriter(file.writer());
const st = buf_stream.writer();
var exif_tags = exif.init();
if (pvt) |value| {
exif_tags.set_gnss(value);
}
if (exif_tags.bytes()) |exif_array| {
const exif_len = exif_array.len + 2;
const exif_buffer = exif_array.constSlice();
// std.log.info("EXIF | [{d}] {s}", .{ exif_buffer.len, std.fmt.fmtSliceHexUpper(exif_buffer) });
try st.writeAll(JPEG_SOI[0..]);
try st.writeAll(exif.APP0_HEADER[0..]);
try st.writeAll(exif.MARK_APP1[0..]);
try st.writeByte(@truncate(u8, exif_len >> 8));
try st.writeByte(@truncate(u8, exif_len));
try st.writeAll(exif_buffer);
try st.writeAll(buffer[exif.image_offset..]);
} else {
// No EXIF data, so just write out the image part of the buffer -- it is valid JPEG data.
std.log.info("EXIF embedding failed", .{});
try st.writeAll(buffer[0..]);
}
try buf_stream.flush();
}
pub fn recording_cleanup_thread(ctx: RecordingContext) void {
const sleep_ns = @intCast(u64, ctx.config.cleanup_frequency) * std.time.ns_per_s;
const path = ctx.config.dir;
if (std.fs.openDirAbsolute(path, .{ .iterate = true, .no_follow = false })) |dir| {} else |err| switch (err) {
error.FileNotFound => {
std.log.info("recording directory {s} does not exists, creating folder\n", .{path});
if (std.fs.makeDirAbsolute(path)) {} else |mkerr| {
std.log.warn("[{any}] when creating recording directory {s}\n", .{ mkerr, path });
}
},
else => {
std.log.warn("[{any}] when testin recording directory {s}\n", .{ err, path });
},
}
while (true) {
const start_ms = std.time.milliTimestamp();
recording.directory_cleanup(ctx);
const ellapsed_ns = (std.time.milliTimestamp() - start_ms) * std.time.ns_per_ms;
std.time.sleep(sleep_ns - @intCast(u64, ellapsed_ns));
}
}
pub fn heartbeat_thread(ctx: HeartBeatContext) void {
while (true) {
// ctx.led.set(ctx.idx, ctx.color);
std.time.sleep(ctx.on * std.time.ns_per_ms);
// ctx.led.set(ctx.idx, [_]u8{ 0, 0, 0 });
std.time.sleep(ctx.off * std.time.ns_per_ms);
}
}
pub fn gnss_thread(ctx: GnssContext) void {
ctx.gnss.set_timeout(ctx.rate + 50);
while (true) {
// ctx.gnss.set_next_timeout(ctx.rate * 2);
if (ctx.gnss.get_pvt()) {
if (ctx.gnss.last_nav_pvt()) |pvt| {
if (pvt.fix_type == 0) {
// If no position fix, color LED orange
ctx.led.set(1, [_]u8{ 255, 127, 0 });
} else {
// If there is a fix, color LED green
ctx.led.set(1, [_]u8{ 0, 255, 0 });
}
print("PVT {s} at ({d:.6},{d:.6}) height {d:.2}", .{ pvt.timestamp, pvt.latitude, pvt.longitude, pvt.height });
print(" heading {d:.2} velocity ({d:.2},{d:.2},{d:.2}) speed {d:.2}", .{ pvt.heading, pvt.velocity[0], pvt.velocity[1], pvt.velocity[2], pvt.speed });
print(" fix {d} sat {} flags {} {} {}\n", .{ pvt.fix_type, pvt.satellite_count, pvt.flags[0], pvt.flags[1], pvt.flags[2] });
}
} else {
// If no communications, color LED red
ctx.led.set(1, [_]u8{ 255, 0, 0 });
}
// std.time.sleep(std.time.ns_per_ms * @intCast(u64, ctx.rate / 4));
}
}
pub fn app_thread(ctx: AppContext) void {
defer ctx.app.deinit();
ctx.app.listen("0.0.0.0", ctx.config.port) catch |err| {
print("app : could not open server port {d}\n", .{ctx.config.port});
ctx.app.listen("0.0.0.0", 5000) catch |err_fallback| {
print("app : could not open fallback server port\n", .{});
return;
};
};
ctx.app.start() catch |err| {
print("app : could not start\n", .{});
return;
};
} | src/threads.zig |
const std = @import("std");
const vec4 = std.meta.Vector(4, f64);
fn vec1to4(f: f64) vec4 {
return @splat(4, f);
}
fn runInParallel(tasks: []std.Thread, len: usize, comptime f: anytype, args: anytype) !void {
const len_per_task = @divTrunc(len, tasks.len + 1);
for (tasks) |*task, i| {
const first = len_per_task * i;
const last = first + len_per_task;
task.* = try std.Thread.spawn(.{}, f, .{ first, last } ++ args);
}
@call(.{}, f, .{ tasks.len * len_per_task, len } ++ args);
for (tasks) |*task| task.join();
}
fn baseIdx(i: vec4) vec4 {
@setFloatMode(.Optimized);
return i * (i + vec1to4(1)) * vec1to4(0.5) + vec1to4(1);
}
fn multAvGeneric(comptime transpose: bool, first: usize, dst: []vec4, src: []const vec4) void {
@setFloatMode(.Optimized);
const srcVals = std.mem.bytesAsSlice(f64, std.mem.sliceAsBytes(src));
var ti = vec1to4(@intToFloat(f64, first * 4)) + if (transpose) vec4{ 1, 2, 3, 4 } else vec4{ 0, 1, 2, 3 };
for (dst) |*res| {
var idx = if (transpose) baseIdx(ti - vec1to4(1)) else baseIdx(ti) + ti;
var sum = vec1to4(0);
for (srcVals) |u, j| {
sum += vec1to4(u) / idx;
idx += ti + vec1to4(@intToFloat(f64, j + 1));
}
res.* = sum;
ti += vec1to4(4);
}
}
fn multAv(first: usize, last: usize, dst: []vec4, src: []const vec4) void {
return multAvGeneric(false, first, dst[first..last], src);
}
fn multAtv(first: usize, last: usize, dst: []vec4, src: []const vec4) void {
return multAvGeneric(true, first, dst[first..last], src);
}
fn multAtAv(tasks: []std.Thread, dest: []vec4, src: []const vec4, temp: []vec4) !void {
std.debug.assert(dest.len == src.len and src.len == temp.len);
try runInParallel(tasks, dest.len, multAv, .{ temp, src });
try runInParallel(tasks, dest.len, multAtv, .{ dest, temp });
}
fn setOnes(first: usize, last: usize, dst: []vec4) void {
for (dst[first..last]) |*v| v.* = vec1to4(1);
}
fn aggregateResults(first: usize, last: usize, u: []const vec4, v: []const vec4, total_vbv: *f64, total_vv: *f64) void {
@setFloatMode(.Optimized);
var vbv = vec1to4(0);
var vv = vec1to4(0);
for (v[first..last]) |f, i| {
vbv += u[first + i] * f;
vv += f * f;
}
_ = @atomicRmw(f64, total_vbv, .Add, @reduce(.Add, vbv), .SeqCst);
_ = @atomicRmw(f64, total_vv, .Add, @reduce(.Add, vv), .SeqCst);
}
pub fn main() !void {
const n = try get_n();
const len = n / @typeInfo(vec4).Vector.len;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = gpa.allocator();
var u = try allocator.alloc(vec4, len);
defer allocator.free(u);
var v = try allocator.alloc(vec4, len);
defer allocator.free(v);
var temp = try allocator.alloc(vec4, len);
defer allocator.free(temp);
const task_count = try std.Thread.getCpuCount();
const tasks = try allocator.alloc(std.Thread, task_count - 1);
defer allocator.free(tasks);
try runInParallel(tasks, u.len, setOnes, .{u});
var times: usize = 0;
while (times < 10) : (times += 1) {
try multAtAv(tasks, v, u, temp);
try multAtAv(tasks, u, v, temp);
}
var vbv: f64 = 0;
var vv: f64 = 0;
try runInParallel(tasks, u.len, aggregateResults, .{ u, v, &vbv, &vv });
const res = std.math.sqrt(vbv / vv);
const stdout = std.io.getStdOut().writer();
try stdout.print("{d:.9}\n", .{res});
}
fn get_n() !usize {
var arg_it = std.process.args();
_ = arg_it.skip();
const arg = arg_it.next() orelse return 100;
return try std.fmt.parseInt(usize, arg, 10);
} | bench/algorithm/spectral-norm/2-m.zig |
const builtin = @import("builtin");
const expect = @import("std").testing.expect;
test "@mulAdd" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try testMulAdd();
try testMulAdd();
}
fn testMulAdd() !void {
{
var a: f32 = 5.5;
var b: f32 = 2.5;
var c: f32 = 6.25;
try expect(@mulAdd(f32, a, b, c) == 20);
}
{
var a: f64 = 5.5;
var b: f64 = 2.5;
var c: f64 = 6.25;
try expect(@mulAdd(f64, a, b, c) == 20);
}
}
test "@mulAdd f16" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try testMulAdd16();
try testMulAdd16();
}
fn testMulAdd16() !void {
var a: f16 = 5.5;
var b: f16 = 2.5;
var c: f16 = 6.25;
try expect(@mulAdd(f16, a, b, c) == 20);
}
test "@mulAdd f80" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
comptime try testMulAdd80();
try testMulAdd80();
}
fn testMulAdd80() !void {
var a: f16 = 5.5;
var b: f80 = 2.5;
var c: f80 = 6.25;
try expect(@mulAdd(f80, a, b, c) == 20);
}
test "@mulAdd f128" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.os.tag == .macos and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/9900
return error.SkipZigTest;
}
if (builtin.zig_backend == .stage1 and
builtin.cpu.arch == .i386 and builtin.os.tag == .linux)
{
return error.SkipZigTest;
}
comptime try testMulAdd128();
try testMulAdd128();
}
fn testMulAdd128() !void {
var a: f16 = 5.5;
var b: f128 = 2.5;
var c: f128 = 6.25;
try expect(@mulAdd(f128, a, b, c) == 20);
}
fn vector16() !void {
var a = @Vector(4, f16){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f16){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f16){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f16), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
try expect(x[3] == 20);
}
test "vector f16" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try vector16();
try vector16();
}
fn vector32() !void {
var a = @Vector(4, f32){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f32){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f32){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f32), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
try expect(x[3] == 20);
}
test "vector f32" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try vector32();
try vector32();
}
fn vector64() !void {
var a = @Vector(4, f64){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f64){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f64){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f64), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
try expect(x[3] == 20);
}
test "vector f64" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try vector64();
try vector64();
}
fn vector80() !void {
var a = @Vector(4, f80){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f80){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f80){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f80), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
try expect(x[3] == 20);
}
test "vector f80" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try vector80();
try vector80();
}
fn vector128() !void {
var a = @Vector(4, f128){ 5.5, 5.5, 5.5, 5.5 };
var b = @Vector(4, f128){ 2.5, 2.5, 2.5, 2.5 };
var c = @Vector(4, f128){ 6.25, 6.25, 6.25, 6.25 };
var x = @mulAdd(@Vector(4, f128), a, b, c);
try expect(x[0] == 20);
try expect(x[1] == 20);
try expect(x[2] == 20);
try expect(x[3] == 20);
}
test "vector f128" {
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
comptime try vector128();
try vector128();
} | test/behavior/muladd.zig |
const builtin = @import("builtin");
const std = @import("std.zig");
const math = std.math;
const debug = std.debug;
const assert = std.debug.assert;
const testing = std.testing;
/// There is a trade off of how quickly to fill a bloom filter;
/// the number of items is:
/// n_items / K * ln(2)
/// the rate of false positives is:
/// (1-e^(-K*N/n_items))^K
/// where N is the number of items
pub fn BloomFilter(
/// Size of bloom filter in cells, must be a power of two.
comptime n_items: usize,
/// Number of cells to set per item
comptime K: usize,
/// Cell type, should be:
/// - `bool` for a standard bloom filter
/// - an unsigned integer type for a counting bloom filter
comptime Cell: type,
/// endianess of the Cell
comptime endian: builtin.Endian,
/// Hash function to use
comptime hash: fn (out: []u8, Ki: usize, in: []const u8) void,
) type {
assert(n_items > 0);
assert(math.isPowerOfTwo(n_items));
assert(K > 0);
const cellEmpty = if (Cell == bool) false else Cell(0);
const cellMax = if (Cell == bool) true else math.maxInt(Cell);
const n_bytes = (n_items * comptime std.meta.bitCount(Cell)) / 8;
assert(n_bytes > 0);
const Io = std.packed_int_array.PackedIntIo(Cell, endian);
return struct {
const Self = @This();
pub const items = n_items;
pub const Index = math.IntFittingRange(0, n_items - 1);
data: [n_bytes]u8 = [_]u8{0} ** n_bytes,
pub fn reset(self: *Self) void {
std.mem.set(u8, self.data[0..], 0);
}
pub fn @"union"(x: Self, y: Self) Self {
var r = Self{ .data = undefined };
inline for (x.data) |v, i| {
r.data[i] = v | y.data[i];
}
return r;
}
pub fn intersection(x: Self, y: Self) Self {
var r = Self{ .data = undefined };
inline for (x.data) |v, i| {
r.data[i] = v & y.data[i];
}
return r;
}
pub fn getCell(self: Self, cell: Index) Cell {
return Io.get(self.data, cell, 0);
}
pub fn incrementCell(self: *Self, cell: Index) void {
if (Cell == bool or Cell == u1) {
// skip the 'get' operation
Io.set(&self.data, cell, 0, cellMax);
} else {
const old = Io.get(self.data, cell, 0);
if (old != cellMax) {
Io.set(&self.data, cell, 0, old + 1);
}
}
}
pub fn clearCell(self: *Self, cell: Index) void {
Io.set(&self.data, cell, 0, cellEmpty);
}
pub fn add(self: *Self, item: []const u8) void {
comptime var i = 0;
inline while (i < K) : (i += 1) {
var K_th_bit: packed struct {
x: Index,
} = undefined;
hash(std.mem.asBytes(&K_th_bit), i, item);
incrementCell(self, K_th_bit.x);
}
}
pub fn contains(self: Self, item: []const u8) bool {
comptime var i = 0;
inline while (i < K) : (i += 1) {
var K_th_bit: packed struct {
x: Index,
} = undefined;
hash(std.mem.asBytes(&K_th_bit), i, item);
if (getCell(self, K_th_bit.x) == cellEmpty)
return false;
}
return true;
}
pub fn resize(self: Self, comptime newsize: usize) BloomFilter(newsize, K, Cell, endian, hash) {
var r: BloomFilter(newsize, K, Cell, endian, hash) = undefined;
if (newsize < n_items) {
std.mem.copy(u8, r.data[0..], self.data[0..r.data.len]);
var copied: usize = r.data.len;
while (copied < self.data.len) : (copied += r.data.len) {
for (self.data[copied .. copied + r.data.len]) |s, i| {
r.data[i] |= s;
}
}
} else if (newsize == n_items) {
r = self;
} else if (newsize > n_items) {
var copied: usize = 0;
while (copied < r.data.len) : (copied += self.data.len) {
std.mem.copy(u8, r.data[copied .. copied + self.data.len], self.data);
}
}
return r;
}
/// Returns number of non-zero cells
pub fn popCount(self: Self) Index {
var n: Index = 0;
if (Cell == bool or Cell == u1) {
for (self.data) |b, i| {
n += @popCount(u8, b);
}
} else {
var i: usize = 0;
while (i < n_items) : (i += 1) {
const cell = self.getCell(@intCast(Index, i));
n += if (if (Cell == bool) cell else cell > 0) Index(1) else Index(0);
}
}
return n;
}
pub fn estimateItems(self: Self) f64 {
const m = comptime @intToFloat(f64, n_items);
const k = comptime @intToFloat(f64, K);
const X = @intToFloat(f64, self.popCount());
return (comptime (-m / k)) * math.log1p(X * comptime (-1 / m));
}
};
}
fn hashFunc(out: []u8, Ki: usize, in: []const u8) void {
var st = std.crypto.gimli.Hash.init();
st.update(std.mem.asBytes(&Ki));
st.update(in);
st.final(out);
}
test "std.BloomFilter" {
inline for ([_]type{ bool, u1, u2, u3, u4 }) |Cell| {
const emptyCell = if (Cell == bool) false else Cell(0);
const BF = BloomFilter(128 * 8, 8, Cell, builtin.endian, hashFunc);
var bf = BF{};
var i: usize = undefined;
// confirm that it is initialised to the empty filter
i = 0;
while (i < BF.items) : (i += 1) {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
testing.expectEqual(f64(0), bf.estimateItems());
// fill in a few items
bf.incrementCell(42);
bf.incrementCell(255);
bf.incrementCell(256);
bf.incrementCell(257);
// check that they were set
testing.expectEqual(true, bf.getCell(42) != emptyCell);
testing.expectEqual(true, bf.getCell(255) != emptyCell);
testing.expectEqual(true, bf.getCell(256) != emptyCell);
testing.expectEqual(true, bf.getCell(257) != emptyCell);
// clear just one of them; make sure the rest are still set
bf.clearCell(256);
testing.expectEqual(true, bf.getCell(42) != emptyCell);
testing.expectEqual(true, bf.getCell(255) != emptyCell);
testing.expectEqual(false, bf.getCell(256) != emptyCell);
testing.expectEqual(true, bf.getCell(257) != emptyCell);
// reset any of the ones we've set and confirm we're back to the empty filter
bf.clearCell(42);
bf.clearCell(255);
bf.clearCell(257);
i = 0;
while (i < BF.items) : (i += 1) {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
testing.expectEqual(f64(0), bf.estimateItems());
// Lets add a string
bf.add("foo");
testing.expectEqual(true, bf.contains("foo"));
{
// try adding same string again. make sure popcount is the same
const old_popcount = bf.popCount();
testing.expect(old_popcount > 0);
bf.add("foo");
testing.expectEqual(true, bf.contains("foo"));
testing.expectEqual(old_popcount, bf.popCount());
}
// Get back to empty filter via .reset
bf.reset();
// Double check that .reset worked
i = 0;
while (i < BF.items) : (i += 1) {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
testing.expectEqual(f64(0), bf.estimateItems());
comptime var teststrings = [_][]const u8{
"foo",
"bar",
"a longer string",
"some more",
"the quick brown fox",
"unique string",
};
inline for (teststrings) |str| {
bf.add(str);
}
inline for (teststrings) |str| {
testing.expectEqual(true, bf.contains(str));
}
{ // estimate should be close for low packing
const est = bf.estimateItems();
testing.expect(est > @intToFloat(f64, teststrings.len) - 1);
testing.expect(est < @intToFloat(f64, teststrings.len) + 1);
}
const larger_bf = bf.resize(4096);
inline for (teststrings) |str| {
testing.expectEqual(true, larger_bf.contains(str));
}
testing.expectEqual(u12(bf.popCount()) * (4096 / 1024), larger_bf.popCount());
const smaller_bf = bf.resize(64);
inline for (teststrings) |str| {
testing.expectEqual(true, smaller_bf.contains(str));
}
testing.expect(bf.popCount() <= u10(smaller_bf.popCount()) * (1024 / 64));
}
} | lib/std/bloom_filter.zig |
const clap = @import("clap");
const datetime = @import("datetime");
const folders = @import("known_folders");
const std = @import("std");
const anime = @import("anime.zig");
const base64 = std.base64;
const fs = std.fs;
const heap = std.heap;
const io = std.io;
const json = std.json;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const database_name = "database";
const database_url = "https://raw.githubusercontent.com/manami-project/anime-offline-database/master/anime-offline-database.json";
const image_cache_name = "images";
const list_name = "list";
const program_name = "anilist";
// TODO: One of these days, we will have a good networking library
// and a proper event loop in std. When that happens I'll look
// into downloading/writing things in parallel.
const params = [_]clap.Param(clap.Help){
clap.parseParam("-h, --help Print this message to stdout") catch unreachable,
clap.parseParam("-t, --token <TOKEN> The discord token.") catch unreachable,
};
fn usage(stream: anytype, command: Command, p: []const clap.Param(clap.Help)) !void {
_ = command;
try stream.writeAll("Usage: ");
try clap.usage(stream, ¶ms);
try stream.writeAll(
\\
\\Help message here
\\
\\Options:
\\
);
try clap.help(stream, p);
}
const Command = enum {
@"--help",
complete,
database,
drop,
fetch,
help,
list,
plan_to_watch,
put_on_hold,
remove,
start_watching,
update,
watch_episode,
};
pub fn main() !u8 {
var gba = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = gba.allocator();
defer _ = gba.deinit();
var args_iter = try clap.args.OsIterator.init(allocator);
defer args_iter.deinit();
const command_str = (try args_iter.next()) orelse "help";
const command = std.meta.stringToEnum(Command, command_str) orelse .help;
return switch (command) {
.help, .@"--help" => try helpMain(allocator, &args_iter),
.database => try databaseMain(allocator),
.fetch => try fetchMain(allocator, &args_iter),
.list => try listMain(allocator),
.complete => try listManipulateMain(allocator, &args_iter, .complete),
.drop => try listManipulateMain(allocator, &args_iter, .dropped),
.plan_to_watch => try listManipulateMain(allocator, &args_iter, .plan_to_watch),
.put_on_hold => try listManipulateMain(allocator, &args_iter, .on_hold),
.remove => try listManipulateMain(allocator, &args_iter, .remove),
.start_watching => try listManipulateMain(allocator, &args_iter, .watching),
.update => try listManipulateMain(allocator, &args_iter, .update),
.watch_episode => try listManipulateMain(allocator, &args_iter, .watch_episode),
};
}
fn helpMain(allocator: mem.Allocator, args_iter: *clap.args.OsIterator) !u8 {
_ = allocator;
_ = args_iter;
// TODO
return 0;
}
fn fetchMain(allocator: mem.Allocator, args_iter: *clap.args.OsIterator) !u8 {
_ = args_iter;
var dir = try openFolder(.cache, .{});
defer dir.close();
const database_json = try curlAlloc(allocator, database_url);
defer allocator.free(database_json);
// Validate the json
var database = try anime.Info.fromJsonList(
&json.TokenStream.init(database_json),
allocator,
);
defer database.deinit(allocator);
var database_writing_job = async writeDatabaseFile(dir, database);
var update_image_cache_job = async updateImageCache(allocator, dir, &database);
try await database_writing_job;
try await update_image_cache_job;
return 0;
}
fn listMain(allocator: mem.Allocator) !u8 {
var cache_dir = try openFolder(.cache, .{});
defer cache_dir.close();
var data_dir = try openFolder(.data, .{});
defer data_dir.close();
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
const image_dir_path = try cache_dir.realpath(image_cache_name, &buf);
var list = blk: {
const data = data_dir.readFileAlloc(
allocator,
list_name,
math.maxInt(usize),
) catch |err| switch (err) {
error.FileNotFound => "",
else => |e| return e,
};
defer allocator.free(data);
break :blk try anime.List.fromDsv(allocator, data);
};
defer list.deinit(allocator);
const stdout = io.bufferedWriter(io.getStdOut().writer()).writer();
for (list.entries.items) |entry| {
try entry.writeToDsv(stdout);
try stdout.print("\t{s}/{s}\n", .{
image_dir_path,
bufToBase64(hash(entry.id)),
});
}
try stdout.context.flush();
return 0;
}
fn databaseMain(allocator: mem.Allocator) !u8 {
var dir = try openFolder(.cache, .{});
defer dir.close();
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
const image_dir_path = try dir.realpath(image_cache_name, &buf);
var database = readDatabaseFile(dir, allocator) catch |err| {
std.log.err("Could not read database file: {s}", .{@errorName(err)});
std.log.err("Try running 'anilist fetch' to download a new database", .{});
return 1;
};
defer database.deinit(allocator);
const stdout = io.bufferedWriter(io.getStdOut().writer()).writer();
for (database.items(.type)) |_, i| {
const info = database.get(i);
const id = info.id();
try stdout.print("{s}\t{}\t{s}\t{}\t{s}\t{s}{d}\t{s}/{s}\n", .{
@tagName(info.type),
info.year,
@tagName(info.season),
info.episodes,
mem.sliceTo(&info.title, 0),
id.site.url(),
id.id,
image_dir_path,
bufToBase64(hash(id)),
});
}
try stdout.context.flush();
return 0;
}
const Action = enum {
complete,
dropped,
on_hold,
plan_to_watch,
remove,
update,
watch_episode,
watching,
};
fn listManipulateMain(
allocator: mem.Allocator,
args_iter: *clap.args.OsIterator,
action: Action,
) !u8 {
var data_dir = try openFolder(.data, .{});
defer data_dir.close();
var list = blk: {
const data = data_dir.readFileAlloc(
allocator,
list_name,
math.maxInt(usize),
) catch |err| switch (err) {
error.FileNotFound => "",
else => |e| return e,
};
defer allocator.free(data);
break :blk try anime.List.fromDsv(allocator, data);
};
defer list.deinit(allocator);
var database = blk: {
var cache_dir = try openFolder(.cache, .{});
defer cache_dir.close();
break :blk try readDatabaseFile(cache_dir, allocator);
};
defer database.deinit(allocator);
while (try args_iter.next()) |anime_link|
try manipulateList(allocator, &list, &database, anime_link, action);
var file = try data_dir.atomicFile(list_name, .{});
defer file.deinit();
const writer = io.bufferedWriter(file.file.writer()).writer();
try list.writeToDsv(writer);
try writer.context.flush();
try file.finish();
return 0;
}
fn manipulateList(
allocator: mem.Allocator,
list: *anime.List,
database: *std.MultiArrayList(anime.Info),
link: []const u8,
action: Action,
) !void {
const link_id = try anime.Id.fromUrl(link);
const slice_to_search = switch (link_id.site) {
.anidb => database.items(.anidb),
.anilist => database.items(.anilist),
.anisearch => database.items(.anisearch),
.kitsu => database.items(.kitsu),
.livechart => database.items(.livechart),
.myanimelist => database.items(.myanimelist),
};
const i = for (slice_to_search) |id, i| {
if (link_id.id == id)
break i;
} else {
std.log.err("Anime '{s}' was not found in the database", .{link});
return error.NoSuchAnime;
};
const database_entry = database.get(i);
const entry = list.findWithId(link_id) orelse blk: {
const entry = try list.entries.addOne(allocator);
entry.* = .{
.date = datetime.Date.now(),
.status = .watching,
.episodes = 0,
.watched = 0,
.title = undefined,
.id = undefined,
};
break :blk entry;
};
// Always update the entry to have newest link id and title.
entry.id = database_entry.id();
entry.title = database_entry.title;
switch (action) {
.complete => {
if (entry.status != .complete)
entry.date = datetime.Date.now();
entry.status = .complete;
entry.watched += 1;
entry.episodes = database_entry.episodes;
},
.dropped => {
if (entry.status != .dropped)
entry.date = datetime.Date.now();
entry.watched = 0;
entry.status = .dropped;
},
.on_hold => {
if (entry.status != .on_hold)
entry.date = datetime.Date.now();
entry.watched = 0;
entry.status = .on_hold;
},
.plan_to_watch => {
if (entry.status != .plan_to_watch)
entry.date = datetime.Date.now();
entry.watched = 0;
entry.status = .plan_to_watch;
},
.watching => {
if (entry.status != .watching)
entry.date = datetime.Date.now();
entry.watched = 0;
entry.status = .watching;
},
.watch_episode => entry.episodes = math.min(
database_entry.episodes,
entry.episodes + 1,
),
.remove => {
const index = (@ptrToInt(entry) - @ptrToInt(list.entries.items.ptr)) /
@sizeOf(anime.Entry);
_ = list.entries.swapRemove(index);
},
.update => switch (entry.status) {
.complete => entry.episodes = database_entry.episodes,
.dropped, .on_hold, .plan_to_watch, .watching => entry.watched = 0,
},
}
}
// TODO: Replace with LiniarFifo.pump or fs.sendFile when these
// apies exists.
fn cat(reader: anytype, writer: anytype) !void {
var buf: [mem.page_size]u8 = undefined;
while (true) {
const read_len = try reader.read(&buf);
if (read_len == 0)
break;
try writer.writeAll(buf[0..read_len]);
}
}
fn openFolder(folder: folders.KnownFolder, flags: fs.Dir.OpenDirOptions) !fs.Dir {
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
var fba = heap.FixedBufferAllocator.init(&buf);
var dir = (try folders.open(fba.allocator(), folder, flags)) orelse
return error.NoCacheDir;
defer dir.close();
return makeAndOpenDir(dir, program_name);
}
fn updateImageCache(allocator: mem.Allocator, dir: fs.Dir, database: *std.MultiArrayList(anime.Info)) !void {
var image_dir = try makeAndOpenDir(dir, image_cache_name);
defer image_dir.close();
var result = std.ArrayList(u8).init(allocator);
defer result.deinit();
var progress = std.Progress{};
const root_node = try progress.start("", database.len);
defer root_node.end();
// TODO: Have a channel, and push links into that channel. Have N
// jobs that pulls download tasks from the channel and downloads
// in parallel.
for (database.items(.image)) |*image, i| {
const image_name = bufToBase64(hash(image));
if (image_dir.createFile(&image_name, .{ .exclusive = true })) |file| {
errdefer image_dir.deleteFile(&image_name) catch {};
defer file.close();
// File didn't exist. Download it!
result.resize(0) catch unreachable;
try curl(result.writer(), mem.sliceTo(image, 0));
// Some images might have moved. In that case the html will specify
// the new position.
const url_start = "<p>The document has moved <a href=\"";
while (mem.indexOf(u8, result.items, url_start)) |url_start_index| {
const start = url_start_index + url_start.len;
const end = mem.indexOfPos(u8, result.items, start, "\"") orelse break;
const link = try allocator.dupe(u8, result.items[start..end]);
defer allocator.free(link);
result.resize(0) catch unreachable;
try curl(result.writer(), link);
}
try file.writeAll(result.items);
} else |err| switch (err) {
error.PathAlreadyExists => {},
else => |new_err| return new_err,
}
const id = database.get(i).id();
const link_name = bufToBase64(hash(id));
image_dir.deleteFile(&link_name) catch {};
image_dir.symLink(&image_name, &link_name, .{}) catch |err| switch (err) {
error.PathAlreadyExists => {},
else => |new_err| return new_err,
};
root_node.completeOne();
}
}
fn hash(things: anytype) [24]u8 {
var out: [24]u8 = undefined;
var hasher = std.crypto.hash.Blake3.init(.{});
std.hash.autoHashStrat(&hasher, things, .DeepRecursive);
hasher.final(&out);
return out;
}
fn bufToBase64(buf: anytype) [fs.base64_encoder.calcSize(buf.len)]u8 {
var res: [fs.base64_encoder.calcSize(buf.len)]u8 = undefined;
_ = fs.base64_encoder.encode(&res, &buf);
return res;
}
fn makeAndOpenDir(dir: fs.Dir, sub_path: []const u8) !fs.Dir {
dir.makeDir(sub_path) catch |err| switch (err) {
error.PathAlreadyExists => {},
else => |new_err| return new_err,
};
return dir.openDir(sub_path, .{});
}
fn writeDatabaseFile(dir: fs.Dir, database: std.MultiArrayList(anime.Info)) !void {
var file = try dir.atomicFile(database_name, .{});
defer file.deinit();
const Enum = meta.FieldEnum(anime.Info);
inline for (@typeInfo(anime.Info).Struct.fields) |field| {
const field_enum = comptime meta.stringToEnum(Enum, field.name).?;
try file.file.writeAll(mem.sliceAsBytes(database.items(field_enum)));
}
try file.finish();
}
fn readDatabaseFile(dir: fs.Dir, allocator: mem.Allocator) !std.MultiArrayList(anime.Info) {
const info_size = comptime blk: {
var res: usize = 0;
for (@typeInfo(anime.Info).Struct.fields) |field|
res += @sizeOf(field.field_type);
break :blk res;
};
var res = std.MultiArrayList(anime.Info){};
errdefer res.deinit(allocator);
const file = try dir.openFile(database_name, .{});
defer file.close();
const stat = try file.stat();
const count = @intCast(usize, stat.size / info_size);
try res.resize(allocator, count);
@setEvalBranchQuota(10000);
const Enum = meta.FieldEnum(anime.Info);
inline for (@typeInfo(anime.Info).Struct.fields) |field| {
const field_enum = comptime meta.stringToEnum(Enum, field.name).?;
try file.reader().readNoEof(mem.sliceAsBytes(res.items(field_enum)));
}
return res;
}
fn curlAlloc(allocator: mem.Allocator, link: []const u8) ![]u8 {
var list = std.ArrayList(u8).init(allocator);
errdefer list.deinit();
try curl(list.writer(), link);
return list.toOwnedSlice();
}
fn curl(writer: anytype, link: []const u8) !void {
var alloc_buf: [std.mem.page_size * 10]u8 = undefined;
var fba = heap.FixedBufferAllocator.init(&alloc_buf);
const proc = try std.ChildProcess.init(&[_][]const u8{ "curl", "-s", link }, fba.allocator());
proc.stdin_behavior = .Ignore;
proc.stderr_behavior = .Ignore;
proc.stdout_behavior = .Pipe;
try proc.spawn();
errdefer _ = proc.kill() catch undefined;
try cat(proc.stdout.?.reader(), writer);
switch (try proc.wait()) {
.Exited => |status| if (status != 0) return error.CurlFailed,
else => return error.CurlFailed,
}
} | src/main.zig |
const std = @import("std");
const warn = std.debug.warn;
const assert = std.debug.assert;
const File = std.fs.File;
const files = @import("../Files.zig");
const loadFile = files.loadFile;
pub const c = @cImport({
@cInclude("stb_image.h");
});
fn save(path: []const u8, w: u32, h: u32, data: []const u8) !void {
assert(data.len == w * h * 4);
var file = try std.fs.cwd().openFile(path, std.fs.File.OpenFlags{ .write = true });
defer file.close();
// Magic bytes
const header = [8]u8{ 0x00, 0x72, 0x67, 0x62, 0x31, 0x30, 0x61, 0x32 };
_ = try file.write(header[0..]);
_ = try file.write(@ptrCast([*c]const u8, &w)[0..4]);
_ = try file.write(@ptrCast([*c]const u8, &h)[0..4]);
_ = try file.write(data);
}
pub fn convertFile(path: []const u8, output_file_path: []const u8, allocator: *std.mem.Allocator) !void {
var input_file_data = try loadFile(path, allocator);
defer allocator.free(input_file_data);
var w: i32 = 0;
var h: i32 = 0;
var n: i32 = 0;
const decoded_png = c.stbi_load_16_from_memory(input_file_data.ptr, @intCast(c_int, input_file_data.len), @ptrCast([*c]c_int, &w), @ptrCast([*c]c_int, &h), @ptrCast([*c]c_int, &n), 4);
if (decoded_png == null) {
return error.ImageDecodeError;
}
defer c.stbi_image_free(decoded_png);
const w_u32 = @intCast(u32, w);
const h_u32 = @intCast(u32, h);
var decoded_png_u16 = std.mem.bytesAsSlice(u16, std.mem.sliceAsBytes(decoded_png[0..(w_u32 * h_u32 * 4)]));
var converted_data = try allocator.alloc(u32, w_u32 * h_u32);
defer allocator.free(converted_data);
// Convert bit depth from rgba16 to rgb10a2
var src: u32 = 0; // Index into decoded_png_u16
var dst: u32 = 0; // Index into converted_data
var y: u32 = 0;
while (y < h_u32) : (y += 1) {
var x: u32 = 0;
while (x < w_u32) : (x += 1) {
const a = @intCast(u32, (decoded_png_u16[src + 3] >> 14)) << 0;
const r = (decoded_png_u16[src + 2] >> 6) << 2;
const g = @intCast(u32, (decoded_png_u16[src + 1] >> 6)) << 12;
const b = @intCast(u32, (decoded_png_u16[src + 0] >> 6)) << 22;
converted_data[dst] = r | g | b | a;
src += 4;
dst += 1;
}
}
////
try save(output_file_path, w_u32, h_u32, std.mem.sliceAsBytes(converted_data));
} | src/RGB10A2/RGB10A2.zig |
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
const lib = b.addStaticLibrary("zorro", "src/main.zig");
lib.setBuildMode(mode);
lib.install();
const main_tests = b.addTest("src/main.zig");
main_tests.setBuildMode(mode);
const test_step = b.step("test", "Run library tests");
test_step.dependOn(&main_tests.step);
// TODO test this and force user to make explicit decision what to use
//const build_z3 = b.step("build_z3", "Build Z3, assumes Z3 is in folder z3");
//{
// const z3_buildpath = "z3/build";
// fs.cwd().makePath(z3_buildpath) catch {}; // unconditionally create build folder
// const buildprep_cmd = b.addSystemCommand(&[_][]const u8{
// "cd",
// z3_buildpath,
// "; ",
// "CC='zig cc'" CXX='zig c++'",
// "cmake",
// "..",
// "-GNinja",
// });
// const build_cmd = b.addSystemCommand(&[_][]const u8{
// "cd",
// z3_buildpath,
// "; ",
// "ninja",
// });
// build_cmd.dependOn(&buildprep_cmd.step);
// build_z3.dependOn(&build_cmd.step);
//}
const z3_inc_c = "./z3/src/api";
const z3_inc_cpp = "./z3/src/api/c++";
const z3_lib = "./z3/build";
const proof_folder = "./src/pcrt";
const exe = b.addExecutable("runProofs", null);
exe.setTarget(target);
exe.setBuildMode(mode);
exe.linkLibCpp();
exe.addIncludePath(z3_inc_c);
exe.addIncludePath(z3_inc_cpp);
exe.addLibPath(z3_lib);
exe.linkSystemLibraryName("z3");
exe.addIncludePath(proof_folder); // this also makes the header usable
exe.addCSourceFile("src/pcrt/mulv.cpp", &[_][]const u8{});
exe.addCSourceFile("src/pcrt/main.cpp", &[_][]const u8{});
exe.install();
const run_cmd = exe.run(); // returns *RunStep that can be used with step()
run_cmd.step.dependOn(b.getInstallStep());
//if (b.args) |args| {
// run_cmd.addArgs(args);
//}
const run_step = b.step("prove", "Run all proofs with Z3");
run_step.dependOn(&run_cmd.step);
// TODO make system libs usable
// system lib paths, which pkg-config does not provide for inclusion
//const z3_inc_c = "/usr/include";
//const z3_lib = "/usr/lib";
//const exe = b.addExecutable("example", null);
//exe.setBuildMode(mode);
//exe.install();
//exe.linkLibCpp();
//exe.addSystemIncludeDir(z3_inc_c);
//exe.addLibPath(z3_lib);
//exe.linkSystemLibraryName("z3");
//exe.addCSourceFile("src/pcrt/min.cpp", &[_][]const u8{});
} | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const nvg = @import("nanovg");
const gui = @import("../gui.zig");
const Point = @import("../geometry.zig").Point;
const Rect = @import("../geometry.zig").Rect;
const Button = @This();
pub const ButtonStyle = enum(u8) {
default,
toolbar,
};
widget: gui.Widget,
allocator: Allocator,
text: [:0]const u8,
font_size: f32 = 12,
iconFn: ?fn (vg: nvg) void = null,
icon_x: f32 = 2,
icon_y: f32 = 2,
style: ButtonStyle = .default,
hovered: bool = false,
focused: bool = false,
pressed: bool = false,
checked: bool = false,
auto_repeat_timer: gui.Timer,
auto_repeat_interval: u32 = 0, // in milliseconds
onClickFn: ?fn (*Self) void = null,
onEnterFn: ?fn (*Self) void = null,
onLeaveFn: ?fn (*Self) void = null,
const Self = @This();
pub fn init(allocator: Allocator, rect: Rect(f32), text: [:0]const u8) !*Self {
var self = try allocator.create(Self);
self.* = Self{
.widget = gui.Widget.init(allocator, rect),
.allocator = allocator,
.text = text,
.auto_repeat_timer = gui.Timer{
.on_elapsed_fn = onAutoRepeatTimerElapsed,
.ctx = @ptrToInt(self),
},
};
self.widget.focus_policy.mouse = true;
self.widget.focus_policy.keyboard = true;
self.widget.drawFn = draw;
self.widget.onMouseDownFn = onMouseDown;
self.widget.onMouseUpFn = onMouseUp;
self.widget.onKeyDownFn = onKeyDown;
self.widget.onKeyUpFn = onKeyUp;
self.widget.onFocusFn = onFocus;
self.widget.onBlurFn = onBlur;
self.widget.onEnterFn = onEnter;
self.widget.onLeaveFn = onLeave;
return self;
}
pub fn deinit(self: *Self) void {
self.auto_repeat_timer.stop();
self.widget.deinit();
self.allocator.destroy(self);
}
fn click(self: *Self) void {
if (!self.widget.isEnabled()) return;
if (self.onClickFn) |clickFn| {
clickFn(self);
}
}
pub fn onMouseDown(widget: *gui.Widget, mouse_event: *const gui.MouseEvent) void {
if (!widget.isEnabled()) return;
const self = @fieldParentPtr(Self, "widget", widget);
const mouse_position = Point(f32).make(mouse_event.x, mouse_event.y);
self.hovered = widget.getRect().contains(mouse_position);
if (mouse_event.button == .left) {
if (self.hovered) {
self.pressed = true;
if (self.auto_repeat_interval > 0) {
self.click();
self.auto_repeat_timer.start(self.auto_repeat_interval);
}
}
}
}
fn onMouseUp(widget: *gui.Widget, mouse_event: *const gui.MouseEvent) void {
if (!widget.isEnabled()) return;
const self = @fieldParentPtr(Self, "widget", widget);
const mouse_position = Point(f32).make(mouse_event.x, mouse_event.y);
self.hovered = widget.getRect().contains(mouse_position);
if (mouse_event.button == .left) {
self.pressed = false;
self.auto_repeat_timer.stop();
if (self.hovered and self.auto_repeat_interval == 0) {
self.click();
}
}
}
fn onKeyDown(widget: *gui.Widget, key_event: *gui.KeyEvent) void {
widget.onKeyDown(key_event);
const self = @fieldParentPtr(Self, "widget", widget);
if (key_event.key == .Space) {
self.pressed = true;
}
}
fn onKeyUp(widget: *gui.Widget, key_event: *gui.KeyEvent) void {
const self = @fieldParentPtr(Self, "widget", widget);
if (key_event.key == .Space and self.pressed) {
self.pressed = false;
self.click();
}
}
fn onFocus(widget: *gui.Widget, focus_event: *gui.FocusEvent) void {
const self = @fieldParentPtr(Self, "widget", widget);
self.focused = focus_event.source == .keyboard;
}
fn onBlur(widget: *gui.Widget, _: *gui.FocusEvent) void {
const self = @fieldParentPtr(Self, "widget", widget);
self.pressed = false;
}
fn onEnter(widget: *gui.Widget) void {
const self = @fieldParentPtr(Self, "widget", widget);
self.hovered = true;
if (self.onEnterFn) |enterFn| enterFn(self);
}
fn onLeave(widget: *gui.Widget) void {
const self = @fieldParentPtr(Self, "widget", widget);
self.hovered = false;
if (self.onLeaveFn) |leaveFn| leaveFn(self);
}
fn onAutoRepeatTimerElapsed(context: usize) void {
var button = @intToPtr(*Button, context);
if (button.onClickFn) |onClickFn| {
onClickFn(button);
}
}
pub fn draw(widget: *gui.Widget, vg: nvg) void {
const self = @fieldParentPtr(Self, "widget", widget);
const rect = widget.relative_rect;
const enabled = widget.isEnabled();
if (!widget.isFocused()) self.focused = false;
switch (self.style) {
.default => {
gui.drawPanel(vg, rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 2, 1, enabled and self.hovered, (enabled and self.pressed) or self.checked);
// border
vg.beginPath();
if (self.focused) {
vg.rect(rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 2);
vg.strokeWidth(2);
} else {
vg.rect(rect.x + 0.5, rect.y + 0.5, rect.w - 1, rect.h - 1);
}
vg.strokeColor(gui.theme_colors.border);
vg.stroke();
vg.strokeWidth(1);
},
.toolbar => {
if ((enabled and self.hovered) or self.checked) {
const depth: f32 = 1;
gui.drawPanel(vg, rect.x, rect.y, rect.w, rect.h, depth, false, (enabled and self.pressed) or self.checked);
}
},
}
// vg.beginPath();
// vg.roundedRect(rect.x + 1.5, rect.y + 1.5, rect.w - 3, rect.h - 3, 1);
// vg.fillColor(gui.theme_colors.background);
// vg.fill();
// vg.strokeColor(gui.theme_colors.light);
// vg.stroke();
// vg.beginPath();
// vg.roundedRect(rect.x + 0.5, rect.y + 0.5, rect.w - 1, rect.h - 1, 2);
// vg.strokeColor(gui.theme_colors.border);
// vg.stroke();
vg.fontFace("guifont");
vg.fontSize(self.font_size);
vg.textAlign(.{ .horizontal = .center, .vertical = .middle });
vg.fillColor(nvg.rgb(0, 0, 0));
_ = vg.text(rect.x + 0.5 * rect.w, rect.y + 0.5 * rect.h, self.text);
if (self.iconFn) |iconFn| {
vg.save();
vg.translate(rect.x + self.icon_x, rect.y + self.icon_y);
iconFn(vg);
vg.restore();
}
} | src/gui/widgets/Button.zig |
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const _value = @import("./value.zig");
const _chunk = @import("./chunk.zig");
const _disassembler = @import("./disassembler.zig");
const _obj = @import("./obj.zig");
const Allocator = std.mem.Allocator;
const Config = @import("./config.zig").Config;
const Value = _value.Value;
const HashableValue = _value.HashableValue;
const ValueType = _value.ValueType;
const valueToHashable = _value.valueToHashable;
const hashableToValue = _value.hashableToValue;
const valueToString = _value.valueToString;
const valueEql = _value.valueEql;
const valueIs = _value.valueIs;
const ObjType = _obj.ObjType;
const Obj = _obj.Obj;
const ObjNative = _obj.ObjNative;
const ObjString = _obj.ObjString;
const ObjUpValue = _obj.ObjUpValue;
const ObjClosure = _obj.ObjClosure;
const ObjFunction = _obj.ObjFunction;
const ObjObjectInstance = _obj.ObjObjectInstance;
const ObjObject = _obj.ObjObject;
const ObjectDef = _obj.ObjectDef;
const ObjList = _obj.ObjList;
const ObjMap = _obj.ObjMap;
const ObjEnum = _obj.ObjEnum;
const ObjEnumInstance = _obj.ObjEnumInstance;
const ObjBoundMethod = _obj.ObjBoundMethod;
const ObjTypeDef = _obj.ObjTypeDef;
const allocateObject = _obj.allocateObject;
const allocateString = _obj.allocateString;
const OpCode = _chunk.OpCode;
const Chunk = _chunk.Chunk;
const disassembleChunk = _disassembler.disassembleChunk;
const dumpStack = _disassembler.dumpStack;
pub const CallFrame = struct {
const Self = @This();
closure: *ObjClosure,
// Index into closure's chunk
ip: usize,
// Frame
slots: [*]Value,
// Default value in case of error
error_value: ?Value = null,
// Error handlers
error_handlers: std.ArrayList(*ObjClosure),
// Line in source code where the call occured
call_site: ?usize,
};
pub const VM = struct {
const Self = @This();
pub const Error = error{
UnwrappedNull,
OutOfBound,
NumberOverflow,
Custom, // TODO: remove when user can use this set directly in buzz code
} || Allocator.Error || std.fmt.BufPrintError;
allocator: Allocator,
frames: std.ArrayList(CallFrame),
frame_count: u64 = 0,
// TODO: put ta limit somewhere
stack: []Value,
stack_top: [*]Value,
globals: std.ArrayList(Value),
// Interned strings
strings: *std.StringHashMap(*ObjString),
open_upvalues: ?*ObjUpValue,
bytes_allocated: usize = 0,
next_gc: usize = if (Config.debug_gc) 1024 else 1024 * 1024,
// TODO: replace with SinglyLinkedList(*Obj)
objects: ?*Obj = null,
gray_stack: std.ArrayList(*Obj),
pub fn init(allocator: Allocator, strings: *std.StringHashMap(*ObjString)) !Self {
var self: Self = .{
.allocator = allocator,
.stack = try allocator.alloc(Value, 1000000),
.stack_top = undefined,
.globals = std.ArrayList(Value).init(allocator),
.frames = std.ArrayList(CallFrame).init(allocator),
.strings = strings,
.open_upvalues = null,
.gray_stack = std.ArrayList(*Obj).init(allocator),
};
self.stack_top = @ptrCast([*]Value, self.stack[0..]);
return self;
}
pub fn deinit(self: *Self) void {
self.allocator.free(self.stack);
self.frames.deinit();
// TODO: free all objects except exported ones (be careful of indirected exported stuff like object of objectinstance)
self.gray_stack.deinit();
// TODO: we can't free this because exported closure refer to it
// self.globals.deinit();
}
pub fn pushArgs(self: *Self, args: ?[][:0]u8) !void {
// TODO: 3 steps to do this is horrible -> helper functions please
var list_def: ObjList.ListDef = ObjList.ListDef.init(
self.allocator,
try allocateObject(
self,
ObjTypeDef,
ObjTypeDef{ .def_type = .String },
),
);
var list_def_union: ObjTypeDef.TypeUnion = .{
.List = list_def,
};
var list_def_type: *ObjTypeDef = try allocateObject(self, ObjTypeDef, ObjTypeDef{
.def_type = .List,
.optional = false,
.resolved_type = list_def_union,
});
var list: *ObjList = try allocateObject(
self,
ObjList,
ObjList.init(self.allocator,
// TODO: get instance that already exists
list_def_type),
);
// Args is the first local like `this` which replace the closure itself in the stack
(self.stack_top - 1)[0] = list.toValue();
if (args) |uargs| {
for (uargs) |arg| {
try list.items.append(
Value{
.Obj = (try _obj.copyString(self, std.mem.sliceTo(arg, 0))).toObj(),
},
);
}
}
}
pub fn push(self: *Self, value: Value) void {
self.stack_top[0] = value;
self.stack_top += 1;
}
pub fn pop(self: *Self) Value {
self.stack_top -= 1;
return self.stack_top[0];
}
pub fn peek(self: *Self, distance: u32) Value {
return (self.stack_top - 1 - distance)[0];
}
pub fn copy(self: *Self, n: u24) void {
if (n == 0) {
self.push(self.peek(0));
return;
}
var i = n - 1;
while (i >= 0) : (i -= 1) {
self.push(self.peek(i));
if (i == 0) {
break;
}
}
}
fn swap(self: *Self, from: u8, to: u8) void {
var temp: Value = (self.stack_top - to - 1)[0];
(self.stack_top - to - 1)[0] = (self.stack_top - from - 1)[0];
(self.stack_top - from - 1)[0] = temp;
}
pub inline fn currentFrame(self: *Self) ?*CallFrame {
if (self.frame_count == 0) {
return null;
}
return &self.frames.items[self.frame_count - 1];
}
pub inline fn currentGlobals(self: *Self) *std.ArrayList(Value) {
return self.currentFrame().?.closure.globals;
}
pub fn interpret(self: *Self, function: *ObjFunction, args: ?[][:0]u8) Error!void {
self.push(.{ .Obj = function.toObj() });
var closure: *ObjClosure = try allocateObject(
self,
ObjClosure,
try ObjClosure.init(self.allocator, self, function),
);
_ = self.pop();
self.push(.{ .Obj = closure.toObj() });
// Command line arguments are the first local
try self.pushArgs(args);
_ = try self.call(closure, 0, null);
return try self.run();
}
fn readInstruction(self: *Self) u32 {
const current_frame: *CallFrame = self.currentFrame().?;
var instruction: u32 = current_frame.closure.function.chunk.code.items[current_frame.ip];
current_frame.ip += 1;
return instruction;
}
inline fn getCode(instruction: u32) OpCode {
return @intToEnum(OpCode, @intCast(u8, instruction >> 24));
}
inline fn getArg(instruction: u32) u24 {
return @intCast(u24, 0x00ffffff & instruction);
}
inline fn readByte(self: *Self) u8 {
return @intCast(u8, self.readInstruction());
}
inline fn readOpCode(self: *Self) OpCode {
// TODO: measure if [*]OpCode[0] is faster
var opcode: OpCode = @intToEnum(
OpCode,
self.currentFrame().?.closure.function.chunk.code.items[self.currentFrame().?.ip],
);
self.currentFrame().?.ip += 1;
return opcode;
}
inline fn readConstant(self: *Self, arg: u24) Value {
return self.currentFrame().?.closure.function.chunk.constants.items[arg];
}
inline fn readString(self: *Self, arg: u24) *ObjString {
return ObjString.cast(self.readConstant(arg).Obj).?;
}
fn run(self: *Self) Error!void {
while (true) {
const current_frame: *CallFrame = self.currentFrame().?;
var full_instruction: u32 = self.readInstruction();
var instruction: OpCode = getCode(full_instruction);
var arg: u24 = getArg(full_instruction);
if (Config.debug_current_instruction) {
std.debug.print(
"{}: {}\n",
.{
current_frame.ip,
instruction,
},
);
}
switch (instruction) {
.OP_NULL => self.push(Value{ .Null = null }),
.OP_VOID => self.push(Value{ .Void = null }),
.OP_TRUE => self.push(Value{ .Boolean = true }),
.OP_FALSE => self.push(Value{ .Boolean = false }),
.OP_POP => _ = self.pop(),
.OP_COPY => self.copy(arg),
.OP_SWAP => self.swap(@intCast(u8, arg), self.readByte()),
.OP_DEFINE_GLOBAL => {
try self.globals.ensureTotalCapacity(arg + 1);
self.globals.expandToCapacity();
self.globals.items[arg] = self.peek(0);
_ = self.pop();
},
.OP_GET_GLOBAL => self.push(self.currentGlobals().items[arg]),
.OP_SET_GLOBAL => self.currentGlobals().items[arg] = self.peek(0),
.OP_GET_LOCAL => self.push(current_frame.slots[arg]),
.OP_SET_LOCAL => current_frame.slots[arg] = self.peek(0),
.OP_GET_UPVALUE => self.push(current_frame.closure.upvalues.items[arg].location.*),
.OP_SET_UPVALUE => current_frame.closure.upvalues.items[arg].location.* = self.peek(0),
.OP_CONSTANT => self.push(self.readConstant(arg)),
.OP_TO_STRING => {
var str = try valueToString(self.allocator, self.pop());
defer self.allocator.free(str);
self.push(
Value{
.Obj = (try _obj.copyString(self, str)).toObj(),
},
);
},
.OP_NEGATE => self.push(Value{ .Number = -self.pop().Number }),
.OP_CLOSURE => {
var function: *ObjFunction = ObjFunction.cast(self.readConstant(arg).Obj).?;
var closure: *ObjClosure = try allocateObject(
self,
ObjClosure,
try ObjClosure.init(self.allocator, self, function),
);
self.push(Value{ .Obj = closure.toObj() });
var i: usize = 0;
while (i < function.upvalue_count) : (i += 1) {
var is_local: bool = self.readByte() == 1;
var index: u8 = self.readByte();
if (is_local) {
try closure.upvalues.append(try self.captureUpvalue(&(current_frame.slots[index])));
} else {
try closure.upvalues.append(current_frame.closure.upvalues.items[index]);
}
}
},
.OP_CLOSE_UPVALUE => {
self.closeUpValues(@ptrCast(*Value, self.stack_top - 1));
_ = self.pop();
},
.OP_CALL => {
const arg_count: u8 = @intCast(u8, (0x00ffffff & full_instruction) >> 16);
const catch_count: u16 = @intCast(u16, 0x0000ffff & full_instruction);
var catch_values = std.ArrayList(Value).init(self.allocator);
defer catch_values.deinit();
var i: u16 = 0;
while (i < catch_count) : (i += 1) {
try catch_values.append(self.pop());
}
try self.callValue(self.peek(arg_count), arg_count, catch_values);
},
.OP_INVOKE => {
const method: *ObjString = self.readString(arg);
const arg_instruction: u32 = self.readInstruction();
const arg_count: u8 = @intCast(u8, arg_instruction >> 24);
const catch_count: u24 = @intCast(u8, 0x00ffffff & arg_instruction);
var catch_values = std.ArrayList(Value).init(self.allocator);
defer catch_values.deinit();
var i: u16 = 0;
while (i < catch_count) : (i += 1) {
try catch_values.append(self.pop());
}
try self.invoke(method, arg_count, catch_values);
},
.OP_SUPER_INVOKE => {
const method: *ObjString = self.readString(arg);
const arg_instruction: u32 = self.readInstruction();
const arg_count: u8 = @intCast(u8, arg_instruction >> 24);
const catch_count: u24 = @intCast(u8, 0x00ffffff & arg_instruction);
var catch_values = std.ArrayList(Value).init(self.allocator);
defer catch_values.deinit();
var i: u16 = 0;
while (i < catch_count) : (i += 1) {
try catch_values.append(self.pop());
}
const super_class: *ObjObject = ObjObject.cast(self.pop().Obj).?;
try self.invokeFromObject(super_class, method, arg_count, catch_values);
},
.OP_RETURN => {
if (self.returnFrame()) {
return;
}
},
.OP_EXPORT => {
self.push(Value{ .Number = @intToFloat(f64, arg) });
return;
},
.OP_IMPORT => try self.import(self.peek(0)),
.OP_THROW => try self.throw(Error.Custom, self.pop()),
.OP_LIST => {
var list: *ObjList = try allocateObject(
self,
ObjList,
ObjList.init(self.allocator, ObjTypeDef.cast(self.readConstant(arg).Obj).?),
);
self.push(Value{ .Obj = list.toObj() });
},
.OP_LIST_APPEND => try self.appendToList(),
.OP_MAP => {
var map: *ObjMap = try allocateObject(self, ObjMap, ObjMap.init(
self.allocator,
ObjTypeDef.cast(self.readConstant(arg).Obj).?,
));
self.push(Value{ .Obj = map.toObj() });
},
.OP_SET_MAP => {
var map: *ObjMap = ObjMap.cast(self.peek(2).Obj).?;
var key: Value = self.peek(1);
var value: Value = self.peek(0);
try map.map.put(valueToHashable(key), value);
_ = self.pop();
_ = self.pop();
},
.OP_GET_SUBSCRIPT => try self.subscript(),
.OP_SET_SUBSCRIPT => try self.setSubscript(),
.OP_ENUM => {
var enum_: *ObjEnum = try allocateObject(
self,
ObjEnum,
ObjEnum.init(self.allocator, ObjTypeDef.cast(self.readConstant(arg).Obj).?),
);
self.push(Value{ .Obj = enum_.toObj() });
},
.OP_ENUM_CASE => try self.defineEnumCase(),
.OP_GET_ENUM_CASE => {
var enum_: *ObjEnum = ObjEnum.cast(self.peek(0).Obj).?;
_ = self.pop();
var enum_case: *ObjEnumInstance = try allocateObject(self, ObjEnumInstance, ObjEnumInstance{
.enum_ref = enum_,
.case = @intCast(u8, arg),
});
self.push(Value{ .Obj = enum_case.toObj() });
},
.OP_GET_ENUM_CASE_VALUE => {
var enum_case: *ObjEnumInstance = ObjEnumInstance.cast(self.peek(0).Obj).?;
_ = self.pop();
self.push(enum_case.enum_ref.cases.items[enum_case.case]);
},
.OP_OBJECT => {
var object: *ObjObject = try allocateObject(
self,
ObjObject,
ObjObject.init(
self.allocator,
ObjString.cast(self.readConstant(arg).Obj).?,
ObjTypeDef.cast(self.readConstant(@intCast(u24, self.readInstruction())).Obj).?,
),
);
self.push(Value{ .Obj = object.toObj() });
},
.OP_INHERIT => {
ObjObject.cast(self.pop().Obj).?.super = ObjObject.cast(self.currentGlobals().items[arg].Obj).?;
},
.OP_GET_SUPER => {
const name: *ObjString = self.readString(arg);
const super_class: *ObjObject = ObjObject.cast(self.pop().Obj).?;
try self.bindMethod(super_class.methods.get(name.string).?, null);
},
.OP_INSTANCE => try self.instanciateObject(ObjObject.cast(self.pop().Obj).?),
.OP_METHOD => try self.defineMethod(self.readString(arg)),
// Like OP_SET_PROPERTY but pops the value and leaves the instance on the stack
.OP_PROPERTY => try self.setObjectFieldDefaultValue(self.readString(arg)),
.OP_GET_PROPERTY => {
var obj: *Obj = self.peek(0).Obj;
switch (obj.obj_type) {
.Object => {
const object: *ObjObject = ObjObject.cast(obj).?;
const name: *ObjString = self.readString(arg);
_ = self.pop(); // Pop instance
self.push(object.static_fields.get(name.string).?);
},
.ObjectInstance => {
const instance: *ObjObjectInstance = ObjObjectInstance.cast(obj).?;
const name: *ObjString = self.readString(arg);
if (instance.fields.get(name.string)) |field| {
_ = self.pop(); // Pop instance
self.push(field);
} else if (instance.object.methods.get(name.string)) |method| {
try self.bindMethod(method, null);
} else if (instance.object.super) |super| {
try self.getSuperField(name.string, super);
} else {
unreachable;
}
},
.Enum => {
unreachable;
},
.List => {
const list = ObjList.cast(obj).?;
const name: *ObjString = self.readString(arg);
if (try list.member(self, name.string)) |member| {
try self.bindMethod(null, member);
} else {
unreachable;
}
},
.String => {
const name: *ObjString = self.readString(arg);
if (try ObjString.member(self, name.string)) |member| {
try self.bindMethod(null, member);
} else {
unreachable;
}
},
else => unreachable,
}
},
.OP_SET_PROPERTY => {
var obj: *Obj = self.peek(1).Obj;
switch (obj.obj_type) {
.ObjectInstance => {
const instance: *ObjObjectInstance = ObjObjectInstance.cast(obj).?;
const name: *ObjString = self.readString(arg);
// Set new value
try instance.fields.put(name.string, self.peek(0));
// Get the new value from stack, pop the instance and push value again
const value: Value = self.pop();
_ = self.pop();
self.push(value);
},
.Object => {
const object: *ObjObject = ObjObject.cast(obj).?;
const name: *ObjString = self.readString(arg);
// Set new value
try object.static_fields.put(name.string, self.peek(0));
// Get the new value from stack, pop the object and push value again
const value: Value = self.pop();
_ = self.pop();
self.push(value);
},
else => unreachable,
}
},
// TODO: remove
.OP_PRINT => {
var value_str: []const u8 = try valueToString(self.allocator, self.pop());
defer self.allocator.free(value_str);
std.debug.print("{s}\n", .{value_str});
},
.OP_NOT => self.push(Value{ .Boolean = !self.pop().Boolean }),
.OP_GREATER => {
const left: f64 = self.pop().Number;
const right: f64 = self.pop().Number;
self.push(Value{ .Boolean = right > left });
},
.OP_LESS => {
const left: f64 = self.pop().Number;
const right: f64 = self.pop().Number;
self.push(Value{ .Boolean = right < left });
},
.OP_ADD,
.OP_SUBTRACT,
.OP_MULTIPLY,
.OP_DIVIDE,
.OP_MOD,
=> try self.binary(instruction),
.OP_EQUAL => self.push(Value{ .Boolean = valueEql(self.pop(), self.pop()) }),
.OP_IS => self.push(Value{ .Boolean = valueIs(self.pop(), self.pop()) }),
.OP_JUMP => current_frame.ip += arg,
.OP_JUMP_IF_FALSE => {
if (!self.peek(0).Boolean) {
current_frame.ip += arg;
}
},
.OP_LOOP => current_frame.ip -= arg,
.OP_FOREACH => try self.foreach(),
.OP_UNWRAP => {
if (self.peek(0) == .Null) {
try self.throw(Error.UnwrappedNull, (try _obj.copyString(self, "Force unwrapped optional is null")).toValue());
}
},
.OP_NULL_OR => {
if (self.peek(1) == .Null) {
var else_: Value = self.peek(0);
// Pop operands
_ = self.pop();
_ = self.pop();
// Push left operand
self.push(else_);
} else {
_ = self.pop(); // Pop right operand
}
},
else => {
std.debug.print("{} not yet implemented\n", .{instruction});
std.os.exit(1);
},
}
if (Config.debug_stack) {
std.debug.print(
"frame: {s}, code: {}\n",
.{
current_frame.closure.function.name.string,
instruction,
},
);
try dumpStack(self);
}
}
return true;
}
fn foreach(self: *Self) !void {
var iterable_value: Value = self.peek(0);
var iterable: *Obj = iterable_value.Obj;
switch (iterable.obj_type) {
.String => {
var key_slot: *Value = @ptrCast(*Value, self.stack_top - 3);
var value_slot: *Value = @ptrCast(*Value, self.stack_top - 2);
var str: *ObjString = ObjString.cast(iterable).?;
key_slot.* = if (try str.next(self, if (key_slot.* == .Null) null else key_slot.Number)) |new_index|
Value{ .Number = new_index }
else
Value{ .Null = null };
// Set new value
if (key_slot.* != .Null) {
value_slot.* = (try _obj.copyString(self, &([_]u8{str.string[@floatToInt(usize, key_slot.Number)]}))).toValue();
}
},
.List => {
var key_slot: *Value = @ptrCast(*Value, self.stack_top - 3);
var value_slot: *Value = @ptrCast(*Value, self.stack_top - 2);
var list: *ObjList = ObjList.cast(iterable).?;
// Get next index
key_slot.* = if (try list.rawNext(self, if (key_slot.* == .Null) null else key_slot.Number)) |new_index|
Value{ .Number = new_index }
else
Value{ .Null = null };
// Set new value
if (key_slot.* != .Null) {
value_slot.* = list.items.items[@floatToInt(usize, key_slot.Number)];
}
},
.Enum => {
var value_slot: *Value = @ptrCast(*Value, self.stack_top - 2);
var enum_case: ?*ObjEnumInstance = if (value_slot.* == .Null) null else ObjEnumInstance.cast(value_slot.Obj).?;
var enum_: *ObjEnum = ObjEnum.cast(iterable).?;
// Get next enum case
var next_case: ?*ObjEnumInstance = try enum_.rawNext(self, enum_case);
value_slot.* = (if (next_case) |new_case| Value{ .Obj = new_case.toObj() } else Value{ .Null = null });
},
.Map => {
var key_slot: *Value = @ptrCast(*Value, self.stack_top - 3);
var value_slot: *Value = @ptrCast(*Value, self.stack_top - 2);
var map: *ObjMap = ObjMap.cast(iterable).?;
var current_key: ?HashableValue = if (key_slot.* != .Null) valueToHashable(key_slot.*) else null;
var next_key: ?HashableValue = map.rawNext(current_key);
key_slot.* = if (next_key) |unext_key| hashableToValue(unext_key) else Value{ .Null = null };
if (next_key) |unext_key| {
value_slot.* = map.map.get(unext_key) orelse Value{ .Null = null };
}
},
else => unreachable,
}
}
// result_count > 0 when the return is `export`
fn returnFrame(self: *Self) bool {
var result = self.pop();
const frame: *CallFrame = self.currentFrame().?;
self.closeUpValues(&frame.slots[0]);
self.frame_count -= 1;
_ = self.frames.pop();
if (self.frame_count == 0) {
_ = self.pop();
return true;
}
self.stack_top = frame.slots;
self.push(result);
return false;
}
fn import(self: *Self, value: Value) Error!void {
var function: *ObjFunction = ObjFunction.cast(value.Obj).?;
var vm = try self.allocator.create(VM);
vm.* = try VM.init(self.allocator, self.strings);
// TODO: we can't free this because exported closure refer to it
// defer vm.deinit();
try vm.interpret(function, null);
// Top of stack is how many export we got
var exported_count: u8 = @floatToInt(u8, vm.peek(0).Number);
// Copy them to this vm globals
if (exported_count > 0) {
var i: u8 = exported_count;
while (i > 0) : (i -= 1) {
try self.globals.append(vm.peek(i));
}
}
_ = self.pop();
}
pub fn throw(self: *Self, code: Error, payload: Value) Error!void {
var stack = std.ArrayList(CallFrame).init(self.allocator);
while (self.frame_count > 0) {
var frame: *CallFrame = self.currentFrame().?;
try stack.append(frame.*);
// Pop frame
self.closeUpValues(&frame.slots[0]);
self.frame_count -= 1;
_ = self.frames.pop();
if (self.frame_count == 0) {
// No more frames, the error is uncaught.
_ = self.pop();
// Raise the runtime error
std.debug.print("\n\u{001b}[31mError: {s}\u{001b}[0m\n", .{try valueToString(self.allocator, payload)});
for (stack.items) |stack_frame| {
std.debug.print("\tat {s}", .{stack_frame.closure.function.name.string});
if (stack_frame.call_site) |call_site| {
std.debug.print(":{}\n", .{call_site});
} else {
std.debug.print("\n", .{});
}
}
return code;
}
self.stack_top = frame.slots;
if (frame.error_value) |error_value| {
// Push error_value as failed function return value
self.push(error_value);
return;
} else {
// Are we in a try function?
// TODO: we can accept inline catch to be functions but not the try block
// Call catch closure or continue unwinding frames to find one
if (try self.handleError(payload, frame.error_handlers)) {
stack.deinit();
break;
}
}
}
}
// Returns true if error was handled
fn handleError(self: *Self, error_payload: Value, handlers: std.ArrayList(*ObjClosure)) !bool {
for (handlers.items) |handler| {
const parameters: std.StringArrayHashMap(*ObjTypeDef) = handler.function.type_def.resolved_type.?.Function.parameters;
if (parameters.count() == 0 or _value.valueTypeEql(error_payload, parameters.get(parameters.keys()[0]).?)) {
// In a normal frame, the slots 0 is either the function or a `this` value
self.push(Value{ .Null = null });
// Push error payload
self.push(error_payload);
// Call handler, it's return value is the result of the frame we just closed
try self.call(handler, 1, null);
return true;
}
}
return false;
}
fn binary(self: *Self, code: OpCode) !void {
const left: Value = self.pop();
const right: Value = self.pop();
const right_f: ?f64 = if (right == .Number) right.Number else null;
const left_f: ?f64 = if (left == .Number) left.Number else null;
const right_s: ?*ObjString = if (right == .Obj) ObjString.cast(right.Obj) else null;
const left_s: ?*ObjString = if (left == .Obj) ObjString.cast(left.Obj) else null;
const right_l: ?*ObjList = if (right == .Obj) ObjList.cast(right.Obj) else null;
const left_l: ?*ObjList = if (left == .Obj) ObjList.cast(left.Obj) else null;
const right_m: ?*ObjMap = if (right == .Obj) ObjMap.cast(right.Obj) else null;
const left_m: ?*ObjMap = if (left == .Obj) ObjMap.cast(left.Obj) else null;
switch (code) {
.OP_ADD => add: {
if (right_s != null) {
self.push(Value{ .Obj = (try right_s.?.concat(self, left_s.?)).toObj() });
break :add;
} else if (right_f != null) {
self.push(Value{ .Number = right_f.? + left_f.? });
break :add;
} else if (right_l != null) {
var new_list = std.ArrayList(Value).init(self.allocator);
try new_list.appendSlice(right_l.?.items.items);
try new_list.appendSlice(left_l.?.items.items);
self.push(
(try _obj.allocateObject(self, ObjList, ObjList{
.type_def = left_l.?.type_def,
.methods = left_l.?.methods,
.items = new_list,
})).toValue(),
);
break :add;
}
// map
var new_map = try right_m.?.map.clone();
var it = left_m.?.map.iterator();
while (it.next()) |entry| {
try new_map.put(entry.key_ptr.*, entry.value_ptr.*);
}
self.push(
(try _obj.allocateObject(self, ObjMap, ObjMap{
.type_def = left_m.?.type_def,
.methods = left_m.?.methods,
.map = new_map,
})).toValue(),
);
},
.OP_SUBTRACT => self.push(Value{ .Number = right_f.? - left_f.? }),
.OP_MULTIPLY => self.push(Value{ .Number = right_f.? * left_f.? }),
.OP_DIVIDE => self.push(Value{ .Number = right_f.? / left_f.? }),
.OP_MOD => self.push(Value{ .Number = @mod(right_f.?, left_f.?) }),
else => unreachable,
}
}
fn call(self: *Self, closure: *ObjClosure, arg_count: u8, catch_values: ?std.ArrayList(Value)) !void {
// TODO: check for stack overflow
var frame = CallFrame{
.closure = closure,
.ip = 0,
// -1 is because we reserve slot 0 for this
.slots = self.stack_top - arg_count - 1,
.call_site = if (self.currentFrame()) |current_frame|
current_frame.closure.function.chunk.lines.items[current_frame.ip - 1]
else
null,
.error_handlers = std.ArrayList(*ObjClosure).init(self.allocator),
};
if (catch_values != null) {
for (catch_values.?.items) |catch_value| {
if (catch_value == .Obj and ObjClosure.cast(catch_value.Obj) != null and ObjClosure.cast(catch_value.Obj).?.function.type_def.resolved_type.?.Function.function_type == .Catch) {
try frame.error_handlers.append(ObjClosure.cast(catch_value.Obj).?);
} else {
assert(catch_values.?.items.len == 1);
frame.error_value = catch_value;
}
}
}
if (self.frames.items.len <= self.frame_count) {
try self.frames.append(frame);
} else {
self.frames.items[self.frame_count] = frame;
}
self.frame_count += 1;
if (Config.debug) {
try disassembleChunk(&frame.closure.function.chunk, frame.closure.function.name.string);
std.debug.print("\n\n", .{});
}
}
fn callNative(self: *Self, native: *ObjNative, arg_count: u8, catch_values: ?std.ArrayList(Value)) !void {
// TODO: how to use catch_values with a native call?
var result: Value = Value{ .Null = null };
const native_return = native.native(self);
if (native_return == 1 or native_return == 0) {
if (native_return == 1) {
result = self.pop();
}
self.stack_top = self.stack_top - arg_count - 1;
self.push(result);
} else {
// An error occured within the native function -> call error handlers
if (catch_values != null) {
var handlers = std.ArrayList(*ObjClosure).init(self.allocator);
defer handlers.deinit();
for (catch_values.?.items) |catch_value| {
if (catch_value == .Obj and ObjClosure.cast(catch_value.Obj) != null and ObjClosure.cast(catch_value.Obj).?.function.type_def.resolved_type.?.Function.function_type == .Catch) {
try handlers.append(ObjClosure.cast(catch_value.Obj).?);
} else {
assert(catch_values.?.items.len == 1);
// We discard the error
_ = self.pop();
// Default value in case of error
self.stack_top = self.stack_top - arg_count - 1;
self.push(catch_value);
return;
}
}
// We have some error handlers to try
if (try self.handleError(self.peek(0), handlers)) {
return;
}
}
// No error handler or default value was triggered so forward the error
try self.throw(Error.Custom, self.peek(0));
}
}
fn bindMethod(self: *Self, method: ?*ObjClosure, native: ?*ObjNative) !void {
var bound: *ObjBoundMethod = try allocateObject(self, ObjBoundMethod, .{
.receiver = self.peek(0),
.closure = method,
.native = native,
});
_ = self.pop(); // Pop instane
self.push(Value{ .Obj = bound.toObj() });
}
fn callValue(self: *Self, callee: Value, arg_count: u8, catch_values: ?std.ArrayList(Value)) !void {
var obj: *Obj = callee.Obj;
switch (obj.obj_type) {
.Bound => {
var bound: *ObjBoundMethod = ObjBoundMethod.cast(obj).?;
(self.stack_top - arg_count - 1)[0] = bound.receiver;
if (bound.closure) |closure| {
return try self.call(closure, arg_count, catch_values);
} else {
assert(bound.native != null);
return try self.callNative(bound.native.?, arg_count, catch_values);
}
},
.Closure => {
return try self.call(ObjClosure.cast(obj).?, arg_count, catch_values);
},
.Native => {
return try self.callNative(ObjNative.cast(obj).?, arg_count, catch_values);
},
else => unreachable,
}
}
fn instanciateObject(self: *Self, object: *ObjObject) !void {
var instance: *ObjObjectInstance = try allocateObject(self, ObjObjectInstance, ObjObjectInstance.init(self.allocator, object));
// Set instance fields with super classes default values
if (object.super) |super| {
try self.superDefaults(instance, super);
}
// Set instance fields with default values
var it = object.fields.iterator();
while (it.next()) |kv| {
try instance.fields.put(kv.key_ptr.*, kv.value_ptr.*);
}
self.push(instance.toValue());
}
// TODO: superDefaults and getSuperField could be replaced by specialized opcodes to avoid having to walk up the chain of inheritance
fn superDefaults(self: *Self, instance: *ObjObjectInstance, super: *ObjObject) Allocator.Error!void {
if (super.super) |super_super| {
try self.superDefaults(instance, super_super);
}
var it = super.fields.iterator();
while (it.next()) |kv| {
try instance.fields.put(kv.key_ptr.*, kv.value_ptr.*);
}
}
fn getSuperField(self: *Self, name: []const u8, super: *ObjObject) Allocator.Error!void {
if (super.static_fields.get(name)) |static| {
_ = self.pop(); // Pop instance
self.push(static);
}
if (super.methods.get(name)) |method| {
try self.bindMethod(method, null);
} else if (super.super) |super_super| {
try self.getSuperField(name, super_super);
}
}
fn invokeFromObject(self: *Self, object: *ObjObject, name: *ObjString, arg_count: u8, catch_values: ?std.ArrayList(Value)) !void {
if (object.methods.get(name.string)) |method| {
return self.call(method, arg_count, catch_values);
} else {
unreachable;
}
}
fn invoke(self: *Self, name: *ObjString, arg_count: u8, catch_values: ?std.ArrayList(Value)) !void {
var receiver: Value = self.peek(arg_count);
var obj: *Obj = receiver.Obj;
switch (obj.obj_type) {
.ObjectInstance => {
var instance: *ObjObjectInstance = ObjObjectInstance.cast(obj).?;
if (instance.fields.get(name.string)) |field| {
(self.stack_top - arg_count - 1)[0] = field;
return try self.callValue(field, arg_count, catch_values);
}
try self.invokeFromObject(instance.object, name, arg_count, catch_values);
},
.String => {
if (try ObjString.member(self, name.string)) |member| {
var member_value: Value = Value{ .Obj = member.toObj() };
(self.stack_top - arg_count - 1)[0] = member_value;
return try self.callValue(member_value, arg_count, catch_values);
}
unreachable;
},
.List => {
var list: *ObjList = ObjList.cast(obj).?;
if (try list.member(self, name.string)) |member| {
var member_value: Value = Value{ .Obj = member.toObj() };
(self.stack_top - arg_count - 1)[0] = member_value;
return try self.callValue(member_value, arg_count, catch_values);
}
unreachable;
},
.Map => {
var map: *ObjMap = ObjMap.cast(obj).?;
if (try map.member(self, name.string)) |member| {
var member_value: Value = Value{ .Obj = member.toObj() };
(self.stack_top - arg_count - 1)[0] = member_value;
return try self.callValue(member_value, arg_count, catch_values);
}
unreachable;
},
else => unreachable,
}
}
fn closeUpValues(self: *Self, last: *Value) void {
while (self.open_upvalues != null and @ptrToInt(self.open_upvalues.?.location) >= @ptrToInt(last)) {
var upvalue: *ObjUpValue = self.open_upvalues.?;
upvalue.closed = upvalue.location.*;
upvalue.location = &upvalue.closed.?;
self.open_upvalues = upvalue.next;
}
}
fn captureUpvalue(self: *Self, local: *Value) !*ObjUpValue {
var prev_upvalue: ?*ObjUpValue = null;
var upvalue: ?*ObjUpValue = self.open_upvalues;
while (upvalue != null and @ptrToInt(upvalue.?.location) > @ptrToInt(local)) {
prev_upvalue = upvalue;
upvalue = upvalue.?.next;
}
if (upvalue != null and upvalue.?.location == local) {
return upvalue.?;
}
var created_upvalue: *ObjUpValue = try allocateObject(self, ObjUpValue, ObjUpValue.init(local));
created_upvalue.next = upvalue;
if (prev_upvalue) |uprev_upvalue| {
uprev_upvalue.next = created_upvalue;
} else {
self.open_upvalues = created_upvalue;
}
return created_upvalue;
}
fn appendToList(self: *Self) !void {
var list: *ObjList = ObjList.cast(self.peek(1).Obj).?;
var list_value: Value = self.peek(0);
try list.items.append(list_value);
_ = self.pop();
}
fn defineEnumCase(self: *Self) !void {
var enum_: *ObjEnum = ObjEnum.cast(self.peek(1).Obj).?;
var enum_value: Value = self.peek(0);
try enum_.cases.append(enum_value);
_ = self.pop();
}
fn defineMethod(self: *Self, name: *ObjString) !void {
var method: Value = self.peek(0);
var object: *ObjObject = ObjObject.cast(self.peek(1).Obj).?;
try object.methods.put(name.string, ObjClosure.cast(method.Obj).?);
_ = self.pop();
}
fn setObjectFieldDefaultValue(self: *Self, name: *ObjString) !void {
var property: Value = self.peek(0);
var object: *ObjObject = ObjObject.cast(self.peek(1).Obj).?;
if (object.type_def.resolved_type.?.Object.fields.contains(name.string)) {
try object.fields.put(name.string, property);
} else {
assert(object.type_def.resolved_type.?.Object.static_fields.contains(name.string));
try object.static_fields.put(name.string, property);
}
_ = self.pop();
}
fn subscript(self: *Self) !void {
var subscriptable: *Obj = self.peek(1).Obj;
var index: Value = self.peek(0);
switch (subscriptable.obj_type) {
.List => {
var list: *ObjList = ObjList.cast(subscriptable).?;
if (index.Number < 0) {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound list access.")).toValue());
}
const list_index: usize = @floatToInt(usize, index.Number);
if (list_index < list.items.items.len) {
var list_item: Value = list.items.items[list_index];
// Pop list and index
_ = self.pop();
_ = self.pop();
// Push value
self.push(list_item);
} else {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound list access.")).toValue());
}
},
.Map => {
var map: *ObjMap = ObjMap.cast(subscriptable).?;
// Pop map and key
_ = self.pop();
_ = self.pop();
if (map.map.get(valueToHashable(index))) |value| {
// Push value
self.push(value);
} else {
self.push(Value{ .Null = null });
}
},
.String => {
var str: *ObjString = ObjString.cast(subscriptable).?;
if (index.Number < 0) {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound str access.")).toValue());
}
const str_index: usize = @floatToInt(usize, index.Number);
if (str_index < str.string.len) {
var str_item: Value = (try _obj.copyString(self, &([_]u8{str.string[str_index]}))).toValue();
// Pop str and index
_ = self.pop();
_ = self.pop();
// Push value
self.push(str_item);
} else {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound str access.")).toValue());
}
},
else => unreachable,
}
}
fn setSubscript(self: *Self) !void {
var list_or_map: *Obj = self.peek(2).Obj;
var index: Value = self.peek(1);
var value: Value = self.peek(0);
if (list_or_map.obj_type == .List) {
var list: *ObjList = ObjList.cast(list_or_map).?;
if (index.Number < 0) {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound list access.")).toValue());
}
const list_index: usize = @floatToInt(usize, index.Number);
if (list_index < list.items.items.len) {
list.items.items[list_index] = value;
// Pop everyting
_ = self.pop();
_ = self.pop();
_ = self.pop();
// Push the value
self.push(value);
} else {
try self.throw(Error.OutOfBound, (try _obj.copyString(self, "Out of bound list access.")).toValue());
}
} else {
var map: *ObjMap = ObjMap.cast(list_or_map).?;
try map.map.put(valueToHashable(index), value);
// Pop everyting
_ = self.pop();
_ = self.pop();
_ = self.pop();
// Push the value
self.push(value);
}
}
}; | src/vm.zig |
const std = @import("std");
const builtin = @import("builtin");
const log = std.log.scoped(.OpenGL);
pub const GLenum = c_uint;
pub const GLboolean = u8;
pub const GLbitfield = c_uint;
pub const GLbyte = i8;
pub const GLubyte = u8;
pub const GLshort = i16;
pub const GLushort = u16;
pub const GLint = c_int;
pub const GLuint = c_uint;
pub const GLclampx = i32;
pub const GLsizei = c_int;
pub const GLfloat = f32;
pub const GLclampf = f32;
pub const GLdouble = f64;
pub const GLclampd = f64;
pub const GLeglClientBufferEXT = void;
pub const GLeglImageOES = void;
pub const GLchar = u8;
pub const GLcharARB = u8;
pub const GLhandleARB = if (builtin.os.tag == .macos) *anyopaque else c_uint;
pub const GLhalf = u16;
pub const GLhalfARB = u16;
pub const GLfixed = i32;
pub const GLintptr = usize;
pub const GLintptrARB = usize;
pub const GLsizeiptr = isize;
pub const GLsizeiptrARB = isize;
pub const GLint64 = i64;
pub const GLint64EXT = i64;
pub const GLuint64 = u64;
pub const GLuint64EXT = u64;
pub const GLsync = *opaque {};
pub const _cl_context = opaque {};
pub const _cl_event = opaque {};
pub const GLDEBUGPROC = fn (source: GLenum, _type: GLenum, id: GLuint, severity: GLenum, length: GLsizei, message: [*:0]const u8, userParam: ?*anyopaque) callconv(.C) void;
pub const GLDEBUGPROCARB = fn (source: GLenum, _type: GLenum, id: GLuint, severity: GLenum, length: GLsizei, message: [*:0]const u8, userParam: ?*anyopaque) callconv(.C) void;
pub const GLDEBUGPROCKHR = fn (source: GLenum, _type: GLenum, id: GLuint, severity: GLenum, length: GLsizei, message: [*:0]const u8, userParam: ?*anyopaque) callconv(.C) void;
pub const GLDEBUGPROCAMD = fn (id: GLuint, category: GLenum, severity: GLenum, length: GLsizei, message: [*:0]const u8, userParam: ?*anyopaque) callconv(.C) void;
pub const GLhalfNV = u16;
pub const GLvdpauSurfaceNV = GLintptr;
pub const GLVULKANPROCNV = fn () callconv(.C) void;
pub const DEPTH_BUFFER_BIT = 0x00000100;
pub const STENCIL_BUFFER_BIT = 0x00000400;
pub const COLOR_BUFFER_BIT = 0x00004000;
pub const FALSE = 0;
pub const TRUE = 1;
pub const POINTS = 0x0000;
pub const LINES = 0x0001;
pub const LINE_LOOP = 0x0002;
pub const LINE_STRIP = 0x0003;
pub const TRIANGLES = 0x0004;
pub const TRIANGLE_STRIP = 0x0005;
pub const TRIANGLE_FAN = 0x0006;
pub const COMPRESSED_SRGB8_ETC2 = 0x9275;
pub const NEVER = 0x0200;
pub const LESS = 0x0201;
pub const EQUAL = 0x0202;
pub const LEQUAL = 0x0203;
pub const GREATER = 0x0204;
pub const NOTEQUAL = 0x0205;
pub const GEQUAL = 0x0206;
pub const ALWAYS = 0x0207;
pub const ZERO = 0;
pub const ONE = 1;
pub const SRC_COLOR = 0x0300;
pub const ONE_MINUS_SRC_COLOR = 0x0301;
pub const SRC_ALPHA = 0x0302;
pub const ONE_MINUS_SRC_ALPHA = 0x0303;
pub const DST_ALPHA = 0x0304;
pub const ONE_MINUS_DST_ALPHA = 0x0305;
pub const DST_COLOR = 0x0306;
pub const ONE_MINUS_DST_COLOR = 0x0307;
pub const SRC_ALPHA_SATURATE = 0x0308;
pub const NONE = 0;
pub const FRONT_LEFT = 0x0400;
pub const FRONT_RIGHT = 0x0401;
pub const BACK_LEFT = 0x0402;
pub const BACK_RIGHT = 0x0403;
pub const FRONT = 0x0404;
pub const BACK = 0x0405;
pub const LEFT = 0x0406;
pub const RIGHT = 0x0407;
pub const FRONT_AND_BACK = 0x0408;
pub const NO_ERROR = 0;
pub const INVALID_ENUM = 0x0500;
pub const INVALID_VALUE = 0x0501;
pub const INVALID_OPERATION = 0x0502;
pub const OUT_OF_MEMORY = 0x0505;
pub const CW = 0x0900;
pub const CCW = 0x0901;
pub const POINT_SIZE = 0x0B11;
pub const POINT_SIZE_RANGE = 0x0B12;
pub const POINT_SIZE_GRANULARITY = 0x0B13;
pub const LINE_SMOOTH = 0x0B20;
pub const LINE_WIDTH = 0x0B21;
pub const LINE_WIDTH_RANGE = 0x0B22;
pub const LINE_WIDTH_GRANULARITY = 0x0B23;
pub const POLYGON_MODE = 0x0B40;
pub const POLYGON_SMOOTH = 0x0B41;
pub const CULL_FACE = 0x0B44;
pub const CULL_FACE_MODE = 0x0B45;
pub const FRONT_FACE = 0x0B46;
pub const DEPTH_RANGE = 0x0B70;
pub const DEPTH_TEST = 0x0B71;
pub const DEPTH_WRITEMASK = 0x0B72;
pub const DEPTH_CLEAR_VALUE = 0x0B73;
pub const DEPTH_FUNC = 0x0B74;
pub const STENCIL_TEST = 0x0B90;
pub const STENCIL_CLEAR_VALUE = 0x0B91;
pub const STENCIL_FUNC = 0x0B92;
pub const STENCIL_VALUE_MASK = 0x0B93;
pub const STENCIL_FAIL = 0x0B94;
pub const STENCIL_PASS_DEPTH_FAIL = 0x0B95;
pub const STENCIL_PASS_DEPTH_PASS = 0x0B96;
pub const STENCIL_REF = 0x0B97;
pub const STENCIL_WRITEMASK = 0x0B98;
pub const VIEWPORT = 0x0BA2;
pub const DITHER = 0x0BD0;
pub const BLEND_DST = 0x0BE0;
pub const BLEND_SRC = 0x0BE1;
pub const BLEND = 0x0BE2;
pub const LOGIC_OP_MODE = 0x0BF0;
pub const DRAW_BUFFER = 0x0C01;
pub const READ_BUFFER = 0x0C02;
pub const SCISSOR_BOX = 0x0C10;
pub const SCISSOR_TEST = 0x0C11;
pub const COLOR_CLEAR_VALUE = 0x0C22;
pub const COLOR_WRITEMASK = 0x0C23;
pub const DOUBLEBUFFER = 0x0C32;
pub const STEREO = 0x0C33;
pub const LINE_SMOOTH_HINT = 0x0C52;
pub const POLYGON_SMOOTH_HINT = 0x0C53;
pub const UNPACK_SWAP_BYTES = 0x0CF0;
pub const UNPACK_LSB_FIRST = 0x0CF1;
pub const UNPACK_ROW_LENGTH = 0x0CF2;
pub const UNPACK_SKIP_ROWS = 0x0CF3;
pub const UNPACK_SKIP_PIXELS = 0x0CF4;
pub const UNPACK_ALIGNMENT = 0x0CF5;
pub const PACK_SWAP_BYTES = 0x0D00;
pub const PACK_LSB_FIRST = 0x0D01;
pub const PACK_ROW_LENGTH = 0x0D02;
pub const PACK_SKIP_ROWS = 0x0D03;
pub const PACK_SKIP_PIXELS = 0x0D04;
pub const PACK_ALIGNMENT = 0x0D05;
pub const MAX_TEXTURE_SIZE = 0x0D33;
pub const MAX_VIEWPORT_DIMS = 0x0D3A;
pub const SUBPIXEL_BITS = 0x0D50;
pub const TEXTURE_1D = 0x0DE0;
pub const TEXTURE_2D = 0x0DE1;
pub const TEXTURE_WIDTH = 0x1000;
pub const TEXTURE_HEIGHT = 0x1001;
pub const TEXTURE_BORDER_COLOR = 0x1004;
pub const DONT_CARE = 0x1100;
pub const FASTEST = 0x1101;
pub const NICEST = 0x1102;
pub const BYTE = 0x1400;
pub const UNSIGNED_BYTE = 0x1401;
pub const SHORT = 0x1402;
pub const UNSIGNED_SHORT = 0x1403;
pub const INT = 0x1404;
pub const UNSIGNED_INT = 0x1405;
pub const FLOAT = 0x1406;
pub const CLEAR = 0x1500;
pub const AND = 0x1501;
pub const AND_REVERSE = 0x1502;
pub const COPY = 0x1503;
pub const AND_INVERTED = 0x1504;
pub const NOOP = 0x1505;
pub const XOR = 0x1506;
pub const OR = 0x1507;
pub const NOR = 0x1508;
pub const EQUIV = 0x1509;
pub const INVERT = 0x150A;
pub const OR_REVERSE = 0x150B;
pub const COPY_INVERTED = 0x150C;
pub const OR_INVERTED = 0x150D;
pub const NAND = 0x150E;
pub const SET = 0x150F;
pub const TEXTURE = 0x1702;
pub const COLOR = 0x1800;
pub const DEPTH = 0x1801;
pub const STENCIL = 0x1802;
pub const STENCIL_INDEX = 0x1901;
pub const DEPTH_COMPONENT = 0x1902;
pub const RED = 0x1903;
pub const GREEN = 0x1904;
pub const BLUE = 0x1905;
pub const ALPHA = 0x1906;
pub const RGB = 0x1907;
pub const RGBA = 0x1908;
pub const POINT = 0x1B00;
pub const LINE = 0x1B01;
pub const FILL = 0x1B02;
pub const KEEP = 0x1E00;
pub const REPLACE = 0x1E01;
pub const INCR = 0x1E02;
pub const DECR = 0x1E03;
pub const VENDOR = 0x1F00;
pub const RENDERER = 0x1F01;
pub const VERSION = 0x1F02;
pub const EXTENSIONS = 0x1F03;
pub const NEAREST = 0x2600;
pub const LINEAR = 0x2601;
pub const NEAREST_MIPMAP_NEAREST = 0x2700;
pub const LINEAR_MIPMAP_NEAREST = 0x2701;
pub const NEAREST_MIPMAP_LINEAR = 0x2702;
pub const LINEAR_MIPMAP_LINEAR = 0x2703;
pub const TEXTURE_MAG_FILTER = 0x2800;
pub const TEXTURE_MIN_FILTER = 0x2801;
pub const TEXTURE_WRAP_S = 0x2802;
pub const TEXTURE_WRAP_T = 0x2803;
pub const REPEAT = 0x2901;
pub const MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE;
pub const MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB;
pub const MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266;
pub const MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265;
pub const MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264;
pub const MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263;
pub const MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262;
pub const MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD;
pub const MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC;
pub const MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB;
pub const COMPUTE_SHADER = 0x91B9;
pub const MAX_ELEMENT_INDEX = 0x8D6B;
pub const ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A;
pub const PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69;
pub const COMPRESSED_SIGNED_RG11_EAC = 0x9273;
pub const COMPRESSED_RG11_EAC = 0x9272;
pub const COMPRESSED_SIGNED_R11_EAC = 0x9271;
pub const COMPRESSED_R11_EAC = 0x9270;
pub const COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276;
pub const COMPRESSED_RGB8_ETC2 = 0x9274;
pub const VERTEX_ATTRIB_ARRAY_LONG = 0x874E;
pub const NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9;
pub const TEXTURE_IMMUTABLE_FORMAT = 0x912F;
pub const COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F;
pub const COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E;
pub const COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D;
pub const COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C;
pub const MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF;
pub const MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE;
pub const MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD;
pub const MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC;
pub const MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB;
pub const MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA;
pub const IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9;
pub const IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8;
pub const IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7;
pub const IMAGE_BINDING_FORMAT = 0x906E;
pub const MAX_IMAGE_SAMPLES = 0x906D;
pub const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C;
pub const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B;
pub const UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A;
pub const UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069;
pub const UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068;
pub const UNSIGNED_INT_IMAGE_BUFFER = 0x9067;
pub const UNSIGNED_INT_IMAGE_CUBE = 0x9066;
pub const UNSIGNED_INT_IMAGE_2D_RECT = 0x9065;
pub const UNSIGNED_INT_IMAGE_3D = 0x9064;
pub const INT_IMAGE_CUBE = 0x905B;
pub const INT_IMAGE_2D_RECT = 0x905A;
pub const INT_IMAGE_3D = 0x9059;
pub const INT_IMAGE_2D = 0x9058;
pub const INT_IMAGE_1D = 0x9057;
pub const IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056;
pub const IMAGE_2D_MULTISAMPLE = 0x9055;
pub const IMAGE_CUBE_MAP_ARRAY = 0x9054;
pub const IMAGE_2D_ARRAY = 0x9053;
pub const IMAGE_1D_ARRAY = 0x9052;
pub const IMAGE_BUFFER = 0x9051;
pub const IMAGE_CUBE = 0x9050;
pub const IMAGE_2D_RECT = 0x904F;
pub const IMAGE_3D = 0x904E;
pub const IMAGE_2D = 0x904D;
pub const IMAGE_1D = 0x904C;
pub const IMAGE_BINDING_ACCESS = 0x8F3E;
pub const IMAGE_BINDING_LAYER = 0x8F3D;
pub const IMAGE_BINDING_LAYERED = 0x8F3C;
pub const IMAGE_BINDING_LEVEL = 0x8F3B;
pub const IMAGE_BINDING_NAME = 0x8F3A;
pub const MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39;
pub const MAX_IMAGE_UNITS = 0x8F38;
pub const ALL_BARRIER_BITS = 0xFFFFFFFF;
pub const ATOMIC_COUNTER_BARRIER_BIT = 0x00001000;
pub const TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800;
pub const FRAMEBUFFER_BARRIER_BIT = 0x00000400;
pub const BUFFER_UPDATE_BARRIER_BIT = 0x00000200;
pub const TEXTURE_UPDATE_BARRIER_BIT = 0x00000100;
pub const PIXEL_BUFFER_BARRIER_BIT = 0x00000080;
pub const COMMAND_BARRIER_BIT = 0x00000040;
pub const SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020;
pub const TEXTURE_FETCH_BARRIER_BIT = 0x00000008;
pub const UNIFORM_BARRIER_BIT = 0x00000004;
pub const ELEMENT_ARRAY_BARRIER_BIT = 0x00000002;
pub const VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001;
pub const UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB;
pub const UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA;
pub const ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9;
pub const MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC;
pub const MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8;
pub const MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7;
pub const MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6;
pub const MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5;
pub const MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4;
pub const MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2;
pub const MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1;
pub const MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0;
pub const MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE;
pub const MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD;
pub const MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7;
pub const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6;
pub const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5;
pub const ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4;
pub const ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3;
pub const ATOMIC_COUNTER_BUFFER_START = 0x92C2;
pub const ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1;
pub const ATOMIC_COUNTER_BUFFER = 0x92C0;
pub const MIN_MAP_BUFFER_ALIGNMENT = 0x90BC;
pub const NUM_SAMPLE_COUNTS = 0x9380;
pub const PACK_COMPRESSED_BLOCK_SIZE = 0x912E;
pub const PACK_COMPRESSED_BLOCK_DEPTH = 0x912D;
pub const PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C;
pub const PACK_COMPRESSED_BLOCK_WIDTH = 0x912B;
pub const UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A;
pub const UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129;
pub const UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128;
pub const UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127;
pub const TRANSFORM_FEEDBACK_PAUSED = 0x8E23;
pub const TRANSFORM_FEEDBACK_ACTIVE = 0x8E24;
pub const COPY_WRITE_BUFFER_BINDING = 0x8F37;
pub const COPY_READ_BUFFER_BINDING = 0x8F36;
pub const UNDEFINED_VERTEX = 0x8260;
pub const VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F;
pub const LAYER_PROVOKING_VERTEX = 0x825E;
pub const VIEWPORT_BOUNDS_RANGE = 0x825D;
pub const VIEWPORT_SUBPIXEL_BITS = 0x825C;
pub const MAX_VIEWPORTS = 0x825B;
pub const PROGRAM_PIPELINE_BINDING = 0x825A;
pub const ACTIVE_PROGRAM = 0x8259;
pub const PROGRAM_SEPARABLE = 0x8258;
pub const ALL_SHADER_BITS = 0xFFFFFFFF;
pub const TESS_EVALUATION_SHADER_BIT = 0x00000010;
pub const TESS_CONTROL_SHADER_BIT = 0x00000008;
pub const GEOMETRY_SHADER_BIT = 0x00000004;
pub const FRAGMENT_SHADER_BIT = 0x00000002;
pub const VERTEX_SHADER_BIT = 0x00000001;
pub const PROGRAM_BINARY_FORMATS = 0x87FF;
pub const NUM_PROGRAM_BINARY_FORMATS = 0x87FE;
pub const PROGRAM_BINARY_LENGTH = 0x8741;
pub const PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257;
pub const RGB565 = 0x8D62;
pub const MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD;
pub const MAX_VARYING_VECTORS = 0x8DFC;
pub const MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
pub const NUM_SHADER_BINARY_FORMATS = 0x8DF9;
pub const SHADER_BINARY_FORMATS = 0x8DF8;
pub const SHADER_COMPILER = 0x8DFA;
pub const HIGH_INT = 0x8DF5;
pub const MEDIUM_INT = 0x8DF4;
pub const LOW_INT = 0x8DF3;
pub const HIGH_FLOAT = 0x8DF2;
pub const MEDIUM_FLOAT = 0x8DF1;
pub const LOW_FLOAT = 0x8DF0;
pub const IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
pub const IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
pub const FIXED = 0x140C;
pub const MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70;
pub const ISOLINES = 0x8E7A;
pub const TESS_GEN_POINT_MODE = 0x8E79;
pub const TESS_GEN_VERTEX_ORDER = 0x8E78;
pub const TESS_GEN_SPACING = 0x8E77;
pub const TESS_GEN_MODE = 0x8E76;
pub const TESS_CONTROL_OUTPUT_VERTICES = 0x8E75;
pub const PATCH_DEFAULT_OUTER_LEVEL = 0x8E74;
pub const PATCH_DEFAULT_INNER_LEVEL = 0x8E73;
pub const PATCH_VERTICES = 0x8E72;
pub const PATCHES = 0x000E;
pub const VERTEX_BINDING_BUFFER = 0x8F4F;
pub const MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA;
pub const MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9;
pub const VERTEX_BINDING_STRIDE = 0x82D8;
pub const VERTEX_BINDING_OFFSET = 0x82D7;
pub const VERTEX_BINDING_DIVISOR = 0x82D6;
pub const VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5;
pub const VERTEX_ATTRIB_BINDING = 0x82D4;
pub const TEXTURE_IMMUTABLE_LEVELS = 0x82DF;
pub const TEXTURE_VIEW_NUM_LAYERS = 0x82DE;
pub const TEXTURE_VIEW_MIN_LAYER = 0x82DD;
pub const TEXTURE_VIEW_NUM_LEVELS = 0x82DC;
pub const TEXTURE_VIEW_MIN_LEVEL = 0x82DB;
pub const TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F;
pub const TEXTURE_BUFFER_SIZE = 0x919E;
pub const TEXTURE_BUFFER_OFFSET = 0x919D;
pub const DEPTH_STENCIL_TEXTURE_MODE = 0x90EA;
pub const MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39;
pub const SHADER_STORAGE_BARRIER_BIT = 0x00002000;
pub const SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF;
pub const MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE;
pub const MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD;
pub const MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC;
pub const MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB;
pub const MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA;
pub const MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9;
pub const MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8;
pub const MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7;
pub const MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6;
pub const SHADER_STORAGE_BUFFER_SIZE = 0x90D5;
pub const SHADER_STORAGE_BUFFER_START = 0x90D4;
pub const SHADER_STORAGE_BUFFER_BINDING = 0x90D3;
pub const SHADER_STORAGE_BUFFER = 0x90D2;
pub const IS_PER_PATCH = 0x92E7;
pub const LOCATION_INDEX = 0x930F;
pub const LOCATION = 0x930E;
pub const TOP_LEVEL_ARRAY_STRIDE = 0x930D;
pub const TOP_LEVEL_ARRAY_SIZE = 0x930C;
pub const REFERENCED_BY_COMPUTE_SHADER = 0x930B;
pub const REFERENCED_BY_FRAGMENT_SHADER = 0x930A;
pub const REFERENCED_BY_GEOMETRY_SHADER = 0x9309;
pub const REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308;
pub const REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307;
pub const REFERENCED_BY_VERTEX_SHADER = 0x9306;
pub const ACTIVE_VARIABLES = 0x9305;
pub const NUM_ACTIVE_VARIABLES = 0x9304;
pub const BUFFER_DATA_SIZE = 0x9303;
pub const BUFFER_BINDING = 0x9302;
pub const ATOMIC_COUNTER_BUFFER_INDEX = 0x9301;
pub const IS_ROW_MAJOR = 0x9300;
pub const MATRIX_STRIDE = 0x92FF;
pub const ARRAY_STRIDE = 0x92FE;
pub const BLOCK_INDEX = 0x92FD;
pub const OFFSET = 0x92FC;
pub const ARRAY_SIZE = 0x92FB;
pub const TYPE = 0x92FA;
pub const NAME_LENGTH = 0x92F9;
pub const MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8;
pub const MAX_NUM_ACTIVE_VARIABLES = 0x92F7;
pub const MAX_NAME_LENGTH = 0x92F6;
pub const ACTIVE_RESOURCES = 0x92F5;
pub const TRANSFORM_FEEDBACK_VARYING = 0x92F4;
pub const COMPUTE_SUBROUTINE_UNIFORM = 0x92F3;
pub const FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2;
pub const GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1;
pub const TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0;
pub const TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF;
pub const VERTEX_SUBROUTINE_UNIFORM = 0x92EE;
pub const COMPUTE_SUBROUTINE = 0x92ED;
pub const FRAGMENT_SUBROUTINE = 0x92EC;
pub const GEOMETRY_SUBROUTINE = 0x92EB;
pub const TESS_EVALUATION_SUBROUTINE = 0x92EA;
pub const TESS_CONTROL_SUBROUTINE = 0x92E9;
pub const VERTEX_SUBROUTINE = 0x92E8;
pub const SHADER_STORAGE_BLOCK = 0x92E6;
pub const BUFFER_VARIABLE = 0x92E5;
pub const PROGRAM_OUTPUT = 0x92E4;
pub const PROGRAM_INPUT = 0x92E3;
pub const UNIFORM_BLOCK = 0x92E2;
pub const UNIFORM = 0x92E1;
pub const VIEW_CLASS_BPTC_FLOAT = 0x82D3;
pub const VIEW_CLASS_BPTC_UNORM = 0x82D2;
pub const VIEW_CLASS_RGTC2_RG = 0x82D1;
pub const VIEW_CLASS_RGTC1_RED = 0x82D0;
pub const VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF;
pub const VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE;
pub const VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD;
pub const VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC;
pub const VIEW_CLASS_8_BITS = 0x82CB;
pub const VIEW_CLASS_16_BITS = 0x82CA;
pub const VIEW_CLASS_24_BITS = 0x82C9;
pub const VIEW_CLASS_32_BITS = 0x82C8;
pub const VIEW_CLASS_48_BITS = 0x82C7;
pub const VIEW_CLASS_64_BITS = 0x82C6;
pub const VIEW_CLASS_96_BITS = 0x82C5;
pub const VIEW_CLASS_128_BITS = 0x82C4;
pub const IMAGE_CLASS_10_10_10_2 = 0x82C3;
pub const IMAGE_CLASS_11_11_10 = 0x82C2;
pub const IMAGE_CLASS_1_X_8 = 0x82C1;
pub const IMAGE_CLASS_2_X_8 = 0x82C0;
pub const IMAGE_CLASS_4_X_8 = 0x82BF;
pub const IMAGE_CLASS_1_X_16 = 0x82BE;
pub const IMAGE_CLASS_2_X_16 = 0x82BD;
pub const IMAGE_CLASS_4_X_16 = 0x82BC;
pub const IMAGE_CLASS_1_X_32 = 0x82BB;
pub const IMAGE_CLASS_2_X_32 = 0x82BA;
pub const IMAGE_CLASS_4_X_32 = 0x82B9;
pub const CAVEAT_SUPPORT = 0x82B8;
pub const FULL_SUPPORT = 0x82B7;
pub const VIEW_COMPATIBILITY_CLASS = 0x82B6;
pub const TEXTURE_VIEW = 0x82B5;
pub const CLEAR_BUFFER = 0x82B4;
pub const TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3;
pub const TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2;
pub const TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1;
pub const SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF;
pub const SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE;
pub const SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD;
pub const SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC;
pub const IMAGE_PIXEL_TYPE = 0x82AA;
pub const IMAGE_PIXEL_FORMAT = 0x82A9;
pub const IMAGE_COMPATIBILITY_CLASS = 0x82A8;
pub const IMAGE_TEXEL_SIZE = 0x82A7;
pub const SHADER_IMAGE_ATOMIC = 0x82A6;
pub const SHADER_IMAGE_STORE = 0x82A5;
pub const SHADER_IMAGE_LOAD = 0x82A4;
pub const TEXTURE_GATHER_SHADOW = 0x82A3;
pub const TEXTURE_GATHER = 0x82A2;
pub const TEXTURE_SHADOW = 0x82A1;
pub const COMPUTE_TEXTURE = 0x82A0;
pub const FRAGMENT_TEXTURE = 0x829F;
pub const GEOMETRY_TEXTURE = 0x829E;
pub const TESS_EVALUATION_TEXTURE = 0x829D;
pub const TESS_CONTROL_TEXTURE = 0x829C;
pub const VERTEX_TEXTURE = 0x829B;
pub const FILTER = 0x829A;
pub const SRGB_WRITE = 0x8298;
pub const SRGB_READ = 0x8297;
pub const COLOR_ENCODING = 0x8296;
pub const AUTO_GENERATE_MIPMAP = 0x8295;
pub const MANUAL_GENERATE_MIPMAP = 0x8294;
pub const MIPMAP = 0x8293;
pub const GET_TEXTURE_IMAGE_TYPE = 0x8292;
pub const GET_TEXTURE_IMAGE_FORMAT = 0x8291;
pub const TEXTURE_IMAGE_TYPE = 0x8290;
pub const TEXTURE_IMAGE_FORMAT = 0x828F;
pub const READ_PIXELS_TYPE = 0x828E;
pub const READ_PIXELS_FORMAT = 0x828D;
pub const READ_PIXELS = 0x828C;
pub const FRAMEBUFFER_BLEND = 0x828B;
pub const FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A;
pub const FRAMEBUFFER_RENDERABLE = 0x8289;
pub const STENCIL_RENDERABLE = 0x8288;
pub const DEPTH_RENDERABLE = 0x8287;
pub const COLOR_RENDERABLE = 0x8286;
pub const STENCIL_COMPONENTS = 0x8285;
pub const DEPTH_COMPONENTS = 0x8284;
pub const COLOR_COMPONENTS = 0x8283;
pub const MAX_COMBINED_DIMENSIONS = 0x8282;
pub const MAX_LAYERS = 0x8281;
pub const MAX_DEPTH = 0x8280;
pub const MAX_HEIGHT = 0x827F;
pub const MAX_WIDTH = 0x827E;
pub const INTERNALFORMAT_STENCIL_TYPE = 0x827D;
pub const INTERNALFORMAT_DEPTH_TYPE = 0x827C;
pub const INTERNALFORMAT_ALPHA_TYPE = 0x827B;
pub const INTERNALFORMAT_BLUE_TYPE = 0x827A;
pub const INTERNALFORMAT_GREEN_TYPE = 0x8279;
pub const INTERNALFORMAT_RED_TYPE = 0x8278;
pub const INTERNALFORMAT_SHARED_SIZE = 0x8277;
pub const INTERNALFORMAT_STENCIL_SIZE = 0x8276;
pub const INTERNALFORMAT_DEPTH_SIZE = 0x8275;
pub const INTERNALFORMAT_ALPHA_SIZE = 0x8274;
pub const INTERNALFORMAT_BLUE_SIZE = 0x8273;
pub const INTERNALFORMAT_GREEN_SIZE = 0x8272;
pub const INTERNALFORMAT_RED_SIZE = 0x8271;
pub const INTERNALFORMAT_PREFERRED = 0x8270;
pub const INTERNALFORMAT_SUPPORTED = 0x826F;
pub const MAX_FRAMEBUFFER_SAMPLES = 0x9318;
pub const MAX_FRAMEBUFFER_LAYERS = 0x9317;
pub const MAX_FRAMEBUFFER_HEIGHT = 0x9316;
pub const MAX_FRAMEBUFFER_WIDTH = 0x9315;
pub const FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314;
pub const FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313;
pub const FRAMEBUFFER_DEFAULT_LAYERS = 0x9312;
pub const FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311;
pub const FRAMEBUFFER_DEFAULT_WIDTH = 0x9310;
pub const MAX_UNIFORM_LOCATIONS = 0x826E;
pub const CONTEXT_FLAG_DEBUG_BIT = 0x00000002;
pub const DEBUG_OUTPUT = 0x92E0;
pub const MAX_LABEL_LENGTH = 0x82E8;
pub const SAMPLER = 0x82E6;
pub const PROGRAM_PIPELINE = 0x82E4;
pub const QUERY = 0x82E3;
pub const VERTEX_ARRAY = 0x8074;
pub const PROGRAM = 0x82E2;
pub const SHADER = 0x82E1;
pub const BUFFER = 0x82E0;
pub const DEBUG_GROUP_STACK_DEPTH = 0x826D;
pub const MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C;
pub const DEBUG_SEVERITY_NOTIFICATION = 0x826B;
pub const DEBUG_TYPE_POP_GROUP = 0x826A;
pub const DEBUG_TYPE_PUSH_GROUP = 0x8269;
pub const DEBUG_TYPE_MARKER = 0x8268;
pub const DEBUG_SEVERITY_LOW = 0x9148;
pub const DEBUG_SEVERITY_MEDIUM = 0x9147;
pub const DEBUG_SEVERITY_HIGH = 0x9146;
pub const DEBUG_LOGGED_MESSAGES = 0x9145;
pub const MAX_DEBUG_LOGGED_MESSAGES = 0x9144;
pub const MAX_DEBUG_MESSAGE_LENGTH = 0x9143;
pub const DEBUG_TYPE_OTHER = 0x8251;
pub const DEBUG_TYPE_PERFORMANCE = 0x8250;
pub const DEBUG_TYPE_PORTABILITY = 0x824F;
pub const DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E;
pub const DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D;
pub const DEBUG_TYPE_ERROR = 0x824C;
pub const DEBUG_SOURCE_OTHER = 0x824B;
pub const DEBUG_SOURCE_APPLICATION = 0x824A;
pub const DEBUG_SOURCE_THIRD_PARTY = 0x8249;
pub const DEBUG_SOURCE_SHADER_COMPILER = 0x8248;
pub const DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247;
pub const DEBUG_SOURCE_API = 0x8246;
pub const DEBUG_CALLBACK_USER_PARAM = 0x8245;
pub const DEBUG_CALLBACK_FUNCTION = 0x8244;
pub const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243;
pub const DEBUG_OUTPUT_SYNCHRONOUS = 0x8242;
pub const COMPUTE_SHADER_BIT = 0x00000020;
pub const DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF;
pub const DISPATCH_INDIRECT_BUFFER = 0x90EE;
pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED;
pub const UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC;
pub const COMPUTE_WORK_GROUP_SIZE = 0x8267;
pub const MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF;
pub const COLOR_LOGIC_OP = 0x0BF2;
pub const POLYGON_OFFSET_UNITS = 0x2A00;
pub const POLYGON_OFFSET_POINT = 0x2A01;
pub const POLYGON_OFFSET_LINE = 0x2A02;
pub const POLYGON_OFFSET_FILL = 0x8037;
pub const POLYGON_OFFSET_FACTOR = 0x8038;
pub const TEXTURE_BINDING_1D = 0x8068;
pub const TEXTURE_BINDING_2D = 0x8069;
pub const TEXTURE_INTERNAL_FORMAT = 0x1003;
pub const TEXTURE_RED_SIZE = 0x805C;
pub const TEXTURE_GREEN_SIZE = 0x805D;
pub const TEXTURE_BLUE_SIZE = 0x805E;
pub const TEXTURE_ALPHA_SIZE = 0x805F;
pub const DOUBLE = 0x140A;
pub const PROXY_TEXTURE_1D = 0x8063;
pub const PROXY_TEXTURE_2D = 0x8064;
pub const R3_G3_B2 = 0x2A10;
pub const RGB4 = 0x804F;
pub const RGB5 = 0x8050;
pub const RGB8 = 0x8051;
pub const RGB10 = 0x8052;
pub const RGB12 = 0x8053;
pub const RGB16 = 0x8054;
pub const RGBA2 = 0x8055;
pub const RGBA4 = 0x8056;
pub const RGB5_A1 = 0x8057;
pub const RGBA8 = 0x8058;
pub const RGB10_A2 = 0x8059;
pub const RGBA12 = 0x805A;
pub const RGBA16 = 0x805B;
pub const COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
pub const COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
pub const COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
pub const UNSIGNED_INT_IMAGE_2D = 0x9063;
pub const UNSIGNED_INT_IMAGE_1D = 0x9062;
pub const INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061;
pub const INT_IMAGE_2D_MULTISAMPLE = 0x9060;
pub const INT_IMAGE_CUBE_MAP_ARRAY = 0x905F;
pub const INT_IMAGE_2D_ARRAY = 0x905E;
pub const INT_IMAGE_1D_ARRAY = 0x905D;
pub const INT_IMAGE_BUFFER = 0x905C;
pub const MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3;
pub const MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF;
pub const TRANSFORM_FEEDBACK_BINDING = 0x8E25;
pub const TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24;
pub const TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23;
pub const TRANSFORM_FEEDBACK = 0x8E22;
pub const TESS_CONTROL_SHADER = 0x8E88;
pub const TESS_EVALUATION_SHADER = 0x8E87;
pub const UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1;
pub const UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0;
pub const MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F;
pub const MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E;
pub const MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D;
pub const MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C;
pub const MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A;
pub const MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89;
pub const MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86;
pub const MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85;
pub const MAX_TESS_PATCH_COMPONENTS = 0x8E84;
pub const MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83;
pub const MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82;
pub const MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81;
pub const MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80;
pub const MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F;
pub const MAX_TESS_GEN_LEVEL = 0x8E7E;
pub const MAX_PATCH_VERTICES = 0x8E7D;
pub const FRACTIONAL_EVEN = 0x8E7C;
pub const FRACTIONAL_ODD = 0x8E7B;
pub const QUADS = 0x0007;
pub const MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8;
pub const COMPATIBLE_SUBROUTINES = 0x8E4B;
pub const NUM_COMPATIBLE_SUBROUTINES = 0x8E4A;
pub const MAX_SUBROUTINES = 0x8DE7;
pub const ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49;
pub const ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48;
pub const ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47;
pub const ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6;
pub const ACTIVE_SUBROUTINES = 0x8DE5;
pub const UNSIGNED_BYTE_3_3_2 = 0x8032;
pub const UNSIGNED_SHORT_4_4_4_4 = 0x8033;
pub const UNSIGNED_SHORT_5_5_5_1 = 0x8034;
pub const UNSIGNED_INT_8_8_8_8 = 0x8035;
pub const UNSIGNED_INT_10_10_10_2 = 0x8036;
pub const TEXTURE_BINDING_3D = 0x806A;
pub const PACK_SKIP_IMAGES = 0x806B;
pub const PACK_IMAGE_HEIGHT = 0x806C;
pub const UNPACK_SKIP_IMAGES = 0x806D;
pub const UNPACK_IMAGE_HEIGHT = 0x806E;
pub const TEXTURE_3D = 0x806F;
pub const PROXY_TEXTURE_3D = 0x8070;
pub const TEXTURE_DEPTH = 0x8071;
pub const TEXTURE_WRAP_R = 0x8072;
pub const MAX_3D_TEXTURE_SIZE = 0x8073;
pub const UNSIGNED_BYTE_2_3_3_REV = 0x8362;
pub const UNSIGNED_SHORT_5_6_5 = 0x8363;
pub const UNSIGNED_SHORT_5_6_5_REV = 0x8364;
pub const UNSIGNED_SHORT_4_4_4_4_REV = 0x8365;
pub const UNSIGNED_SHORT_1_5_5_5_REV = 0x8366;
pub const UNSIGNED_INT_8_8_8_8_REV = 0x8367;
pub const UNSIGNED_INT_2_10_10_10_REV = 0x8368;
pub const BGR = 0x80E0;
pub const BGRA = 0x80E1;
pub const MAX_ELEMENTS_VERTICES = 0x80E8;
pub const MAX_ELEMENTS_INDICES = 0x80E9;
pub const CLAMP_TO_EDGE = 0x812F;
pub const TEXTURE_MIN_LOD = 0x813A;
pub const TEXTURE_MAX_LOD = 0x813B;
pub const TEXTURE_BASE_LEVEL = 0x813C;
pub const TEXTURE_MAX_LEVEL = 0x813D;
pub const SMOOTH_POINT_SIZE_RANGE = 0x0B12;
pub const SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13;
pub const SMOOTH_LINE_WIDTH_RANGE = 0x0B22;
pub const SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23;
pub const ALIASED_LINE_WIDTH_RANGE = 0x846E;
pub const TEXTURE0 = 0x84C0;
pub const TEXTURE1 = 0x84C1;
pub const TEXTURE2 = 0x84C2;
pub const TEXTURE3 = 0x84C3;
pub const TEXTURE4 = 0x84C4;
pub const TEXTURE5 = 0x84C5;
pub const TEXTURE6 = 0x84C6;
pub const TEXTURE7 = 0x84C7;
pub const TEXTURE8 = 0x84C8;
pub const TEXTURE9 = 0x84C9;
pub const TEXTURE10 = 0x84CA;
pub const TEXTURE11 = 0x84CB;
pub const TEXTURE12 = 0x84CC;
pub const TEXTURE13 = 0x84CD;
pub const TEXTURE14 = 0x84CE;
pub const TEXTURE15 = 0x84CF;
pub const TEXTURE16 = 0x84D0;
pub const TEXTURE17 = 0x84D1;
pub const TEXTURE18 = 0x84D2;
pub const TEXTURE19 = 0x84D3;
pub const TEXTURE20 = 0x84D4;
pub const TEXTURE21 = 0x84D5;
pub const TEXTURE22 = 0x84D6;
pub const TEXTURE23 = 0x84D7;
pub const TEXTURE24 = 0x84D8;
pub const TEXTURE25 = 0x84D9;
pub const TEXTURE26 = 0x84DA;
pub const TEXTURE27 = 0x84DB;
pub const TEXTURE28 = 0x84DC;
pub const TEXTURE29 = 0x84DD;
pub const TEXTURE30 = 0x84DE;
pub const TEXTURE31 = 0x84DF;
pub const ACTIVE_TEXTURE = 0x84E0;
pub const MULTISAMPLE = 0x809D;
pub const SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
pub const SAMPLE_ALPHA_TO_ONE = 0x809F;
pub const SAMPLE_COVERAGE = 0x80A0;
pub const SAMPLE_BUFFERS = 0x80A8;
pub const SAMPLES = 0x80A9;
pub const SAMPLE_COVERAGE_VALUE = 0x80AA;
pub const SAMPLE_COVERAGE_INVERT = 0x80AB;
pub const TEXTURE_CUBE_MAP = 0x8513;
pub const TEXTURE_BINDING_CUBE_MAP = 0x8514;
pub const TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
pub const TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
pub const TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
pub const TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
pub const TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
pub const TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
pub const PROXY_TEXTURE_CUBE_MAP = 0x851B;
pub const MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
pub const COMPRESSED_RGB = 0x84ED;
pub const COMPRESSED_RGBA = 0x84EE;
pub const TEXTURE_COMPRESSION_HINT = 0x84EF;
pub const TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0;
pub const TEXTURE_COMPRESSED = 0x86A1;
pub const NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
pub const COMPRESSED_TEXTURE_FORMATS = 0x86A3;
pub const CLAMP_TO_BORDER = 0x812D;
pub const DOUBLE_MAT4x3 = 0x8F4E;
pub const DOUBLE_MAT4x2 = 0x8F4D;
pub const DOUBLE_MAT3x4 = 0x8F4C;
pub const DOUBLE_MAT3x2 = 0x8F4B;
pub const DOUBLE_MAT2x4 = 0x8F4A;
pub const DOUBLE_MAT2x3 = 0x8F49;
pub const DOUBLE_MAT4 = 0x8F48;
pub const DOUBLE_MAT3 = 0x8F47;
pub const DOUBLE_MAT2 = 0x8F46;
pub const DOUBLE_VEC4 = 0x8FFE;
pub const DOUBLE_VEC3 = 0x8FFD;
pub const DOUBLE_VEC2 = 0x8FFC;
pub const MAX_VERTEX_STREAMS = 0x8E71;
pub const FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D;
pub const MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C;
pub const MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B;
pub const MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A;
pub const GEOMETRY_SHADER_INVOCATIONS = 0x887F;
pub const DRAW_INDIRECT_BUFFER_BINDING = 0x8F43;
pub const DRAW_INDIRECT_BUFFER = 0x8F3F;
pub const UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F;
pub const INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E;
pub const SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D;
pub const SAMPLER_CUBE_MAP_ARRAY = 0x900C;
pub const PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B;
pub const TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A;
pub const TEXTURE_CUBE_MAP_ARRAY = 0x9009;
pub const MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F;
pub const MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E;
pub const MIN_SAMPLE_SHADING_VALUE = 0x8C37;
pub const SAMPLE_SHADING = 0x8C36;
pub const INT_2_10_10_10_REV = 0x8D9F;
pub const TIMESTAMP = 0x8E28;
pub const TIME_ELAPSED = 0x88BF;
pub const TEXTURE_SWIZZLE_RGBA = 0x8E46;
pub const TEXTURE_SWIZZLE_A = 0x8E45;
pub const TEXTURE_SWIZZLE_B = 0x8E44;
pub const TEXTURE_SWIZZLE_G = 0x8E43;
pub const TEXTURE_SWIZZLE_R = 0x8E42;
pub const RGB10_A2UI = 0x906F;
pub const BLEND_DST_RGB = 0x80C8;
pub const BLEND_SRC_RGB = 0x80C9;
pub const BLEND_DST_ALPHA = 0x80CA;
pub const BLEND_SRC_ALPHA = 0x80CB;
pub const POINT_FADE_THRESHOLD_SIZE = 0x8128;
pub const DEPTH_COMPONENT16 = 0x81A5;
pub const DEPTH_COMPONENT24 = 0x81A6;
pub const DEPTH_COMPONENT32 = 0x81A7;
pub const MIRRORED_REPEAT = 0x8370;
pub const MAX_TEXTURE_LOD_BIAS = 0x84FD;
pub const TEXTURE_LOD_BIAS = 0x8501;
pub const INCR_WRAP = 0x8507;
pub const DECR_WRAP = 0x8508;
pub const TEXTURE_DEPTH_SIZE = 0x884A;
pub const TEXTURE_COMPARE_MODE = 0x884C;
pub const TEXTURE_COMPARE_FUNC = 0x884D;
pub const SAMPLER_BINDING = 0x8919;
pub const ANY_SAMPLES_PASSED = 0x8C2F;
pub const MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC;
pub const ONE_MINUS_SRC1_ALPHA = 0x88FB;
pub const ONE_MINUS_SRC1_COLOR = 0x88FA;
pub const SRC1_COLOR = 0x88F9;
pub const VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE;
pub const MAX_INTEGER_SAMPLES = 0x9110;
pub const MAX_DEPTH_TEXTURE_SAMPLES = 0x910F;
pub const MAX_COLOR_TEXTURE_SAMPLES = 0x910E;
pub const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D;
pub const INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C;
pub const SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B;
pub const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A;
pub const INT_SAMPLER_2D_MULTISAMPLE = 0x9109;
pub const SAMPLER_2D_MULTISAMPLE = 0x9108;
pub const TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107;
pub const TEXTURE_SAMPLES = 0x9106;
pub const TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105;
pub const TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104;
pub const PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103;
pub const TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102;
pub const PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101;
pub const TEXTURE_2D_MULTISAMPLE = 0x9100;
pub const MAX_SAMPLE_MASK_WORDS = 0x8E59;
pub const SAMPLE_MASK_VALUE = 0x8E52;
pub const SAMPLE_MASK = 0x8E51;
pub const SAMPLE_POSITION = 0x8E50;
pub const SYNC_FLUSH_COMMANDS_BIT = 0x00000001;
pub const TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF;
pub const WAIT_FAILED = 0x911D;
pub const CONDITION_SATISFIED = 0x911C;
pub const TIMEOUT_EXPIRED = 0x911B;
pub const ALREADY_SIGNALED = 0x911A;
pub const SIGNALED = 0x9119;
pub const UNSIGNALED = 0x9118;
pub const SYNC_GPU_COMMANDS_COMPLETE = 0x9117;
pub const BLEND_COLOR = 0x8005;
pub const BLEND_EQUATION = 0x8009;
pub const CONSTANT_COLOR = 0x8001;
pub const ONE_MINUS_CONSTANT_COLOR = 0x8002;
pub const CONSTANT_ALPHA = 0x8003;
pub const ONE_MINUS_CONSTANT_ALPHA = 0x8004;
pub const FUNC_ADD = 0x8006;
pub const FUNC_REVERSE_SUBTRACT = 0x800B;
pub const FUNC_SUBTRACT = 0x800A;
pub const MIN = 0x8007;
pub const MAX = 0x8008;
pub const BUFFER_SIZE = 0x8764;
pub const BUFFER_USAGE = 0x8765;
pub const QUERY_COUNTER_BITS = 0x8864;
pub const CURRENT_QUERY = 0x8865;
pub const QUERY_RESULT = 0x8866;
pub const QUERY_RESULT_AVAILABLE = 0x8867;
pub const ARRAY_BUFFER = 0x8892;
pub const ELEMENT_ARRAY_BUFFER = 0x8893;
pub const ARRAY_BUFFER_BINDING = 0x8894;
pub const ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
pub const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
pub const READ_ONLY = 0x88B8;
pub const WRITE_ONLY = 0x88B9;
pub const READ_WRITE = 0x88BA;
pub const BUFFER_ACCESS = 0x88BB;
pub const BUFFER_MAPPED = 0x88BC;
pub const BUFFER_MAP_POINTER = 0x88BD;
pub const STREAM_DRAW = 0x88E0;
pub const STREAM_READ = 0x88E1;
pub const STREAM_COPY = 0x88E2;
pub const STATIC_DRAW = 0x88E4;
pub const STATIC_READ = 0x88E5;
pub const STATIC_COPY = 0x88E6;
pub const DYNAMIC_DRAW = 0x88E8;
pub const DYNAMIC_READ = 0x88E9;
pub const DYNAMIC_COPY = 0x88EA;
pub const SAMPLES_PASSED = 0x8914;
pub const SRC1_ALPHA = 0x8589;
pub const SYNC_FENCE = 0x9116;
pub const SYNC_FLAGS = 0x9115;
pub const SYNC_STATUS = 0x9114;
pub const SYNC_CONDITION = 0x9113;
pub const OBJECT_TYPE = 0x9112;
pub const MAX_SERVER_WAIT_TIMEOUT = 0x9111;
pub const TEXTURE_CUBE_MAP_SEAMLESS = 0x884F;
pub const PROVOKING_VERTEX = 0x8E4F;
pub const LAST_VERTEX_CONVENTION = 0x8E4E;
pub const FIRST_VERTEX_CONVENTION = 0x8E4D;
pub const QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C;
pub const DEPTH_CLAMP = 0x864F;
pub const CONTEXT_PROFILE_MASK = 0x9126;
pub const MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125;
pub const MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124;
pub const MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123;
pub const MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122;
pub const BLEND_EQUATION_RGB = 0x8009;
pub const VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
pub const VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
pub const VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
pub const VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
pub const CURRENT_VERTEX_ATTRIB = 0x8626;
pub const VERTEX_PROGRAM_POINT_SIZE = 0x8642;
pub const VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
pub const STENCIL_BACK_FUNC = 0x8800;
pub const STENCIL_BACK_FAIL = 0x8801;
pub const STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802;
pub const STENCIL_BACK_PASS_DEPTH_PASS = 0x8803;
pub const MAX_DRAW_BUFFERS = 0x8824;
pub const DRAW_BUFFER0 = 0x8825;
pub const DRAW_BUFFER1 = 0x8826;
pub const DRAW_BUFFER2 = 0x8827;
pub const DRAW_BUFFER3 = 0x8828;
pub const DRAW_BUFFER4 = 0x8829;
pub const DRAW_BUFFER5 = 0x882A;
pub const DRAW_BUFFER6 = 0x882B;
pub const DRAW_BUFFER7 = 0x882C;
pub const DRAW_BUFFER8 = 0x882D;
pub const DRAW_BUFFER9 = 0x882E;
pub const DRAW_BUFFER10 = 0x882F;
pub const DRAW_BUFFER11 = 0x8830;
pub const DRAW_BUFFER12 = 0x8831;
pub const DRAW_BUFFER13 = 0x8832;
pub const DRAW_BUFFER14 = 0x8833;
pub const DRAW_BUFFER15 = 0x8834;
pub const BLEND_EQUATION_ALPHA = 0x883D;
pub const MAX_VERTEX_ATTRIBS = 0x8869;
pub const VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
pub const MAX_TEXTURE_IMAGE_UNITS = 0x8872;
pub const FRAGMENT_SHADER = 0x8B30;
pub const VERTEX_SHADER = 0x8B31;
pub const MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49;
pub const MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A;
pub const MAX_VARYING_FLOATS = 0x8B4B;
pub const MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
pub const MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
pub const SHADER_TYPE = 0x8B4F;
pub const FLOAT_VEC2 = 0x8B50;
pub const FLOAT_VEC3 = 0x8B51;
pub const FLOAT_VEC4 = 0x8B52;
pub const INT_VEC2 = 0x8B53;
pub const INT_VEC3 = 0x8B54;
pub const INT_VEC4 = 0x8B55;
pub const BOOL = 0x8B56;
pub const BOOL_VEC2 = 0x8B57;
pub const BOOL_VEC3 = 0x8B58;
pub const BOOL_VEC4 = 0x8B59;
pub const FLOAT_MAT2 = 0x8B5A;
pub const FLOAT_MAT3 = 0x8B5B;
pub const FLOAT_MAT4 = 0x8B5C;
pub const SAMPLER_1D = 0x8B5D;
pub const SAMPLER_2D = 0x8B5E;
pub const SAMPLER_3D = 0x8B5F;
pub const SAMPLER_CUBE = 0x8B60;
pub const SAMPLER_1D_SHADOW = 0x8B61;
pub const SAMPLER_2D_SHADOW = 0x8B62;
pub const DELETE_STATUS = 0x8B80;
pub const COMPILE_STATUS = 0x8B81;
pub const LINK_STATUS = 0x8B82;
pub const VALIDATE_STATUS = 0x8B83;
pub const INFO_LOG_LENGTH = 0x8B84;
pub const ATTACHED_SHADERS = 0x8B85;
pub const ACTIVE_UNIFORMS = 0x8B86;
pub const ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87;
pub const SHADER_SOURCE_LENGTH = 0x8B88;
pub const ACTIVE_ATTRIBUTES = 0x8B89;
pub const ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A;
pub const FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B;
pub const SHADING_LANGUAGE_VERSION = 0x8B8C;
pub const CURRENT_PROGRAM = 0x8B8D;
pub const POINT_SPRITE_COORD_ORIGIN = 0x8CA0;
pub const LOWER_LEFT = 0x8CA1;
pub const UPPER_LEFT = 0x8CA2;
pub const STENCIL_BACK_REF = 0x8CA3;
pub const STENCIL_BACK_VALUE_MASK = 0x8CA4;
pub const STENCIL_BACK_WRITEMASK = 0x8CA5;
pub const MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1;
pub const MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0;
pub const MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF;
pub const GEOMETRY_OUTPUT_TYPE = 0x8918;
pub const PIXEL_PACK_BUFFER = 0x88EB;
pub const PIXEL_UNPACK_BUFFER = 0x88EC;
pub const PIXEL_PACK_BUFFER_BINDING = 0x88ED;
pub const PIXEL_UNPACK_BUFFER_BINDING = 0x88EF;
pub const FLOAT_MAT2x3 = 0x8B65;
pub const FLOAT_MAT2x4 = 0x8B66;
pub const FLOAT_MAT3x2 = 0x8B67;
pub const FLOAT_MAT3x4 = 0x8B68;
pub const FLOAT_MAT4x2 = 0x8B69;
pub const FLOAT_MAT4x3 = 0x8B6A;
pub const SRGB = 0x8C40;
pub const SRGB8 = 0x8C41;
pub const SRGB_ALPHA = 0x8C42;
pub const SRGB8_ALPHA8 = 0x8C43;
pub const COMPRESSED_SRGB = 0x8C48;
pub const COMPRESSED_SRGB_ALPHA = 0x8C49;
pub const GEOMETRY_INPUT_TYPE = 0x8917;
pub const GEOMETRY_VERTICES_OUT = 0x8916;
pub const GEOMETRY_SHADER = 0x8DD9;
pub const FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8;
pub const FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7;
pub const MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29;
pub const PROGRAM_POINT_SIZE = 0x8642;
pub const COMPARE_REF_TO_TEXTURE = 0x884E;
pub const CLIP_DISTANCE0 = 0x3000;
pub const CLIP_DISTANCE1 = 0x3001;
pub const CLIP_DISTANCE2 = 0x3002;
pub const CLIP_DISTANCE3 = 0x3003;
pub const CLIP_DISTANCE4 = 0x3004;
pub const CLIP_DISTANCE5 = 0x3005;
pub const CLIP_DISTANCE6 = 0x3006;
pub const CLIP_DISTANCE7 = 0x3007;
pub const MAX_CLIP_DISTANCES = 0x0D32;
pub const MAJOR_VERSION = 0x821B;
pub const MINOR_VERSION = 0x821C;
pub const NUM_EXTENSIONS = 0x821D;
pub const CONTEXT_FLAGS = 0x821E;
pub const COMPRESSED_RED = 0x8225;
pub const COMPRESSED_RG = 0x8226;
pub const CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001;
pub const RGBA32F = 0x8814;
pub const RGB32F = 0x8815;
pub const RGBA16F = 0x881A;
pub const RGB16F = 0x881B;
pub const VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD;
pub const MAX_ARRAY_TEXTURE_LAYERS = 0x88FF;
pub const MIN_PROGRAM_TEXEL_OFFSET = 0x8904;
pub const MAX_PROGRAM_TEXEL_OFFSET = 0x8905;
pub const CLAMP_READ_COLOR = 0x891C;
pub const FIXED_ONLY = 0x891D;
pub const MAX_VARYING_COMPONENTS = 0x8B4B;
pub const TEXTURE_1D_ARRAY = 0x8C18;
pub const PROXY_TEXTURE_1D_ARRAY = 0x8C19;
pub const TEXTURE_2D_ARRAY = 0x8C1A;
pub const PROXY_TEXTURE_2D_ARRAY = 0x8C1B;
pub const TEXTURE_BINDING_1D_ARRAY = 0x8C1C;
pub const TEXTURE_BINDING_2D_ARRAY = 0x8C1D;
pub const R11F_G11F_B10F = 0x8C3A;
pub const UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B;
pub const RGB9_E5 = 0x8C3D;
pub const UNSIGNED_INT_5_9_9_9_REV = 0x8C3E;
pub const TEXTURE_SHARED_SIZE = 0x8C3F;
pub const TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76;
pub const TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F;
pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80;
pub const TRANSFORM_FEEDBACK_VARYINGS = 0x8C83;
pub const TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84;
pub const TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85;
pub const PRIMITIVES_GENERATED = 0x8C87;
pub const TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88;
pub const RASTERIZER_DISCARD = 0x8C89;
pub const MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A;
pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B;
pub const INTERLEAVED_ATTRIBS = 0x8C8C;
pub const SEPARATE_ATTRIBS = 0x8C8D;
pub const TRANSFORM_FEEDBACK_BUFFER = 0x8C8E;
pub const TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F;
pub const RGBA32UI = 0x8D70;
pub const RGB32UI = 0x8D71;
pub const RGBA16UI = 0x8D76;
pub const RGB16UI = 0x8D77;
pub const RGBA8UI = 0x8D7C;
pub const RGB8UI = 0x8D7D;
pub const RGBA32I = 0x8D82;
pub const RGB32I = 0x8D83;
pub const RGBA16I = 0x8D88;
pub const RGB16I = 0x8D89;
pub const RGBA8I = 0x8D8E;
pub const RGB8I = 0x8D8F;
pub const RED_INTEGER = 0x8D94;
pub const GREEN_INTEGER = 0x8D95;
pub const BLUE_INTEGER = 0x8D96;
pub const RGB_INTEGER = 0x8D98;
pub const RGBA_INTEGER = 0x8D99;
pub const BGR_INTEGER = 0x8D9A;
pub const BGRA_INTEGER = 0x8D9B;
pub const SAMPLER_1D_ARRAY = 0x8DC0;
pub const SAMPLER_2D_ARRAY = 0x8DC1;
pub const SAMPLER_1D_ARRAY_SHADOW = 0x8DC3;
pub const SAMPLER_2D_ARRAY_SHADOW = 0x8DC4;
pub const SAMPLER_CUBE_SHADOW = 0x8DC5;
pub const UNSIGNED_INT_VEC2 = 0x8DC6;
pub const UNSIGNED_INT_VEC3 = 0x8DC7;
pub const UNSIGNED_INT_VEC4 = 0x8DC8;
pub const INT_SAMPLER_1D = 0x8DC9;
pub const INT_SAMPLER_2D = 0x8DCA;
pub const INT_SAMPLER_3D = 0x8DCB;
pub const INT_SAMPLER_CUBE = 0x8DCC;
pub const INT_SAMPLER_1D_ARRAY = 0x8DCE;
pub const INT_SAMPLER_2D_ARRAY = 0x8DCF;
pub const UNSIGNED_INT_SAMPLER_1D = 0x8DD1;
pub const UNSIGNED_INT_SAMPLER_2D = 0x8DD2;
pub const UNSIGNED_INT_SAMPLER_3D = 0x8DD3;
pub const UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4;
pub const UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6;
pub const UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7;
pub const QUERY_WAIT = 0x8E13;
pub const QUERY_NO_WAIT = 0x8E14;
pub const QUERY_BY_REGION_WAIT = 0x8E15;
pub const QUERY_BY_REGION_NO_WAIT = 0x8E16;
pub const BUFFER_ACCESS_FLAGS = 0x911F;
pub const BUFFER_MAP_LENGTH = 0x9120;
pub const BUFFER_MAP_OFFSET = 0x9121;
pub const DEPTH_COMPONENT32F = 0x8CAC;
pub const DEPTH32F_STENCIL8 = 0x8CAD;
pub const FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;
pub const INVALID_FRAMEBUFFER_OPERATION = 0x0506;
pub const FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210;
pub const FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211;
pub const FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212;
pub const FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213;
pub const FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214;
pub const FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215;
pub const FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216;
pub const FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217;
pub const FRAMEBUFFER_DEFAULT = 0x8218;
pub const FRAMEBUFFER_UNDEFINED = 0x8219;
pub const DEPTH_STENCIL_ATTACHMENT = 0x821A;
pub const MAX_RENDERBUFFER_SIZE = 0x84E8;
pub const DEPTH_STENCIL = 0x84F9;
pub const UNSIGNED_INT_24_8 = 0x84FA;
pub const DEPTH24_STENCIL8 = 0x88F0;
pub const TEXTURE_STENCIL_SIZE = 0x88F1;
pub const TEXTURE_RED_TYPE = 0x8C10;
pub const TEXTURE_GREEN_TYPE = 0x8C11;
pub const TEXTURE_BLUE_TYPE = 0x8C12;
pub const TEXTURE_ALPHA_TYPE = 0x8C13;
pub const TEXTURE_DEPTH_TYPE = 0x8C16;
pub const UNSIGNED_NORMALIZED = 0x8C17;
pub const FRAMEBUFFER_BINDING = 0x8CA6;
pub const DRAW_FRAMEBUFFER_BINDING = 0x8CA6;
pub const RENDERBUFFER_BINDING = 0x8CA7;
pub const READ_FRAMEBUFFER = 0x8CA8;
pub const DRAW_FRAMEBUFFER = 0x8CA9;
pub const READ_FRAMEBUFFER_BINDING = 0x8CAA;
pub const RENDERBUFFER_SAMPLES = 0x8CAB;
pub const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
pub const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4;
pub const FRAMEBUFFER_COMPLETE = 0x8CD5;
pub const FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
pub const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
pub const FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB;
pub const FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC;
pub const FRAMEBUFFER_UNSUPPORTED = 0x8CDD;
pub const MAX_COLOR_ATTACHMENTS = 0x8CDF;
pub const COLOR_ATTACHMENT0 = 0x8CE0;
pub const COLOR_ATTACHMENT1 = 0x8CE1;
pub const COLOR_ATTACHMENT2 = 0x8CE2;
pub const COLOR_ATTACHMENT3 = 0x8CE3;
pub const COLOR_ATTACHMENT4 = 0x8CE4;
pub const COLOR_ATTACHMENT5 = 0x8CE5;
pub const COLOR_ATTACHMENT6 = 0x8CE6;
pub const COLOR_ATTACHMENT7 = 0x8CE7;
pub const COLOR_ATTACHMENT8 = 0x8CE8;
pub const COLOR_ATTACHMENT9 = 0x8CE9;
pub const COLOR_ATTACHMENT10 = 0x8CEA;
pub const COLOR_ATTACHMENT11 = 0x8CEB;
pub const COLOR_ATTACHMENT12 = 0x8CEC;
pub const COLOR_ATTACHMENT13 = 0x8CED;
pub const COLOR_ATTACHMENT14 = 0x8CEE;
pub const COLOR_ATTACHMENT15 = 0x8CEF;
pub const COLOR_ATTACHMENT16 = 0x8CF0;
pub const COLOR_ATTACHMENT17 = 0x8CF1;
pub const COLOR_ATTACHMENT18 = 0x8CF2;
pub const COLOR_ATTACHMENT19 = 0x8CF3;
pub const COLOR_ATTACHMENT20 = 0x8CF4;
pub const COLOR_ATTACHMENT21 = 0x8CF5;
pub const COLOR_ATTACHMENT22 = 0x8CF6;
pub const COLOR_ATTACHMENT23 = 0x8CF7;
pub const COLOR_ATTACHMENT24 = 0x8CF8;
pub const COLOR_ATTACHMENT25 = 0x8CF9;
pub const COLOR_ATTACHMENT26 = 0x8CFA;
pub const COLOR_ATTACHMENT27 = 0x8CFB;
pub const COLOR_ATTACHMENT28 = 0x8CFC;
pub const COLOR_ATTACHMENT29 = 0x8CFD;
pub const COLOR_ATTACHMENT30 = 0x8CFE;
pub const COLOR_ATTACHMENT31 = 0x8CFF;
pub const DEPTH_ATTACHMENT = 0x8D00;
pub const STENCIL_ATTACHMENT = 0x8D20;
pub const FRAMEBUFFER = 0x8D40;
pub const RENDERBUFFER = 0x8D41;
pub const RENDERBUFFER_WIDTH = 0x8D42;
pub const RENDERBUFFER_HEIGHT = 0x8D43;
pub const RENDERBUFFER_INTERNAL_FORMAT = 0x8D44;
pub const STENCIL_INDEX1 = 0x8D46;
pub const STENCIL_INDEX4 = 0x8D47;
pub const STENCIL_INDEX8 = 0x8D48;
pub const STENCIL_INDEX16 = 0x8D49;
pub const RENDERBUFFER_RED_SIZE = 0x8D50;
pub const RENDERBUFFER_GREEN_SIZE = 0x8D51;
pub const RENDERBUFFER_BLUE_SIZE = 0x8D52;
pub const RENDERBUFFER_ALPHA_SIZE = 0x8D53;
pub const RENDERBUFFER_DEPTH_SIZE = 0x8D54;
pub const RENDERBUFFER_STENCIL_SIZE = 0x8D55;
pub const FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56;
pub const MAX_SAMPLES = 0x8D57;
pub const LINES_ADJACENCY = 0x000A;
pub const CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002;
pub const CONTEXT_CORE_PROFILE_BIT = 0x00000001;
pub const FRAMEBUFFER_SRGB = 0x8DB9;
pub const HALF_FLOAT = 0x140B;
pub const MAP_READ_BIT = 0x0001;
pub const MAP_WRITE_BIT = 0x0002;
pub const MAP_INVALIDATE_RANGE_BIT = 0x0004;
pub const MAP_INVALIDATE_BUFFER_BIT = 0x0008;
pub const MAP_FLUSH_EXPLICIT_BIT = 0x0010;
pub const MAP_UNSYNCHRONIZED_BIT = 0x0020;
pub const COMPRESSED_RED_RGTC1 = 0x8DBB;
pub const COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC;
pub const COMPRESSED_RG_RGTC2 = 0x8DBD;
pub const COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE;
pub const RG = 0x8227;
pub const RG_INTEGER = 0x8228;
pub const R8 = 0x8229;
pub const R16 = 0x822A;
pub const RG8 = 0x822B;
pub const RG16 = 0x822C;
pub const R16F = 0x822D;
pub const R32F = 0x822E;
pub const RG16F = 0x822F;
pub const RG32F = 0x8230;
pub const R8I = 0x8231;
pub const R8UI = 0x8232;
pub const R16I = 0x8233;
pub const R16UI = 0x8234;
pub const R32I = 0x8235;
pub const R32UI = 0x8236;
pub const RG8I = 0x8237;
pub const RG8UI = 0x8238;
pub const RG16I = 0x8239;
pub const RG16UI = 0x823A;
pub const RG32I = 0x823B;
pub const RG32UI = 0x823C;
pub const VERTEX_ARRAY_BINDING = 0x85B5;
pub const TRIANGLE_STRIP_ADJACENCY = 0x000D;
pub const TRIANGLES_ADJACENCY = 0x000C;
pub const LINE_STRIP_ADJACENCY = 0x000B;
pub const SAMPLER_2D_RECT = 0x8B63;
pub const SAMPLER_2D_RECT_SHADOW = 0x8B64;
pub const SAMPLER_BUFFER = 0x8DC2;
pub const INT_SAMPLER_2D_RECT = 0x8DCD;
pub const INT_SAMPLER_BUFFER = 0x8DD0;
pub const UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5;
pub const UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8;
pub const TEXTURE_BUFFER = 0x8C2A;
pub const MAX_TEXTURE_BUFFER_SIZE = 0x8C2B;
pub const TEXTURE_BINDING_BUFFER = 0x8C2C;
pub const TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D;
pub const TEXTURE_RECTANGLE = 0x84F5;
pub const TEXTURE_BINDING_RECTANGLE = 0x84F6;
pub const PROXY_TEXTURE_RECTANGLE = 0x84F7;
pub const MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8;
pub const R8_SNORM = 0x8F94;
pub const RG8_SNORM = 0x8F95;
pub const RGB8_SNORM = 0x8F96;
pub const RGBA8_SNORM = 0x8F97;
pub const R16_SNORM = 0x8F98;
pub const RG16_SNORM = 0x8F99;
pub const RGB16_SNORM = 0x8F9A;
pub const RGBA16_SNORM = 0x8F9B;
pub const SIGNED_NORMALIZED = 0x8F9C;
pub const PRIMITIVE_RESTART = 0x8F9D;
pub const PRIMITIVE_RESTART_INDEX = 0x8F9E;
pub const COPY_READ_BUFFER = 0x8F36;
pub const COPY_WRITE_BUFFER = 0x8F37;
pub const UNIFORM_BUFFER = 0x8A11;
pub const UNIFORM_BUFFER_BINDING = 0x8A28;
pub const UNIFORM_BUFFER_START = 0x8A29;
pub const UNIFORM_BUFFER_SIZE = 0x8A2A;
pub const MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B;
pub const MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C;
pub const MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D;
pub const MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E;
pub const MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F;
pub const MAX_UNIFORM_BLOCK_SIZE = 0x8A30;
pub const MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31;
pub const MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32;
pub const MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33;
pub const UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34;
pub const ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35;
pub const ACTIVE_UNIFORM_BLOCKS = 0x8A36;
pub const UNIFORM_TYPE = 0x8A37;
pub const UNIFORM_SIZE = 0x8A38;
pub const UNIFORM_NAME_LENGTH = 0x8A39;
pub const UNIFORM_BLOCK_INDEX = 0x8A3A;
pub const UNIFORM_OFFSET = 0x8A3B;
pub const UNIFORM_ARRAY_STRIDE = 0x8A3C;
pub const UNIFORM_MATRIX_STRIDE = 0x8A3D;
pub const UNIFORM_IS_ROW_MAJOR = 0x8A3E;
pub const UNIFORM_BLOCK_BINDING = 0x8A3F;
pub const UNIFORM_BLOCK_DATA_SIZE = 0x8A40;
pub const UNIFORM_BLOCK_NAME_LENGTH = 0x8A41;
pub const UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42;
pub const UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43;
pub const UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44;
pub const UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45;
pub const UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46;
pub const INVALID_INDEX = 0xFFFFFFFF;
pub const STACK_UNDERFLOW = 0x0504;
pub const STACK_OVERFLOW = 0x0503;
pub const MAX_VERTEX_ATTRIB_STRIDE = 0x82E5;
pub const PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221;
pub const TEXTURE_BUFFER_BINDING = 0x8C2A;
pub const MAP_PERSISTENT_BIT = 0x0040;
pub const MAP_COHERENT_BIT = 0x0080;
pub const DYNAMIC_STORAGE_BIT = 0x0100;
pub const CLIENT_STORAGE_BIT = 0x0200;
pub const CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000;
pub const BUFFER_IMMUTABLE_STORAGE = 0x821F;
pub const BUFFER_STORAGE_FLAGS = 0x8220;
pub const CLEAR_TEXTURE = 0x9365;
pub const LOCATION_COMPONENT = 0x934A;
pub const TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B;
pub const TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C;
pub const QUERY_BUFFER = 0x9192;
pub const QUERY_BUFFER_BARRIER_BIT = 0x00008000;
pub const QUERY_BUFFER_BINDING = 0x9193;
pub const QUERY_RESULT_NO_WAIT = 0x9194;
pub const MIRROR_CLAMP_TO_EDGE = 0x8743;
pub fn texStorage2D(_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glTexStorage2D orelse @panic("glTexStorage2D was not bound."))(_target, _levels, _internalformat, _width, _height);
}
pub fn texStorage1D(_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei) void {
return (function_pointers.glTexStorage1D orelse @panic("glTexStorage1D was not bound."))(_target, _levels, _internalformat, _width);
}
pub fn drawTransformFeedbackStreamInstanced(_mode: GLenum, _id: GLuint, _stream: GLuint, _instancecount: GLsizei) void {
return (function_pointers.glDrawTransformFeedbackStreamInstanced orelse @panic("glDrawTransformFeedbackStreamInstanced was not bound."))(_mode, _id, _stream, _instancecount);
}
pub fn drawTransformFeedbackInstanced(_mode: GLenum, _id: GLuint, _instancecount: GLsizei) void {
return (function_pointers.glDrawTransformFeedbackInstanced orelse @panic("glDrawTransformFeedbackInstanced was not bound."))(_mode, _id, _instancecount);
}
pub fn texStorage3D(_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei) void {
return (function_pointers.glTexStorage3D orelse @panic("glTexStorage3D was not bound."))(_target, _levels, _internalformat, _width, _height, _depth);
}
pub fn memoryBarrier(_barriers: GLbitfield) void {
return (function_pointers.glMemoryBarrier orelse @panic("glMemoryBarrier was not bound."))(_barriers);
}
pub fn bindImageTexture(_unit: GLuint, _texture: GLuint, _level: GLint, _layered: GLboolean, _layer: GLint, _access: GLenum, _format: GLenum) void {
return (function_pointers.glBindImageTexture orelse @panic("glBindImageTexture was not bound."))(_unit, _texture, _level, _layered, _layer, _access, _format);
}
pub fn getActiveAtomicCounterBufferiv(_program: GLuint, _bufferIndex: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetActiveAtomicCounterBufferiv orelse @panic("glGetActiveAtomicCounterBufferiv was not bound."))(_program, _bufferIndex, _pname, _params);
}
pub fn getInternalformativ(_target: GLenum, _internalformat: GLenum, _pname: GLenum, _count: GLsizei, _params: [*c]GLint) void {
return (function_pointers.glGetInternalformativ orelse @panic("glGetInternalformativ was not bound."))(_target, _internalformat, _pname, _count, _params);
}
pub fn drawElementsInstancedBaseVertexBaseInstance(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _basevertex: GLint, _baseinstance: GLuint) void {
return (function_pointers.glDrawElementsInstancedBaseVertexBaseInstance orelse @panic("glDrawElementsInstancedBaseVertexBaseInstance was not bound."))(_mode, _count, _type, _indices, _instancecount, _basevertex, _baseinstance);
}
pub fn drawElementsInstancedBaseInstance(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _baseinstance: GLuint) void {
return (function_pointers.glDrawElementsInstancedBaseInstance orelse @panic("glDrawElementsInstancedBaseInstance was not bound."))(_mode, _count, _type, _indices, _instancecount, _baseinstance);
}
pub fn drawArraysInstancedBaseInstance(_mode: GLenum, _first: GLint, _count: GLsizei, _instancecount: GLsizei, _baseinstance: GLuint) void {
return (function_pointers.glDrawArraysInstancedBaseInstance orelse @panic("glDrawArraysInstancedBaseInstance was not bound."))(_mode, _first, _count, _instancecount, _baseinstance);
}
pub fn getDoublei_v(_target: GLenum, _index: GLuint, _data: [*c]GLdouble) void {
return (function_pointers.glGetDoublei_v orelse @panic("glGetDoublei_v was not bound."))(_target, _index, _data);
}
pub fn getFloati_v(_target: GLenum, _index: GLuint, _data: [*c]GLfloat) void {
return (function_pointers.glGetFloati_v orelse @panic("glGetFloati_v was not bound."))(_target, _index, _data);
}
pub fn depthRangeIndexed(_index: GLuint, _n: GLdouble, _f: GLdouble) void {
return (function_pointers.glDepthRangeIndexed orelse @panic("glDepthRangeIndexed was not bound."))(_index, _n, _f);
}
pub fn depthRangeArrayv(_first: GLuint, _count: GLsizei, _v: [*c]const GLdouble) void {
return (function_pointers.glDepthRangeArrayv orelse @panic("glDepthRangeArrayv was not bound."))(_first, _count, _v);
}
pub fn scissorIndexedv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glScissorIndexedv orelse @panic("glScissorIndexedv was not bound."))(_index, _v);
}
pub fn scissorIndexed(_index: GLuint, _left: GLint, _bottom: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glScissorIndexed orelse @panic("glScissorIndexed was not bound."))(_index, _left, _bottom, _width, _height);
}
pub fn scissorArrayv(_first: GLuint, _count: GLsizei, _v: [*c]const GLint) void {
return (function_pointers.glScissorArrayv orelse @panic("glScissorArrayv was not bound."))(_first, _count, _v);
}
pub fn viewportIndexedfv(_index: GLuint, _v: [*c]const GLfloat) void {
return (function_pointers.glViewportIndexedfv orelse @panic("glViewportIndexedfv was not bound."))(_index, _v);
}
pub fn viewportIndexedf(_index: GLuint, _x: GLfloat, _y: GLfloat, _w: GLfloat, _h: GLfloat) void {
return (function_pointers.glViewportIndexedf orelse @panic("glViewportIndexedf was not bound."))(_index, _x, _y, _w, _h);
}
pub fn viewportArrayv(_first: GLuint, _count: GLsizei, _v: [*c]const GLfloat) void {
return (function_pointers.glViewportArrayv orelse @panic("glViewportArrayv was not bound."))(_first, _count, _v);
}
pub fn getVertexAttribLdv(_index: GLuint, _pname: GLenum, _params: [*c]GLdouble) void {
return (function_pointers.glGetVertexAttribLdv orelse @panic("glGetVertexAttribLdv was not bound."))(_index, _pname, _params);
}
pub fn vertexAttribLPointer(_index: GLuint, _size: GLint, _type: GLenum, _stride: GLsizei, _pointer: ?*const anyopaque) void {
return (function_pointers.glVertexAttribLPointer orelse @panic("glVertexAttribLPointer was not bound."))(_index, _size, _type, _stride, _pointer);
}
pub fn vertexAttribL4dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttribL4dv orelse @panic("glVertexAttribL4dv was not bound."))(_index, _v);
}
pub fn vertexAttribL3dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttribL3dv orelse @panic("glVertexAttribL3dv was not bound."))(_index, _v);
}
pub fn vertexAttribL2dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttribL2dv orelse @panic("glVertexAttribL2dv was not bound."))(_index, _v);
}
pub fn vertexAttribL1dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttribL1dv orelse @panic("glVertexAttribL1dv was not bound."))(_index, _v);
}
pub fn vertexAttribL4d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void {
return (function_pointers.glVertexAttribL4d orelse @panic("glVertexAttribL4d was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttribL3d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void {
return (function_pointers.glVertexAttribL3d orelse @panic("glVertexAttribL3d was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttribL2d(_index: GLuint, _x: GLdouble, _y: GLdouble) void {
return (function_pointers.glVertexAttribL2d orelse @panic("glVertexAttribL2d was not bound."))(_index, _x, _y);
}
pub fn vertexAttribL1d(_index: GLuint, _x: GLdouble) void {
return (function_pointers.glVertexAttribL1d orelse @panic("glVertexAttribL1d was not bound."))(_index, _x);
}
pub fn validateProgramPipeline(_pipeline: GLuint) void {
return (function_pointers.glValidateProgramPipeline orelse @panic("glValidateProgramPipeline was not bound."))(_pipeline);
}
pub fn programUniformMatrix4x3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix4x3dv orelse @panic("glProgramUniformMatrix4x3dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3x4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix3x4dv orelse @panic("glProgramUniformMatrix3x4dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix4x2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix4x2dv orelse @panic("glProgramUniformMatrix4x2dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2x4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix2x4dv orelse @panic("glProgramUniformMatrix2x4dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3x2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix3x2dv orelse @panic("glProgramUniformMatrix3x2dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2x3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix2x3dv orelse @panic("glProgramUniformMatrix2x3dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix4x3fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix4x3fv orelse @panic("glProgramUniformMatrix4x3fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3x4fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix3x4fv orelse @panic("glProgramUniformMatrix3x4fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix4x2fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix4x2fv orelse @panic("glProgramUniformMatrix4x2fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2x4fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix2x4fv orelse @panic("glProgramUniformMatrix2x4fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3x2fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix3x2fv orelse @panic("glProgramUniformMatrix3x2fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2x3fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix2x3fv orelse @panic("glProgramUniformMatrix2x3fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix4dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix4dv orelse @panic("glProgramUniformMatrix4dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix3dv orelse @panic("glProgramUniformMatrix3dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2dv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniformMatrix2dv orelse @panic("glProgramUniformMatrix2dv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix4fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix4fv orelse @panic("glProgramUniformMatrix4fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix3fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix3fv orelse @panic("glProgramUniformMatrix3fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniformMatrix2fv(_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniformMatrix2fv orelse @panic("glProgramUniformMatrix2fv was not bound."))(_program, _location, _count, _transpose, _value);
}
pub fn programUniform4uiv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glProgramUniform4uiv orelse @panic("glProgramUniform4uiv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform4ui(_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint, _v3: GLuint) void {
return (function_pointers.glProgramUniform4ui orelse @panic("glProgramUniform4ui was not bound."))(_program, _location, _v0, _v1, _v2, _v3);
}
pub fn programUniform4dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniform4dv orelse @panic("glProgramUniform4dv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform4d(_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble, _v2: GLdouble, _v3: GLdouble) void {
return (function_pointers.glProgramUniform4d orelse @panic("glProgramUniform4d was not bound."))(_program, _location, _v0, _v1, _v2, _v3);
}
pub fn programUniform4fv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniform4fv orelse @panic("glProgramUniform4fv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform4f(_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat, _v3: GLfloat) void {
return (function_pointers.glProgramUniform4f orelse @panic("glProgramUniform4f was not bound."))(_program, _location, _v0, _v1, _v2, _v3);
}
pub fn programUniform4iv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glProgramUniform4iv orelse @panic("glProgramUniform4iv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform4i(_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint, _v2: GLint, _v3: GLint) void {
return (function_pointers.glProgramUniform4i orelse @panic("glProgramUniform4i was not bound."))(_program, _location, _v0, _v1, _v2, _v3);
}
pub fn programUniform3uiv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glProgramUniform3uiv orelse @panic("glProgramUniform3uiv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform3ui(_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint) void {
return (function_pointers.glProgramUniform3ui orelse @panic("glProgramUniform3ui was not bound."))(_program, _location, _v0, _v1, _v2);
}
pub fn programUniform3dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniform3dv orelse @panic("glProgramUniform3dv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform3d(_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble, _v2: GLdouble) void {
return (function_pointers.glProgramUniform3d orelse @panic("glProgramUniform3d was not bound."))(_program, _location, _v0, _v1, _v2);
}
pub fn programUniform3fv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniform3fv orelse @panic("glProgramUniform3fv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform3f(_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat) void {
return (function_pointers.glProgramUniform3f orelse @panic("glProgramUniform3f was not bound."))(_program, _location, _v0, _v1, _v2);
}
pub fn programUniform3iv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glProgramUniform3iv orelse @panic("glProgramUniform3iv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform3i(_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint, _v2: GLint) void {
return (function_pointers.glProgramUniform3i orelse @panic("glProgramUniform3i was not bound."))(_program, _location, _v0, _v1, _v2);
}
pub fn useProgramStages(_pipeline: GLuint, _stages: GLbitfield, _program: GLuint) void {
return (function_pointers.glUseProgramStages orelse @panic("glUseProgramStages was not bound."))(_pipeline, _stages, _program);
}
pub fn programParameteri(_program: GLuint, _pname: GLenum, _value: GLint) void {
return (function_pointers.glProgramParameteri orelse @panic("glProgramParameteri was not bound."))(_program, _pname, _value);
}
pub fn getShaderPrecisionFormat(_shadertype: GLenum, _precisiontype: GLenum, _range: [*c]GLint, _precision: [*c]GLint) void {
return (function_pointers.glGetShaderPrecisionFormat orelse @panic("glGetShaderPrecisionFormat was not bound."))(_shadertype, _precisiontype, _range, _precision);
}
pub fn shaderBinary(_count: GLsizei, _shaders: [*c]const GLuint, _binaryFormat: GLenum, _binary: ?*const anyopaque, _length: GLsizei) void {
return (function_pointers.glShaderBinary orelse @panic("glShaderBinary was not bound."))(_count, _shaders, _binaryFormat, _binary, _length);
}
pub fn releaseShaderCompiler() void {
return (function_pointers.glReleaseShaderCompiler orelse @panic("glReleaseShaderCompiler was not bound."))();
}
pub fn getQueryIndexediv(_target: GLenum, _index: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetQueryIndexediv orelse @panic("glGetQueryIndexediv was not bound."))(_target, _index, _pname, _params);
}
pub fn endQueryIndexed(_target: GLenum, _index: GLuint) void {
return (function_pointers.glEndQueryIndexed orelse @panic("glEndQueryIndexed was not bound."))(_target, _index);
}
pub fn beginQueryIndexed(_target: GLenum, _index: GLuint, _id: GLuint) void {
return (function_pointers.glBeginQueryIndexed orelse @panic("glBeginQueryIndexed was not bound."))(_target, _index, _id);
}
pub fn drawTransformFeedbackStream(_mode: GLenum, _id: GLuint, _stream: GLuint) void {
return (function_pointers.glDrawTransformFeedbackStream orelse @panic("glDrawTransformFeedbackStream was not bound."))(_mode, _id, _stream);
}
pub fn drawTransformFeedback(_mode: GLenum, _id: GLuint) void {
return (function_pointers.glDrawTransformFeedback orelse @panic("glDrawTransformFeedback was not bound."))(_mode, _id);
}
pub fn resumeTransformFeedback() void {
return (function_pointers.glResumeTransformFeedback orelse @panic("glResumeTransformFeedback was not bound."))();
}
pub fn pauseTransformFeedback() void {
return (function_pointers.glPauseTransformFeedback orelse @panic("glPauseTransformFeedback was not bound."))();
}
pub fn getProgramStageiv(_program: GLuint, _shadertype: GLenum, _pname: GLenum, _values: [*c]GLint) void {
return (function_pointers.glGetProgramStageiv orelse @panic("glGetProgramStageiv was not bound."))(_program, _shadertype, _pname, _values);
}
pub fn getUniformSubroutineuiv(_shadertype: GLenum, _location: GLint, _params: [*c]GLuint) void {
return (function_pointers.glGetUniformSubroutineuiv orelse @panic("glGetUniformSubroutineuiv was not bound."))(_shadertype, _location, _params);
}
pub fn uniformSubroutinesuiv(_shadertype: GLenum, _count: GLsizei, _indices: [*c]const GLuint) void {
return (function_pointers.glUniformSubroutinesuiv orelse @panic("glUniformSubroutinesuiv was not bound."))(_shadertype, _count, _indices);
}
pub fn getActiveSubroutineName(_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void {
return (function_pointers.glGetActiveSubroutineName orelse @panic("glGetActiveSubroutineName was not bound."))(_program, _shadertype, _index, _bufSize, _length, _name);
}
pub fn cullFace(_mode: GLenum) void {
return (function_pointers.glCullFace orelse @panic("glCullFace was not bound."))(_mode);
}
pub fn frontFace(_mode: GLenum) void {
return (function_pointers.glFrontFace orelse @panic("glFrontFace was not bound."))(_mode);
}
pub fn hint(_target: GLenum, _mode: GLenum) void {
return (function_pointers.glHint orelse @panic("glHint was not bound."))(_target, _mode);
}
pub fn lineWidth(_width: GLfloat) void {
return (function_pointers.glLineWidth orelse @panic("glLineWidth was not bound."))(_width);
}
pub fn pointSize(_size: GLfloat) void {
return (function_pointers.glPointSize orelse @panic("glPointSize was not bound."))(_size);
}
pub fn polygonMode(_face: GLenum, _mode: GLenum) void {
return (function_pointers.glPolygonMode orelse @panic("glPolygonMode was not bound."))(_face, _mode);
}
pub fn scissor(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glScissor orelse @panic("glScissor was not bound."))(_x, _y, _width, _height);
}
pub fn texParameterf(_target: GLenum, _pname: GLenum, _param: GLfloat) void {
return (function_pointers.glTexParameterf orelse @panic("glTexParameterf was not bound."))(_target, _pname, _param);
}
pub fn texParameterfv(_target: GLenum, _pname: GLenum, _params: [*c]const GLfloat) void {
return (function_pointers.glTexParameterfv orelse @panic("glTexParameterfv was not bound."))(_target, _pname, _params);
}
pub fn texParameteri(_target: GLenum, _pname: GLenum, _param: GLint) void {
return (function_pointers.glTexParameteri orelse @panic("glTexParameteri was not bound."))(_target, _pname, _param);
}
pub fn texParameteriv(_target: GLenum, _pname: GLenum, _params: [*c]const GLint) void {
return (function_pointers.glTexParameteriv orelse @panic("glTexParameteriv was not bound."))(_target, _pname, _params);
}
pub fn texImage1D(_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexImage1D orelse @panic("glTexImage1D was not bound."))(_target, _level, _internalformat, _width, _border, _format, _type, _pixels);
}
pub fn texImage2D(_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexImage2D orelse @panic("glTexImage2D was not bound."))(_target, _level, _internalformat, _width, _height, _border, _format, _type, _pixels);
}
pub fn drawBuffer(_buf: GLenum) void {
return (function_pointers.glDrawBuffer orelse @panic("glDrawBuffer was not bound."))(_buf);
}
pub fn clear(_mask: GLbitfield) void {
return (function_pointers.glClear orelse @panic("glClear was not bound."))(_mask);
}
pub fn clearColor(_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) void {
return (function_pointers.glClearColor orelse @panic("glClearColor was not bound."))(_red, _green, _blue, _alpha);
}
pub fn clearStencil(_s: GLint) void {
return (function_pointers.glClearStencil orelse @panic("glClearStencil was not bound."))(_s);
}
pub fn clearDepth(_depth: GLdouble) void {
return (function_pointers.glClearDepth orelse @panic("glClearDepth was not bound."))(_depth);
}
pub fn stencilMask(_mask: GLuint) void {
return (function_pointers.glStencilMask orelse @panic("glStencilMask was not bound."))(_mask);
}
pub fn colorMask(_red: GLboolean, _green: GLboolean, _blue: GLboolean, _alpha: GLboolean) void {
return (function_pointers.glColorMask orelse @panic("glColorMask was not bound."))(_red, _green, _blue, _alpha);
}
pub fn depthMask(_flag: GLboolean) void {
return (function_pointers.glDepthMask orelse @panic("glDepthMask was not bound."))(_flag);
}
pub fn disable(_cap: GLenum) void {
return (function_pointers.glDisable orelse @panic("glDisable was not bound."))(_cap);
}
pub fn enable(_cap: GLenum) void {
return (function_pointers.glEnable orelse @panic("glEnable was not bound."))(_cap);
}
pub fn finish() void {
return (function_pointers.glFinish orelse @panic("glFinish was not bound."))();
}
pub fn flush() void {
return (function_pointers.glFlush orelse @panic("glFlush was not bound."))();
}
pub fn blendFunc(_sfactor: GLenum, _dfactor: GLenum) void {
return (function_pointers.glBlendFunc orelse @panic("glBlendFunc was not bound."))(_sfactor, _dfactor);
}
pub fn logicOp(_opcode: GLenum) void {
return (function_pointers.glLogicOp orelse @panic("glLogicOp was not bound."))(_opcode);
}
pub fn stencilFunc(_func: GLenum, _ref: GLint, _mask: GLuint) void {
return (function_pointers.glStencilFunc orelse @panic("glStencilFunc was not bound."))(_func, _ref, _mask);
}
pub fn stencilOp(_fail: GLenum, _zfail: GLenum, _zpass: GLenum) void {
return (function_pointers.glStencilOp orelse @panic("glStencilOp was not bound."))(_fail, _zfail, _zpass);
}
pub fn depthFunc(_func: GLenum) void {
return (function_pointers.glDepthFunc orelse @panic("glDepthFunc was not bound."))(_func);
}
pub fn pixelStoref(_pname: GLenum, _param: GLfloat) void {
return (function_pointers.glPixelStoref orelse @panic("glPixelStoref was not bound."))(_pname, _param);
}
pub fn pixelStorei(_pname: GLenum, _param: GLint) void {
return (function_pointers.glPixelStorei orelse @panic("glPixelStorei was not bound."))(_pname, _param);
}
pub fn readBuffer(_src: GLenum) void {
return (function_pointers.glReadBuffer orelse @panic("glReadBuffer was not bound."))(_src);
}
pub fn readPixels(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*anyopaque) void {
return (function_pointers.glReadPixels orelse @panic("glReadPixels was not bound."))(_x, _y, _width, _height, _format, _type, _pixels);
}
pub fn getBooleanv(_pname: GLenum, _data: [*c]GLboolean) void {
return (function_pointers.glGetBooleanv orelse @panic("glGetBooleanv was not bound."))(_pname, _data);
}
pub fn getDoublev(_pname: GLenum, _data: [*c]GLdouble) void {
return (function_pointers.glGetDoublev orelse @panic("glGetDoublev was not bound."))(_pname, _data);
}
pub fn getError() GLenum {
return (function_pointers.glGetError orelse @panic("glGetError was not bound."))();
}
pub fn getFloatv(_pname: GLenum, _data: [*c]GLfloat) void {
return (function_pointers.glGetFloatv orelse @panic("glGetFloatv was not bound."))(_pname, _data);
}
pub fn getIntegerv(_pname: GLenum, _data: [*c]GLint) void {
return (function_pointers.glGetIntegerv orelse @panic("glGetIntegerv was not bound."))(_pname, _data);
}
pub fn getString(_name: GLenum) ?[*:0]const GLubyte {
return (function_pointers.glGetString orelse @panic("glGetString was not bound."))(_name);
}
pub fn getTexImage(_target: GLenum, _level: GLint, _format: GLenum, _type: GLenum, _pixels: ?*anyopaque) void {
return (function_pointers.glGetTexImage orelse @panic("glGetTexImage was not bound."))(_target, _level, _format, _type, _pixels);
}
pub fn getTexParameterfv(_target: GLenum, _pname: GLenum, _params: [*c]GLfloat) void {
return (function_pointers.glGetTexParameterfv orelse @panic("glGetTexParameterfv was not bound."))(_target, _pname, _params);
}
pub fn getTexParameteriv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetTexParameteriv orelse @panic("glGetTexParameteriv was not bound."))(_target, _pname, _params);
}
pub fn getTexLevelParameterfv(_target: GLenum, _level: GLint, _pname: GLenum, _params: [*c]GLfloat) void {
return (function_pointers.glGetTexLevelParameterfv orelse @panic("glGetTexLevelParameterfv was not bound."))(_target, _level, _pname, _params);
}
pub fn getTexLevelParameteriv(_target: GLenum, _level: GLint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetTexLevelParameteriv orelse @panic("glGetTexLevelParameteriv was not bound."))(_target, _level, _pname, _params);
}
pub fn isEnabled(_cap: GLenum) GLboolean {
return (function_pointers.glIsEnabled orelse @panic("glIsEnabled was not bound."))(_cap);
}
pub fn depthRange(_n: GLdouble, _f: GLdouble) void {
return (function_pointers.glDepthRange orelse @panic("glDepthRange was not bound."))(_n, _f);
}
pub fn viewport(_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glViewport orelse @panic("glViewport was not bound."))(_x, _y, _width, _height);
}
pub fn texStorage2DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _fixedsamplelocations: GLboolean) void {
return (function_pointers.glTexStorage2DMultisample orelse @panic("glTexStorage2DMultisample was not bound."))(_target, _samples, _internalformat, _width, _height, _fixedsamplelocations);
}
pub fn texBufferRange(_target: GLenum, _internalformat: GLenum, _buffer: GLuint, _offset: GLintptr, _size: GLsizeiptr) void {
return (function_pointers.glTexBufferRange orelse @panic("glTexBufferRange was not bound."))(_target, _internalformat, _buffer, _offset, _size);
}
pub fn shaderStorageBlockBinding(_program: GLuint, _storageBlockIndex: GLuint, _storageBlockBinding: GLuint) void {
return (function_pointers.glShaderStorageBlockBinding orelse @panic("glShaderStorageBlockBinding was not bound."))(_program, _storageBlockIndex, _storageBlockBinding);
}
pub fn getProgramResourceLocationIndex(_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetProgramResourceLocationIndex orelse @panic("glGetProgramResourceLocationIndex was not bound."))(_program, _programInterface, _name);
}
pub fn getProgramResourceLocation(_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetProgramResourceLocation orelse @panic("glGetProgramResourceLocation was not bound."))(_program, _programInterface, _name);
}
pub fn getProgramResourceiv(_program: GLuint, _programInterface: GLenum, _index: GLuint, _propCount: GLsizei, _props: [*c]const GLenum, _count: GLsizei, _length: [*c]GLsizei, _params: [*c]GLint) void {
return (function_pointers.glGetProgramResourceiv orelse @panic("glGetProgramResourceiv was not bound."))(_program, _programInterface, _index, _propCount, _props, _count, _length, _params);
}
pub fn getProgramResourceName(_program: GLuint, _programInterface: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void {
return (function_pointers.glGetProgramResourceName orelse @panic("glGetProgramResourceName was not bound."))(_program, _programInterface, _index, _bufSize, _length, _name);
}
pub fn getProgramResourceIndex(_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLuint {
return (function_pointers.glGetProgramResourceIndex orelse @panic("glGetProgramResourceIndex was not bound."))(_program, _programInterface, _name);
}
pub fn getProgramInterfaceiv(_program: GLuint, _programInterface: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetProgramInterfaceiv orelse @panic("glGetProgramInterfaceiv was not bound."))(_program, _programInterface, _pname, _params);
}
pub fn multiDrawElementsIndirect(_mode: GLenum, _type: GLenum, _indirect: ?*const anyopaque, _drawcount: GLsizei, _stride: GLsizei) void {
return (function_pointers.glMultiDrawElementsIndirect orelse @panic("glMultiDrawElementsIndirect was not bound."))(_mode, _type, _indirect, _drawcount, _stride);
}
pub fn multiDrawArraysIndirect(_mode: GLenum, _indirect: ?*const anyopaque, _drawcount: GLsizei, _stride: GLsizei) void {
return (function_pointers.glMultiDrawArraysIndirect orelse @panic("glMultiDrawArraysIndirect was not bound."))(_mode, _indirect, _drawcount, _stride);
}
pub fn invalidateSubFramebuffer(_target: GLenum, _numAttachments: GLsizei, _attachments: [*c]const GLenum, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glInvalidateSubFramebuffer orelse @panic("glInvalidateSubFramebuffer was not bound."))(_target, _numAttachments, _attachments, _x, _y, _width, _height);
}
pub fn invalidateFramebuffer(_target: GLenum, _numAttachments: GLsizei, _attachments: [*c]const GLenum) void {
return (function_pointers.glInvalidateFramebuffer orelse @panic("glInvalidateFramebuffer was not bound."))(_target, _numAttachments, _attachments);
}
pub fn invalidateBufferData(_buffer: GLuint) void {
return (function_pointers.glInvalidateBufferData orelse @panic("glInvalidateBufferData was not bound."))(_buffer);
}
pub fn invalidateBufferSubData(_buffer: GLuint, _offset: GLintptr, _length: GLsizeiptr) void {
return (function_pointers.glInvalidateBufferSubData orelse @panic("glInvalidateBufferSubData was not bound."))(_buffer, _offset, _length);
}
pub fn invalidateTexImage(_texture: GLuint, _level: GLint) void {
return (function_pointers.glInvalidateTexImage orelse @panic("glInvalidateTexImage was not bound."))(_texture, _level);
}
pub fn invalidateTexSubImage(_texture: GLuint, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei) void {
return (function_pointers.glInvalidateTexSubImage orelse @panic("glInvalidateTexSubImage was not bound."))(_texture, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth);
}
pub fn getInternalformati64v(_target: GLenum, _internalformat: GLenum, _pname: GLenum, _count: GLsizei, _params: [*c]GLint64) void {
return (function_pointers.glGetInternalformati64v orelse @panic("glGetInternalformati64v was not bound."))(_target, _internalformat, _pname, _count, _params);
}
pub fn getFramebufferParameteriv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetFramebufferParameteriv orelse @panic("glGetFramebufferParameteriv was not bound."))(_target, _pname, _params);
}
pub fn framebufferParameteri(_target: GLenum, _pname: GLenum, _param: GLint) void {
return (function_pointers.glFramebufferParameteri orelse @panic("glFramebufferParameteri was not bound."))(_target, _pname, _param);
}
pub fn copyImageSubData(_srcName: GLuint, _srcTarget: GLenum, _srcLevel: GLint, _srcX: GLint, _srcY: GLint, _srcZ: GLint, _dstName: GLuint, _dstTarget: GLenum, _dstLevel: GLint, _dstX: GLint, _dstY: GLint, _dstZ: GLint, _srcWidth: GLsizei, _srcHeight: GLsizei, _srcDepth: GLsizei) void {
return (function_pointers.glCopyImageSubData orelse @panic("glCopyImageSubData was not bound."))(_srcName, _srcTarget, _srcLevel, _srcX, _srcY, _srcZ, _dstName, _dstTarget, _dstLevel, _dstX, _dstY, _dstZ, _srcWidth, _srcHeight, _srcDepth);
}
pub fn dispatchComputeIndirect(_indirect: GLintptr) void {
return (function_pointers.glDispatchComputeIndirect orelse @panic("glDispatchComputeIndirect was not bound."))(_indirect);
}
pub fn dispatchCompute(_num_groups_x: GLuint, _num_groups_y: GLuint, _num_groups_z: GLuint) void {
return (function_pointers.glDispatchCompute orelse @panic("glDispatchCompute was not bound."))(_num_groups_x, _num_groups_y, _num_groups_z);
}
pub fn clearBufferSubData(_target: GLenum, _internalformat: GLenum, _offset: GLintptr, _size: GLsizeiptr, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void {
return (function_pointers.glClearBufferSubData orelse @panic("glClearBufferSubData was not bound."))(_target, _internalformat, _offset, _size, _format, _type, _data);
}
pub fn clearBufferData(_target: GLenum, _internalformat: GLenum, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void {
return (function_pointers.glClearBufferData orelse @panic("glClearBufferData was not bound."))(_target, _internalformat, _format, _type, _data);
}
pub fn getProgramPipelineInfoLog(_pipeline: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void {
return (function_pointers.glGetProgramPipelineInfoLog orelse @panic("glGetProgramPipelineInfoLog was not bound."))(_pipeline, _bufSize, _length, _infoLog);
}
pub fn programUniform2uiv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glProgramUniform2uiv orelse @panic("glProgramUniform2uiv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform2ui(_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint) void {
return (function_pointers.glProgramUniform2ui orelse @panic("glProgramUniform2ui was not bound."))(_program, _location, _v0, _v1);
}
pub fn programUniform2dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniform2dv orelse @panic("glProgramUniform2dv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform2d(_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble) void {
return (function_pointers.glProgramUniform2d orelse @panic("glProgramUniform2d was not bound."))(_program, _location, _v0, _v1);
}
pub fn programUniform2fv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniform2fv orelse @panic("glProgramUniform2fv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform2f(_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat) void {
return (function_pointers.glProgramUniform2f orelse @panic("glProgramUniform2f was not bound."))(_program, _location, _v0, _v1);
}
pub fn programUniform2iv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glProgramUniform2iv orelse @panic("glProgramUniform2iv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform2i(_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint) void {
return (function_pointers.glProgramUniform2i orelse @panic("glProgramUniform2i was not bound."))(_program, _location, _v0, _v1);
}
pub fn programUniform1uiv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glProgramUniform1uiv orelse @panic("glProgramUniform1uiv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform1ui(_program: GLuint, _location: GLint, _v0: GLuint) void {
return (function_pointers.glProgramUniform1ui orelse @panic("glProgramUniform1ui was not bound."))(_program, _location, _v0);
}
pub fn programUniform1dv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glProgramUniform1dv orelse @panic("glProgramUniform1dv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform1d(_program: GLuint, _location: GLint, _v0: GLdouble) void {
return (function_pointers.glProgramUniform1d orelse @panic("glProgramUniform1d was not bound."))(_program, _location, _v0);
}
pub fn programUniform1fv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glProgramUniform1fv orelse @panic("glProgramUniform1fv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform1f(_program: GLuint, _location: GLint, _v0: GLfloat) void {
return (function_pointers.glProgramUniform1f orelse @panic("glProgramUniform1f was not bound."))(_program, _location, _v0);
}
pub fn programUniform1iv(_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glProgramUniform1iv orelse @panic("glProgramUniform1iv was not bound."))(_program, _location, _count, _value);
}
pub fn programUniform1i(_program: GLuint, _location: GLint, _v0: GLint) void {
return (function_pointers.glProgramUniform1i orelse @panic("glProgramUniform1i was not bound."))(_program, _location, _v0);
}
pub fn getProgramPipelineiv(_pipeline: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetProgramPipelineiv orelse @panic("glGetProgramPipelineiv was not bound."))(_pipeline, _pname, _params);
}
pub fn isProgramPipeline(_pipeline: GLuint) GLboolean {
return (function_pointers.glIsProgramPipeline orelse @panic("glIsProgramPipeline was not bound."))(_pipeline);
}
pub fn genProgramPipelines(_n: GLsizei, _pipelines: [*c]GLuint) void {
return (function_pointers.glGenProgramPipelines orelse @panic("glGenProgramPipelines was not bound."))(_n, _pipelines);
}
pub fn deleteProgramPipelines(_n: GLsizei, _pipelines: [*c]const GLuint) void {
return (function_pointers.glDeleteProgramPipelines orelse @panic("glDeleteProgramPipelines was not bound."))(_n, _pipelines);
}
pub fn bindProgramPipeline(_pipeline: GLuint) void {
return (function_pointers.glBindProgramPipeline orelse @panic("glBindProgramPipeline was not bound."))(_pipeline);
}
pub fn createShaderProgramv(_type: GLenum, _count: GLsizei, _strings: [*c]const [*c]const GLchar) GLuint {
return (function_pointers.glCreateShaderProgramv orelse @panic("glCreateShaderProgramv was not bound."))(_type, _count, _strings);
}
pub fn activeShaderProgram(_pipeline: GLuint, _program: GLuint) void {
return (function_pointers.glActiveShaderProgram orelse @panic("glActiveShaderProgram was not bound."))(_pipeline, _program);
}
pub fn programBinary(_program: GLuint, _binaryFormat: GLenum, _binary: ?*const anyopaque, _length: GLsizei) void {
return (function_pointers.glProgramBinary orelse @panic("glProgramBinary was not bound."))(_program, _binaryFormat, _binary, _length);
}
pub fn getProgramBinary(_program: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _binaryFormat: [*c]GLenum, _binary: ?*anyopaque) void {
return (function_pointers.glGetProgramBinary orelse @panic("glGetProgramBinary was not bound."))(_program, _bufSize, _length, _binaryFormat, _binary);
}
pub fn clearDepthf(_d: GLfloat) void {
return (function_pointers.glClearDepthf orelse @panic("glClearDepthf was not bound."))(_d);
}
pub fn depthRangef(_n: GLfloat, _f: GLfloat) void {
return (function_pointers.glDepthRangef orelse @panic("glDepthRangef was not bound."))(_n, _f);
}
pub fn isTransformFeedback(_id: GLuint) GLboolean {
return (function_pointers.glIsTransformFeedback orelse @panic("glIsTransformFeedback was not bound."))(_id);
}
pub fn genTransformFeedbacks(_n: GLsizei, _ids: [*c]GLuint) void {
return (function_pointers.glGenTransformFeedbacks orelse @panic("glGenTransformFeedbacks was not bound."))(_n, _ids);
}
pub fn deleteTransformFeedbacks(_n: GLsizei, _ids: [*c]const GLuint) void {
return (function_pointers.glDeleteTransformFeedbacks orelse @panic("glDeleteTransformFeedbacks was not bound."))(_n, _ids);
}
pub fn bindTransformFeedback(_target: GLenum, _id: GLuint) void {
return (function_pointers.glBindTransformFeedback orelse @panic("glBindTransformFeedback was not bound."))(_target, _id);
}
pub fn patchParameterfv(_pname: GLenum, _values: [*c]const GLfloat) void {
return (function_pointers.glPatchParameterfv orelse @panic("glPatchParameterfv was not bound."))(_pname, _values);
}
pub fn patchParameteri(_pname: GLenum, _value: GLint) void {
return (function_pointers.glPatchParameteri orelse @panic("glPatchParameteri was not bound."))(_pname, _value);
}
pub fn drawArrays(_mode: GLenum, _first: GLint, _count: GLsizei) void {
return (function_pointers.glDrawArrays orelse @panic("glDrawArrays was not bound."))(_mode, _first, _count);
}
pub fn drawElements(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque) void {
return (function_pointers.glDrawElements orelse @panic("glDrawElements was not bound."))(_mode, _count, _type, _indices);
}
pub fn polygonOffset(_factor: GLfloat, _units: GLfloat) void {
return (function_pointers.glPolygonOffset orelse @panic("glPolygonOffset was not bound."))(_factor, _units);
}
pub fn copyTexImage1D(_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _border: GLint) void {
return (function_pointers.glCopyTexImage1D orelse @panic("glCopyTexImage1D was not bound."))(_target, _level, _internalformat, _x, _y, _width, _border);
}
pub fn copyTexImage2D(_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _border: GLint) void {
return (function_pointers.glCopyTexImage2D orelse @panic("glCopyTexImage2D was not bound."))(_target, _level, _internalformat, _x, _y, _width, _height, _border);
}
pub fn copyTexSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei) void {
return (function_pointers.glCopyTexSubImage1D orelse @panic("glCopyTexSubImage1D was not bound."))(_target, _level, _xoffset, _x, _y, _width);
}
pub fn copyTexSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glCopyTexSubImage2D orelse @panic("glCopyTexSubImage2D was not bound."))(_target, _level, _xoffset, _yoffset, _x, _y, _width, _height);
}
pub fn texSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexSubImage1D orelse @panic("glTexSubImage1D was not bound."))(_target, _level, _xoffset, _width, _format, _type, _pixels);
}
pub fn texSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexSubImage2D orelse @panic("glTexSubImage2D was not bound."))(_target, _level, _xoffset, _yoffset, _width, _height, _format, _type, _pixels);
}
pub fn bindTexture(_target: GLenum, _texture: GLuint) void {
return (function_pointers.glBindTexture orelse @panic("glBindTexture was not bound."))(_target, _texture);
}
pub fn deleteTextures(_n: GLsizei, _textures: [*c]const GLuint) void {
return (function_pointers.glDeleteTextures orelse @panic("glDeleteTextures was not bound."))(_n, _textures);
}
pub fn genTextures(_n: GLsizei, _textures: [*c]GLuint) void {
return (function_pointers.glGenTextures orelse @panic("glGenTextures was not bound."))(_n, _textures);
}
pub fn isTexture(_texture: GLuint) GLboolean {
return (function_pointers.glIsTexture orelse @panic("glIsTexture was not bound."))(_texture);
}
pub fn getActiveSubroutineUniformName(_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void {
return (function_pointers.glGetActiveSubroutineUniformName orelse @panic("glGetActiveSubroutineUniformName was not bound."))(_program, _shadertype, _index, _bufSize, _length, _name);
}
pub fn getActiveSubroutineUniformiv(_program: GLuint, _shadertype: GLenum, _index: GLuint, _pname: GLenum, _values: [*c]GLint) void {
return (function_pointers.glGetActiveSubroutineUniformiv orelse @panic("glGetActiveSubroutineUniformiv was not bound."))(_program, _shadertype, _index, _pname, _values);
}
pub fn getSubroutineIndex(_program: GLuint, _shadertype: GLenum, _name: [*c]const GLchar) GLuint {
return (function_pointers.glGetSubroutineIndex orelse @panic("glGetSubroutineIndex was not bound."))(_program, _shadertype, _name);
}
pub fn getSubroutineUniformLocation(_program: GLuint, _shadertype: GLenum, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetSubroutineUniformLocation orelse @panic("glGetSubroutineUniformLocation was not bound."))(_program, _shadertype, _name);
}
pub fn getUniformdv(_program: GLuint, _location: GLint, _params: [*c]GLdouble) void {
return (function_pointers.glGetUniformdv orelse @panic("glGetUniformdv was not bound."))(_program, _location, _params);
}
pub fn uniformMatrix4x3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix4x3dv orelse @panic("glUniformMatrix4x3dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix4x2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix4x2dv orelse @panic("glUniformMatrix4x2dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3x4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix3x4dv orelse @panic("glUniformMatrix3x4dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3x2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix3x2dv orelse @panic("glUniformMatrix3x2dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix2x4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix2x4dv orelse @panic("glUniformMatrix2x4dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix2x3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix2x3dv orelse @panic("glUniformMatrix2x3dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix4dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix4dv orelse @panic("glUniformMatrix4dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix3dv orelse @panic("glUniformMatrix3dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn drawRangeElements(_mode: GLenum, _start: GLuint, _end: GLuint, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque) void {
return (function_pointers.glDrawRangeElements orelse @panic("glDrawRangeElements was not bound."))(_mode, _start, _end, _count, _type, _indices);
}
pub fn texImage3D(_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexImage3D orelse @panic("glTexImage3D was not bound."))(_target, _level, _internalformat, _width, _height, _depth, _border, _format, _type, _pixels);
}
pub fn texSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void {
return (function_pointers.glTexSubImage3D orelse @panic("glTexSubImage3D was not bound."))(_target, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth, _format, _type, _pixels);
}
pub fn copyTexSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glCopyTexSubImage3D orelse @panic("glCopyTexSubImage3D was not bound."))(_target, _level, _xoffset, _yoffset, _zoffset, _x, _y, _width, _height);
}
pub fn uniformMatrix2dv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void {
return (function_pointers.glUniformMatrix2dv orelse @panic("glUniformMatrix2dv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniform4dv(_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glUniform4dv orelse @panic("glUniform4dv was not bound."))(_location, _count, _value);
}
pub fn uniform3dv(_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glUniform3dv orelse @panic("glUniform3dv was not bound."))(_location, _count, _value);
}
pub fn uniform2dv(_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glUniform2dv orelse @panic("glUniform2dv was not bound."))(_location, _count, _value);
}
pub fn uniform1dv(_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void {
return (function_pointers.glUniform1dv orelse @panic("glUniform1dv was not bound."))(_location, _count, _value);
}
pub fn uniform4d(_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void {
return (function_pointers.glUniform4d orelse @panic("glUniform4d was not bound."))(_location, _x, _y, _z, _w);
}
pub fn uniform3d(_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void {
return (function_pointers.glUniform3d orelse @panic("glUniform3d was not bound."))(_location, _x, _y, _z);
}
pub fn uniform2d(_location: GLint, _x: GLdouble, _y: GLdouble) void {
return (function_pointers.glUniform2d orelse @panic("glUniform2d was not bound."))(_location, _x, _y);
}
pub fn uniform1d(_location: GLint, _x: GLdouble) void {
return (function_pointers.glUniform1d orelse @panic("glUniform1d was not bound."))(_location, _x);
}
pub fn drawElementsIndirect(_mode: GLenum, _type: GLenum, _indirect: ?*const anyopaque) void {
return (function_pointers.glDrawElementsIndirect orelse @panic("glDrawElementsIndirect was not bound."))(_mode, _type, _indirect);
}
pub fn drawArraysIndirect(_mode: GLenum, _indirect: ?*const anyopaque) void {
return (function_pointers.glDrawArraysIndirect orelse @panic("glDrawArraysIndirect was not bound."))(_mode, _indirect);
}
pub fn blendFuncSeparatei(_buf: GLuint, _srcRGB: GLenum, _dstRGB: GLenum, _srcAlpha: GLenum, _dstAlpha: GLenum) void {
return (function_pointers.glBlendFuncSeparatei orelse @panic("glBlendFuncSeparatei was not bound."))(_buf, _srcRGB, _dstRGB, _srcAlpha, _dstAlpha);
}
pub fn blendFunci(_buf: GLuint, _src: GLenum, _dst: GLenum) void {
return (function_pointers.glBlendFunci orelse @panic("glBlendFunci was not bound."))(_buf, _src, _dst);
}
pub fn blendEquationSeparatei(_buf: GLuint, _modeRGB: GLenum, _modeAlpha: GLenum) void {
return (function_pointers.glBlendEquationSeparatei orelse @panic("glBlendEquationSeparatei was not bound."))(_buf, _modeRGB, _modeAlpha);
}
pub fn blendEquationi(_buf: GLuint, _mode: GLenum) void {
return (function_pointers.glBlendEquationi orelse @panic("glBlendEquationi was not bound."))(_buf, _mode);
}
pub fn minSampleShading(_value: GLfloat) void {
return (function_pointers.glMinSampleShading orelse @panic("glMinSampleShading was not bound."))(_value);
}
pub fn activeTexture(_texture: GLenum) void {
return (function_pointers.glActiveTexture orelse @panic("glActiveTexture was not bound."))(_texture);
}
pub fn sampleCoverage(_value: GLfloat, _invert: GLboolean) void {
return (function_pointers.glSampleCoverage orelse @panic("glSampleCoverage was not bound."))(_value, _invert);
}
pub fn compressedTexImage3D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexImage3D orelse @panic("glCompressedTexImage3D was not bound."))(_target, _level, _internalformat, _width, _height, _depth, _border, _imageSize, _data);
}
pub fn compressedTexImage2D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexImage2D orelse @panic("glCompressedTexImage2D was not bound."))(_target, _level, _internalformat, _width, _height, _border, _imageSize, _data);
}
pub fn compressedTexImage1D(_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexImage1D orelse @panic("glCompressedTexImage1D was not bound."))(_target, _level, _internalformat, _width, _border, _imageSize, _data);
}
pub fn compressedTexSubImage3D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexSubImage3D orelse @panic("glCompressedTexSubImage3D was not bound."))(_target, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth, _format, _imageSize, _data);
}
pub fn compressedTexSubImage2D(_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexSubImage2D orelse @panic("glCompressedTexSubImage2D was not bound."))(_target, _level, _xoffset, _yoffset, _width, _height, _format, _imageSize, _data);
}
pub fn compressedTexSubImage1D(_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void {
return (function_pointers.glCompressedTexSubImage1D orelse @panic("glCompressedTexSubImage1D was not bound."))(_target, _level, _xoffset, _width, _format, _imageSize, _data);
}
pub fn getCompressedTexImage(_target: GLenum, _level: GLint, _img: ?*anyopaque) void {
return (function_pointers.glGetCompressedTexImage orelse @panic("glGetCompressedTexImage was not bound."))(_target, _level, _img);
}
pub fn vertexAttribP4uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void {
return (function_pointers.glVertexAttribP4uiv orelse @panic("glVertexAttribP4uiv was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP4ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void {
return (function_pointers.glVertexAttribP4ui orelse @panic("glVertexAttribP4ui was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP3uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void {
return (function_pointers.glVertexAttribP3uiv orelse @panic("glVertexAttribP3uiv was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP3ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void {
return (function_pointers.glVertexAttribP3ui orelse @panic("glVertexAttribP3ui was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP2uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void {
return (function_pointers.glVertexAttribP2uiv orelse @panic("glVertexAttribP2uiv was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP2ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void {
return (function_pointers.glVertexAttribP2ui orelse @panic("glVertexAttribP2ui was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP1uiv(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void {
return (function_pointers.glVertexAttribP1uiv orelse @panic("glVertexAttribP1uiv was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribP1ui(_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void {
return (function_pointers.glVertexAttribP1ui orelse @panic("glVertexAttribP1ui was not bound."))(_index, _type, _normalized, _value);
}
pub fn vertexAttribDivisor(_index: GLuint, _divisor: GLuint) void {
return (function_pointers.glVertexAttribDivisor orelse @panic("glVertexAttribDivisor was not bound."))(_index, _divisor);
}
pub fn getQueryObjectui64v(_id: GLuint, _pname: GLenum, _params: [*c]GLuint64) void {
return (function_pointers.glGetQueryObjectui64v orelse @panic("glGetQueryObjectui64v was not bound."))(_id, _pname, _params);
}
pub fn getQueryObjecti64v(_id: GLuint, _pname: GLenum, _params: [*c]GLint64) void {
return (function_pointers.glGetQueryObjecti64v orelse @panic("glGetQueryObjecti64v was not bound."))(_id, _pname, _params);
}
pub fn queryCounter(_id: GLuint, _target: GLenum) void {
return (function_pointers.glQueryCounter orelse @panic("glQueryCounter was not bound."))(_id, _target);
}
pub fn getSamplerParameterIuiv(_sampler: GLuint, _pname: GLenum, _params: [*c]GLuint) void {
return (function_pointers.glGetSamplerParameterIuiv orelse @panic("glGetSamplerParameterIuiv was not bound."))(_sampler, _pname, _params);
}
pub fn getSamplerParameterfv(_sampler: GLuint, _pname: GLenum, _params: [*c]GLfloat) void {
return (function_pointers.glGetSamplerParameterfv orelse @panic("glGetSamplerParameterfv was not bound."))(_sampler, _pname, _params);
}
pub fn getSamplerParameterIiv(_sampler: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetSamplerParameterIiv orelse @panic("glGetSamplerParameterIiv was not bound."))(_sampler, _pname, _params);
}
pub fn getSamplerParameteriv(_sampler: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetSamplerParameteriv orelse @panic("glGetSamplerParameteriv was not bound."))(_sampler, _pname, _params);
}
pub fn samplerParameterIuiv(_sampler: GLuint, _pname: GLenum, _param: [*c]const GLuint) void {
return (function_pointers.glSamplerParameterIuiv orelse @panic("glSamplerParameterIuiv was not bound."))(_sampler, _pname, _param);
}
pub fn samplerParameterIiv(_sampler: GLuint, _pname: GLenum, _param: [*c]const GLint) void {
return (function_pointers.glSamplerParameterIiv orelse @panic("glSamplerParameterIiv was not bound."))(_sampler, _pname, _param);
}
pub fn samplerParameterfv(_sampler: GLuint, _pname: GLenum, _param: [*c]const GLfloat) void {
return (function_pointers.glSamplerParameterfv orelse @panic("glSamplerParameterfv was not bound."))(_sampler, _pname, _param);
}
pub fn samplerParameterf(_sampler: GLuint, _pname: GLenum, _param: GLfloat) void {
return (function_pointers.glSamplerParameterf orelse @panic("glSamplerParameterf was not bound."))(_sampler, _pname, _param);
}
pub fn samplerParameteriv(_sampler: GLuint, _pname: GLenum, _param: [*c]const GLint) void {
return (function_pointers.glSamplerParameteriv orelse @panic("glSamplerParameteriv was not bound."))(_sampler, _pname, _param);
}
pub fn samplerParameteri(_sampler: GLuint, _pname: GLenum, _param: GLint) void {
return (function_pointers.glSamplerParameteri orelse @panic("glSamplerParameteri was not bound."))(_sampler, _pname, _param);
}
pub fn bindSampler(_unit: GLuint, _sampler: GLuint) void {
return (function_pointers.glBindSampler orelse @panic("glBindSampler was not bound."))(_unit, _sampler);
}
pub fn isSampler(_sampler: GLuint) GLboolean {
return (function_pointers.glIsSampler orelse @panic("glIsSampler was not bound."))(_sampler);
}
pub fn deleteSamplers(_count: GLsizei, _samplers: [*c]const GLuint) void {
return (function_pointers.glDeleteSamplers orelse @panic("glDeleteSamplers was not bound."))(_count, _samplers);
}
pub fn genSamplers(_count: GLsizei, _samplers: [*c]GLuint) void {
return (function_pointers.glGenSamplers orelse @panic("glGenSamplers was not bound."))(_count, _samplers);
}
pub fn getFragDataIndex(_program: GLuint, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetFragDataIndex orelse @panic("glGetFragDataIndex was not bound."))(_program, _name);
}
pub fn bindFragDataLocationIndexed(_program: GLuint, _colorNumber: GLuint, _index: GLuint, _name: [*c]const GLchar) void {
return (function_pointers.glBindFragDataLocationIndexed orelse @panic("glBindFragDataLocationIndexed was not bound."))(_program, _colorNumber, _index, _name);
}
pub fn sampleMaski(_maskNumber: GLuint, _mask: GLbitfield) void {
return (function_pointers.glSampleMaski orelse @panic("glSampleMaski was not bound."))(_maskNumber, _mask);
}
pub fn getMultisamplefv(_pname: GLenum, _index: GLuint, _val: [*c]GLfloat) void {
return (function_pointers.glGetMultisamplefv orelse @panic("glGetMultisamplefv was not bound."))(_pname, _index, _val);
}
pub fn texImage3DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _fixedsamplelocations: GLboolean) void {
return (function_pointers.glTexImage3DMultisample orelse @panic("glTexImage3DMultisample was not bound."))(_target, _samples, _internalformat, _width, _height, _depth, _fixedsamplelocations);
}
pub fn texImage2DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _fixedsamplelocations: GLboolean) void {
return (function_pointers.glTexImage2DMultisample orelse @panic("glTexImage2DMultisample was not bound."))(_target, _samples, _internalformat, _width, _height, _fixedsamplelocations);
}
pub fn framebufferTexture(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint) void {
return (function_pointers.glFramebufferTexture orelse @panic("glFramebufferTexture was not bound."))(_target, _attachment, _texture, _level);
}
pub fn getBufferParameteri64v(_target: GLenum, _pname: GLenum, _params: [*c]GLint64) void {
return (function_pointers.glGetBufferParameteri64v orelse @panic("glGetBufferParameteri64v was not bound."))(_target, _pname, _params);
}
pub fn blendFuncSeparate(_sfactorRGB: GLenum, _dfactorRGB: GLenum, _sfactorAlpha: GLenum, _dfactorAlpha: GLenum) void {
return (function_pointers.glBlendFuncSeparate orelse @panic("glBlendFuncSeparate was not bound."))(_sfactorRGB, _dfactorRGB, _sfactorAlpha, _dfactorAlpha);
}
pub fn multiDrawArrays(_mode: GLenum, _first: [*c]const GLint, _count: [*c]const GLsizei, _drawcount: GLsizei) void {
return (function_pointers.glMultiDrawArrays orelse @panic("glMultiDrawArrays was not bound."))(_mode, _first, _count, _drawcount);
}
pub fn multiDrawElements(_mode: GLenum, _count: [*c]const GLsizei, _type: GLenum, _indices: [*c]const ?*const anyopaque, _drawcount: GLsizei) void {
return (function_pointers.glMultiDrawElements orelse @panic("glMultiDrawElements was not bound."))(_mode, _count, _type, _indices, _drawcount);
}
pub fn pointParameterf(_pname: GLenum, _param: GLfloat) void {
return (function_pointers.glPointParameterf orelse @panic("glPointParameterf was not bound."))(_pname, _param);
}
pub fn pointParameterfv(_pname: GLenum, _params: [*c]const GLfloat) void {
return (function_pointers.glPointParameterfv orelse @panic("glPointParameterfv was not bound."))(_pname, _params);
}
pub fn pointParameteri(_pname: GLenum, _param: GLint) void {
return (function_pointers.glPointParameteri orelse @panic("glPointParameteri was not bound."))(_pname, _param);
}
pub fn pointParameteriv(_pname: GLenum, _params: [*c]const GLint) void {
return (function_pointers.glPointParameteriv orelse @panic("glPointParameteriv was not bound."))(_pname, _params);
}
pub fn getInteger64i_v(_target: GLenum, _index: GLuint, _data: [*c]GLint64) void {
return (function_pointers.glGetInteger64i_v orelse @panic("glGetInteger64i_v was not bound."))(_target, _index, _data);
}
pub fn getSynciv(_sync: GLsync, _pname: GLenum, _count: GLsizei, _length: [*c]GLsizei, _values: [*c]GLint) void {
return (function_pointers.glGetSynciv orelse @panic("glGetSynciv was not bound."))(_sync, _pname, _count, _length, _values);
}
pub fn getInteger64v(_pname: GLenum, _data: [*c]GLint64) void {
return (function_pointers.glGetInteger64v orelse @panic("glGetInteger64v was not bound."))(_pname, _data);
}
pub fn waitSync(_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) void {
return (function_pointers.glWaitSync orelse @panic("glWaitSync was not bound."))(_sync, _flags, _timeout);
}
pub fn clientWaitSync(_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) GLenum {
return (function_pointers.glClientWaitSync orelse @panic("glClientWaitSync was not bound."))(_sync, _flags, _timeout);
}
pub fn deleteSync(_sync: GLsync) void {
return (function_pointers.glDeleteSync orelse @panic("glDeleteSync was not bound."))(_sync);
}
pub fn isSync(_sync: GLsync) GLboolean {
return (function_pointers.glIsSync orelse @panic("glIsSync was not bound."))(_sync);
}
pub fn fenceSync(_condition: GLenum, _flags: GLbitfield) GLsync {
return (function_pointers.glFenceSync orelse @panic("glFenceSync was not bound."))(_condition, _flags);
}
pub fn blendColor(_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) void {
return (function_pointers.glBlendColor orelse @panic("glBlendColor was not bound."))(_red, _green, _blue, _alpha);
}
pub fn blendEquation(_mode: GLenum) void {
return (function_pointers.glBlendEquation orelse @panic("glBlendEquation was not bound."))(_mode);
}
pub fn provokingVertex(_mode: GLenum) void {
return (function_pointers.glProvokingVertex orelse @panic("glProvokingVertex was not bound."))(_mode);
}
pub fn multiDrawElementsBaseVertex(_mode: GLenum, _count: [*c]const GLsizei, _type: GLenum, _indices: [*c]const ?*const anyopaque, _drawcount: GLsizei, _basevertex: [*c]const GLint) void {
return (function_pointers.glMultiDrawElementsBaseVertex orelse @panic("glMultiDrawElementsBaseVertex was not bound."))(_mode, _count, _type, _indices, _drawcount, _basevertex);
}
pub fn drawElementsInstancedBaseVertex(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _basevertex: GLint) void {
return (function_pointers.glDrawElementsInstancedBaseVertex orelse @panic("glDrawElementsInstancedBaseVertex was not bound."))(_mode, _count, _type, _indices, _instancecount, _basevertex);
}
pub fn drawRangeElementsBaseVertex(_mode: GLenum, _start: GLuint, _end: GLuint, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _basevertex: GLint) void {
return (function_pointers.glDrawRangeElementsBaseVertex orelse @panic("glDrawRangeElementsBaseVertex was not bound."))(_mode, _start, _end, _count, _type, _indices, _basevertex);
}
pub fn drawElementsBaseVertex(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _basevertex: GLint) void {
return (function_pointers.glDrawElementsBaseVertex orelse @panic("glDrawElementsBaseVertex was not bound."))(_mode, _count, _type, _indices, _basevertex);
}
pub fn genQueries(_n: GLsizei, _ids: [*c]GLuint) void {
return (function_pointers.glGenQueries orelse @panic("glGenQueries was not bound."))(_n, _ids);
}
pub fn deleteQueries(_n: GLsizei, _ids: [*c]const GLuint) void {
return (function_pointers.glDeleteQueries orelse @panic("glDeleteQueries was not bound."))(_n, _ids);
}
pub fn isQuery(_id: GLuint) GLboolean {
return (function_pointers.glIsQuery orelse @panic("glIsQuery was not bound."))(_id);
}
pub fn beginQuery(_target: GLenum, _id: GLuint) void {
return (function_pointers.glBeginQuery orelse @panic("glBeginQuery was not bound."))(_target, _id);
}
pub fn endQuery(_target: GLenum) void {
return (function_pointers.glEndQuery orelse @panic("glEndQuery was not bound."))(_target);
}
pub fn getQueryiv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetQueryiv orelse @panic("glGetQueryiv was not bound."))(_target, _pname, _params);
}
pub fn getQueryObjectiv(_id: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetQueryObjectiv orelse @panic("glGetQueryObjectiv was not bound."))(_id, _pname, _params);
}
pub fn getQueryObjectuiv(_id: GLuint, _pname: GLenum, _params: [*c]GLuint) void {
return (function_pointers.glGetQueryObjectuiv orelse @panic("glGetQueryObjectuiv was not bound."))(_id, _pname, _params);
}
pub fn bindBuffer(_target: GLenum, _buffer: GLuint) void {
return (function_pointers.glBindBuffer orelse @panic("glBindBuffer was not bound."))(_target, _buffer);
}
pub fn deleteBuffers(_n: GLsizei, _buffers: [*c]const GLuint) void {
return (function_pointers.glDeleteBuffers orelse @panic("glDeleteBuffers was not bound."))(_n, _buffers);
}
pub fn genBuffers(_n: GLsizei, _buffers: [*c]GLuint) void {
return (function_pointers.glGenBuffers orelse @panic("glGenBuffers was not bound."))(_n, _buffers);
}
pub fn isBuffer(_buffer: GLuint) GLboolean {
return (function_pointers.glIsBuffer orelse @panic("glIsBuffer was not bound."))(_buffer);
}
pub fn bufferData(_target: GLenum, _size: GLsizeiptr, _data: ?*const anyopaque, _usage: GLenum) void {
return (function_pointers.glBufferData orelse @panic("glBufferData was not bound."))(_target, _size, _data, _usage);
}
pub fn bufferSubData(_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: ?*const anyopaque) void {
return (function_pointers.glBufferSubData orelse @panic("glBufferSubData was not bound."))(_target, _offset, _size, _data);
}
pub fn getBufferSubData(_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: ?*anyopaque) void {
return (function_pointers.glGetBufferSubData orelse @panic("glGetBufferSubData was not bound."))(_target, _offset, _size, _data);
}
pub fn mapBuffer(_target: GLenum, _access: GLenum) ?*anyopaque {
return (function_pointers.glMapBuffer orelse @panic("glMapBuffer was not bound."))(_target, _access);
}
pub fn unmapBuffer(_target: GLenum) GLboolean {
return (function_pointers.glUnmapBuffer orelse @panic("glUnmapBuffer was not bound."))(_target);
}
pub fn getBufferParameteriv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetBufferParameteriv orelse @panic("glGetBufferParameteriv was not bound."))(_target, _pname, _params);
}
pub fn getBufferPointerv(_target: GLenum, _pname: GLenum, _params: ?*?*anyopaque) void {
return (function_pointers.glGetBufferPointerv orelse @panic("glGetBufferPointerv was not bound."))(_target, _pname, _params);
}
pub fn blendEquationSeparate(_modeRGB: GLenum, _modeAlpha: GLenum) void {
return (function_pointers.glBlendEquationSeparate orelse @panic("glBlendEquationSeparate was not bound."))(_modeRGB, _modeAlpha);
}
pub fn drawBuffers(_n: GLsizei, _bufs: [*c]const GLenum) void {
return (function_pointers.glDrawBuffers orelse @panic("glDrawBuffers was not bound."))(_n, _bufs);
}
pub fn stencilOpSeparate(_face: GLenum, _sfail: GLenum, _dpfail: GLenum, _dppass: GLenum) void {
return (function_pointers.glStencilOpSeparate orelse @panic("glStencilOpSeparate was not bound."))(_face, _sfail, _dpfail, _dppass);
}
pub fn stencilFuncSeparate(_face: GLenum, _func: GLenum, _ref: GLint, _mask: GLuint) void {
return (function_pointers.glStencilFuncSeparate orelse @panic("glStencilFuncSeparate was not bound."))(_face, _func, _ref, _mask);
}
pub fn stencilMaskSeparate(_face: GLenum, _mask: GLuint) void {
return (function_pointers.glStencilMaskSeparate orelse @panic("glStencilMaskSeparate was not bound."))(_face, _mask);
}
pub fn attachShader(_program: GLuint, _shader: GLuint) void {
return (function_pointers.glAttachShader orelse @panic("glAttachShader was not bound."))(_program, _shader);
}
pub fn bindAttribLocation(_program: GLuint, _index: GLuint, _name: [*c]const GLchar) void {
return (function_pointers.glBindAttribLocation orelse @panic("glBindAttribLocation was not bound."))(_program, _index, _name);
}
pub fn compileShader(_shader: GLuint) void {
return (function_pointers.glCompileShader orelse @panic("glCompileShader was not bound."))(_shader);
}
pub fn createProgram() GLuint {
return (function_pointers.glCreateProgram orelse @panic("glCreateProgram was not bound."))();
}
pub fn createShader(_type: GLenum) GLuint {
return (function_pointers.glCreateShader orelse @panic("glCreateShader was not bound."))(_type);
}
pub fn deleteProgram(_program: GLuint) void {
return (function_pointers.glDeleteProgram orelse @panic("glDeleteProgram was not bound."))(_program);
}
pub fn deleteShader(_shader: GLuint) void {
return (function_pointers.glDeleteShader orelse @panic("glDeleteShader was not bound."))(_shader);
}
pub fn detachShader(_program: GLuint, _shader: GLuint) void {
return (function_pointers.glDetachShader orelse @panic("glDetachShader was not bound."))(_program, _shader);
}
pub fn disableVertexAttribArray(_index: GLuint) void {
return (function_pointers.glDisableVertexAttribArray orelse @panic("glDisableVertexAttribArray was not bound."))(_index);
}
pub fn enableVertexAttribArray(_index: GLuint) void {
return (function_pointers.glEnableVertexAttribArray orelse @panic("glEnableVertexAttribArray was not bound."))(_index);
}
pub fn getActiveAttrib(_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLint, _type: [*c]GLenum, _name: [*c]GLchar) void {
return (function_pointers.glGetActiveAttrib orelse @panic("glGetActiveAttrib was not bound."))(_program, _index, _bufSize, _length, _size, _type, _name);
}
pub fn getActiveUniform(_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLint, _type: [*c]GLenum, _name: [*c]GLchar) void {
return (function_pointers.glGetActiveUniform orelse @panic("glGetActiveUniform was not bound."))(_program, _index, _bufSize, _length, _size, _type, _name);
}
pub fn getAttachedShaders(_program: GLuint, _maxCount: GLsizei, _count: [*c]GLsizei, _shaders: [*c]GLuint) void {
return (function_pointers.glGetAttachedShaders orelse @panic("glGetAttachedShaders was not bound."))(_program, _maxCount, _count, _shaders);
}
pub fn getAttribLocation(_program: GLuint, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetAttribLocation orelse @panic("glGetAttribLocation was not bound."))(_program, _name);
}
pub fn getProgramiv(_program: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetProgramiv orelse @panic("glGetProgramiv was not bound."))(_program, _pname, _params);
}
pub fn getProgramInfoLog(_program: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void {
return (function_pointers.glGetProgramInfoLog orelse @panic("glGetProgramInfoLog was not bound."))(_program, _bufSize, _length, _infoLog);
}
pub fn getShaderiv(_shader: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetShaderiv orelse @panic("glGetShaderiv was not bound."))(_shader, _pname, _params);
}
pub fn getShaderInfoLog(_shader: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void {
return (function_pointers.glGetShaderInfoLog orelse @panic("glGetShaderInfoLog was not bound."))(_shader, _bufSize, _length, _infoLog);
}
pub fn getShaderSource(_shader: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _source: [*c]GLchar) void {
return (function_pointers.glGetShaderSource orelse @panic("glGetShaderSource was not bound."))(_shader, _bufSize, _length, _source);
}
pub fn getUniformLocation(_program: GLuint, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetUniformLocation orelse @panic("glGetUniformLocation was not bound."))(_program, _name);
}
pub fn getUniformfv(_program: GLuint, _location: GLint, _params: [*c]GLfloat) void {
return (function_pointers.glGetUniformfv orelse @panic("glGetUniformfv was not bound."))(_program, _location, _params);
}
pub fn getUniformiv(_program: GLuint, _location: GLint, _params: [*c]GLint) void {
return (function_pointers.glGetUniformiv orelse @panic("glGetUniformiv was not bound."))(_program, _location, _params);
}
pub fn getVertexAttribdv(_index: GLuint, _pname: GLenum, _params: [*c]GLdouble) void {
return (function_pointers.glGetVertexAttribdv orelse @panic("glGetVertexAttribdv was not bound."))(_index, _pname, _params);
}
pub fn getVertexAttribfv(_index: GLuint, _pname: GLenum, _params: [*c]GLfloat) void {
return (function_pointers.glGetVertexAttribfv orelse @panic("glGetVertexAttribfv was not bound."))(_index, _pname, _params);
}
pub fn getVertexAttribiv(_index: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetVertexAttribiv orelse @panic("glGetVertexAttribiv was not bound."))(_index, _pname, _params);
}
pub fn getVertexAttribPointerv(_index: GLuint, _pname: GLenum, _pointer: ?*?*anyopaque) void {
return (function_pointers.glGetVertexAttribPointerv orelse @panic("glGetVertexAttribPointerv was not bound."))(_index, _pname, _pointer);
}
pub fn isProgram(_program: GLuint) GLboolean {
return (function_pointers.glIsProgram orelse @panic("glIsProgram was not bound."))(_program);
}
pub fn isShader(_shader: GLuint) GLboolean {
return (function_pointers.glIsShader orelse @panic("glIsShader was not bound."))(_shader);
}
pub fn linkProgram(_program: GLuint) void {
return (function_pointers.glLinkProgram orelse @panic("glLinkProgram was not bound."))(_program);
}
pub fn shaderSource(_shader: GLuint, _count: GLsizei, _string: [*c]const [*c]const GLchar, _length: [*c]const GLint) void {
return (function_pointers.glShaderSource orelse @panic("glShaderSource was not bound."))(_shader, _count, _string, _length);
}
pub fn useProgram(_program: GLuint) void {
return (function_pointers.glUseProgram orelse @panic("glUseProgram was not bound."))(_program);
}
pub fn uniform1f(_location: GLint, _v0: GLfloat) void {
return (function_pointers.glUniform1f orelse @panic("glUniform1f was not bound."))(_location, _v0);
}
pub fn uniform2f(_location: GLint, _v0: GLfloat, _v1: GLfloat) void {
return (function_pointers.glUniform2f orelse @panic("glUniform2f was not bound."))(_location, _v0, _v1);
}
pub fn uniform3f(_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat) void {
return (function_pointers.glUniform3f orelse @panic("glUniform3f was not bound."))(_location, _v0, _v1, _v2);
}
pub fn uniform4f(_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat, _v3: GLfloat) void {
return (function_pointers.glUniform4f orelse @panic("glUniform4f was not bound."))(_location, _v0, _v1, _v2, _v3);
}
pub fn uniform1i(_location: GLint, _v0: GLint) void {
return (function_pointers.glUniform1i orelse @panic("glUniform1i was not bound."))(_location, _v0);
}
pub fn uniform2i(_location: GLint, _v0: GLint, _v1: GLint) void {
return (function_pointers.glUniform2i orelse @panic("glUniform2i was not bound."))(_location, _v0, _v1);
}
pub fn uniform3i(_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint) void {
return (function_pointers.glUniform3i orelse @panic("glUniform3i was not bound."))(_location, _v0, _v1, _v2);
}
pub fn uniform4i(_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint, _v3: GLint) void {
return (function_pointers.glUniform4i orelse @panic("glUniform4i was not bound."))(_location, _v0, _v1, _v2, _v3);
}
pub fn uniform1fv(_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glUniform1fv orelse @panic("glUniform1fv was not bound."))(_location, _count, _value);
}
pub fn uniform2fv(_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glUniform2fv orelse @panic("glUniform2fv was not bound."))(_location, _count, _value);
}
pub fn uniform3fv(_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glUniform3fv orelse @panic("glUniform3fv was not bound."))(_location, _count, _value);
}
pub fn uniform4fv(_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void {
return (function_pointers.glUniform4fv orelse @panic("glUniform4fv was not bound."))(_location, _count, _value);
}
pub fn uniform1iv(_location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glUniform1iv orelse @panic("glUniform1iv was not bound."))(_location, _count, _value);
}
pub fn uniform2iv(_location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glUniform2iv orelse @panic("glUniform2iv was not bound."))(_location, _count, _value);
}
pub fn uniform3iv(_location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glUniform3iv orelse @panic("glUniform3iv was not bound."))(_location, _count, _value);
}
pub fn uniform4iv(_location: GLint, _count: GLsizei, _value: [*c]const GLint) void {
return (function_pointers.glUniform4iv orelse @panic("glUniform4iv was not bound."))(_location, _count, _value);
}
pub fn uniformMatrix2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix2fv orelse @panic("glUniformMatrix2fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix3fv orelse @panic("glUniformMatrix3fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix4fv orelse @panic("glUniformMatrix4fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn validateProgram(_program: GLuint) void {
return (function_pointers.glValidateProgram orelse @panic("glValidateProgram was not bound."))(_program);
}
pub fn vertexAttrib1d(_index: GLuint, _x: GLdouble) void {
return (function_pointers.glVertexAttrib1d orelse @panic("glVertexAttrib1d was not bound."))(_index, _x);
}
pub fn vertexAttrib1dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttrib1dv orelse @panic("glVertexAttrib1dv was not bound."))(_index, _v);
}
pub fn vertexAttrib1f(_index: GLuint, _x: GLfloat) void {
return (function_pointers.glVertexAttrib1f orelse @panic("glVertexAttrib1f was not bound."))(_index, _x);
}
pub fn vertexAttrib1fv(_index: GLuint, _v: [*c]const GLfloat) void {
return (function_pointers.glVertexAttrib1fv orelse @panic("glVertexAttrib1fv was not bound."))(_index, _v);
}
pub fn vertexAttrib1s(_index: GLuint, _x: GLshort) void {
return (function_pointers.glVertexAttrib1s orelse @panic("glVertexAttrib1s was not bound."))(_index, _x);
}
pub fn vertexAttrib1sv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttrib1sv orelse @panic("glVertexAttrib1sv was not bound."))(_index, _v);
}
pub fn vertexAttrib2d(_index: GLuint, _x: GLdouble, _y: GLdouble) void {
return (function_pointers.glVertexAttrib2d orelse @panic("glVertexAttrib2d was not bound."))(_index, _x, _y);
}
pub fn vertexAttrib2dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttrib2dv orelse @panic("glVertexAttrib2dv was not bound."))(_index, _v);
}
pub fn vertexAttrib2f(_index: GLuint, _x: GLfloat, _y: GLfloat) void {
return (function_pointers.glVertexAttrib2f orelse @panic("glVertexAttrib2f was not bound."))(_index, _x, _y);
}
pub fn vertexAttrib2fv(_index: GLuint, _v: [*c]const GLfloat) void {
return (function_pointers.glVertexAttrib2fv orelse @panic("glVertexAttrib2fv was not bound."))(_index, _v);
}
pub fn vertexAttrib2s(_index: GLuint, _x: GLshort, _y: GLshort) void {
return (function_pointers.glVertexAttrib2s orelse @panic("glVertexAttrib2s was not bound."))(_index, _x, _y);
}
pub fn vertexAttrib2sv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttrib2sv orelse @panic("glVertexAttrib2sv was not bound."))(_index, _v);
}
pub fn vertexAttrib3d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void {
return (function_pointers.glVertexAttrib3d orelse @panic("glVertexAttrib3d was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttrib3dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttrib3dv orelse @panic("glVertexAttrib3dv was not bound."))(_index, _v);
}
pub fn vertexAttrib3f(_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat) void {
return (function_pointers.glVertexAttrib3f orelse @panic("glVertexAttrib3f was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttrib3fv(_index: GLuint, _v: [*c]const GLfloat) void {
return (function_pointers.glVertexAttrib3fv orelse @panic("glVertexAttrib3fv was not bound."))(_index, _v);
}
pub fn vertexAttrib3s(_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort) void {
return (function_pointers.glVertexAttrib3s orelse @panic("glVertexAttrib3s was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttrib3sv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttrib3sv orelse @panic("glVertexAttrib3sv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Nbv(_index: GLuint, _v: [*c]const GLbyte) void {
return (function_pointers.glVertexAttrib4Nbv orelse @panic("glVertexAttrib4Nbv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Niv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttrib4Niv orelse @panic("glVertexAttrib4Niv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Nsv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttrib4Nsv orelse @panic("glVertexAttrib4Nsv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Nub(_index: GLuint, _x: GLubyte, _y: GLubyte, _z: GLubyte, _w: GLubyte) void {
return (function_pointers.glVertexAttrib4Nub orelse @panic("glVertexAttrib4Nub was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttrib4Nubv(_index: GLuint, _v: ?[*:0]const GLubyte) void {
return (function_pointers.glVertexAttrib4Nubv orelse @panic("glVertexAttrib4Nubv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Nuiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttrib4Nuiv orelse @panic("glVertexAttrib4Nuiv was not bound."))(_index, _v);
}
pub fn vertexAttrib4Nusv(_index: GLuint, _v: [*c]const GLushort) void {
return (function_pointers.glVertexAttrib4Nusv orelse @panic("glVertexAttrib4Nusv was not bound."))(_index, _v);
}
pub fn vertexAttrib4bv(_index: GLuint, _v: [*c]const GLbyte) void {
return (function_pointers.glVertexAttrib4bv orelse @panic("glVertexAttrib4bv was not bound."))(_index, _v);
}
pub fn vertexAttrib4d(_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void {
return (function_pointers.glVertexAttrib4d orelse @panic("glVertexAttrib4d was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttrib4dv(_index: GLuint, _v: [*c]const GLdouble) void {
return (function_pointers.glVertexAttrib4dv orelse @panic("glVertexAttrib4dv was not bound."))(_index, _v);
}
pub fn vertexAttrib4f(_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat, _w: GLfloat) void {
return (function_pointers.glVertexAttrib4f orelse @panic("glVertexAttrib4f was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttrib4fv(_index: GLuint, _v: [*c]const GLfloat) void {
return (function_pointers.glVertexAttrib4fv orelse @panic("glVertexAttrib4fv was not bound."))(_index, _v);
}
pub fn vertexAttrib4iv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttrib4iv orelse @panic("glVertexAttrib4iv was not bound."))(_index, _v);
}
pub fn vertexAttrib4s(_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort, _w: GLshort) void {
return (function_pointers.glVertexAttrib4s orelse @panic("glVertexAttrib4s was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttrib4sv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttrib4sv orelse @panic("glVertexAttrib4sv was not bound."))(_index, _v);
}
pub fn vertexAttrib4ubv(_index: GLuint, _v: ?[*:0]const GLubyte) void {
return (function_pointers.glVertexAttrib4ubv orelse @panic("glVertexAttrib4ubv was not bound."))(_index, _v);
}
pub fn vertexAttrib4uiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttrib4uiv orelse @panic("glVertexAttrib4uiv was not bound."))(_index, _v);
}
pub fn vertexAttrib4usv(_index: GLuint, _v: [*c]const GLushort) void {
return (function_pointers.glVertexAttrib4usv orelse @panic("glVertexAttrib4usv was not bound."))(_index, _v);
}
pub fn vertexAttribPointer(_index: GLuint, _size: GLint, _type: GLenum, _normalized: GLboolean, _stride: GLsizei, _pointer: ?*const anyopaque) void {
return (function_pointers.glVertexAttribPointer orelse @panic("glVertexAttribPointer was not bound."))(_index, _size, _type, _normalized, _stride, _pointer);
}
pub fn uniformMatrix2x3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix2x3fv orelse @panic("glUniformMatrix2x3fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3x2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix3x2fv orelse @panic("glUniformMatrix3x2fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix2x4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix2x4fv orelse @panic("glUniformMatrix2x4fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix4x2fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix4x2fv orelse @panic("glUniformMatrix4x2fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix3x4fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix3x4fv orelse @panic("glUniformMatrix3x4fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn uniformMatrix4x3fv(_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void {
return (function_pointers.glUniformMatrix4x3fv orelse @panic("glUniformMatrix4x3fv was not bound."))(_location, _count, _transpose, _value);
}
pub fn colorMaski(_index: GLuint, _r: GLboolean, _g: GLboolean, _b: GLboolean, _a: GLboolean) void {
return (function_pointers.glColorMaski orelse @panic("glColorMaski was not bound."))(_index, _r, _g, _b, _a);
}
pub fn getBooleani_v(_target: GLenum, _index: GLuint, _data: [*c]GLboolean) void {
return (function_pointers.glGetBooleani_v orelse @panic("glGetBooleani_v was not bound."))(_target, _index, _data);
}
pub fn getIntegeri_v(_target: GLenum, _index: GLuint, _data: [*c]GLint) void {
return (function_pointers.glGetIntegeri_v orelse @panic("glGetIntegeri_v was not bound."))(_target, _index, _data);
}
pub fn enablei(_target: GLenum, _index: GLuint) void {
return (function_pointers.glEnablei orelse @panic("glEnablei was not bound."))(_target, _index);
}
pub fn disablei(_target: GLenum, _index: GLuint) void {
return (function_pointers.glDisablei orelse @panic("glDisablei was not bound."))(_target, _index);
}
pub fn isEnabledi(_target: GLenum, _index: GLuint) GLboolean {
return (function_pointers.glIsEnabledi orelse @panic("glIsEnabledi was not bound."))(_target, _index);
}
pub fn beginTransformFeedback(_primitiveMode: GLenum) void {
return (function_pointers.glBeginTransformFeedback orelse @panic("glBeginTransformFeedback was not bound."))(_primitiveMode);
}
pub fn endTransformFeedback() void {
return (function_pointers.glEndTransformFeedback orelse @panic("glEndTransformFeedback was not bound."))();
}
pub fn bindBufferRange(_target: GLenum, _index: GLuint, _buffer: GLuint, _offset: GLintptr, _size: GLsizeiptr) void {
return (function_pointers.glBindBufferRange orelse @panic("glBindBufferRange was not bound."))(_target, _index, _buffer, _offset, _size);
}
pub fn bindBufferBase(_target: GLenum, _index: GLuint, _buffer: GLuint) void {
return (function_pointers.glBindBufferBase orelse @panic("glBindBufferBase was not bound."))(_target, _index, _buffer);
}
pub fn transformFeedbackVaryings(_program: GLuint, _count: GLsizei, _varyings: [*c]const [*c]const GLchar, _bufferMode: GLenum) void {
return (function_pointers.glTransformFeedbackVaryings orelse @panic("glTransformFeedbackVaryings was not bound."))(_program, _count, _varyings, _bufferMode);
}
pub fn getTransformFeedbackVarying(_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLsizei, _type: [*c]GLenum, _name: [*c]GLchar) void {
return (function_pointers.glGetTransformFeedbackVarying orelse @panic("glGetTransformFeedbackVarying was not bound."))(_program, _index, _bufSize, _length, _size, _type, _name);
}
pub fn clampColor(_target: GLenum, _clamp: GLenum) void {
return (function_pointers.glClampColor orelse @panic("glClampColor was not bound."))(_target, _clamp);
}
pub fn beginConditionalRender(_id: GLuint, _mode: GLenum) void {
return (function_pointers.glBeginConditionalRender orelse @panic("glBeginConditionalRender was not bound."))(_id, _mode);
}
pub fn endConditionalRender() void {
return (function_pointers.glEndConditionalRender orelse @panic("glEndConditionalRender was not bound."))();
}
pub fn vertexAttribIPointer(_index: GLuint, _size: GLint, _type: GLenum, _stride: GLsizei, _pointer: ?*const anyopaque) void {
return (function_pointers.glVertexAttribIPointer orelse @panic("glVertexAttribIPointer was not bound."))(_index, _size, _type, _stride, _pointer);
}
pub fn getVertexAttribIiv(_index: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetVertexAttribIiv orelse @panic("glGetVertexAttribIiv was not bound."))(_index, _pname, _params);
}
pub fn getVertexAttribIuiv(_index: GLuint, _pname: GLenum, _params: [*c]GLuint) void {
return (function_pointers.glGetVertexAttribIuiv orelse @panic("glGetVertexAttribIuiv was not bound."))(_index, _pname, _params);
}
pub fn vertexAttribI1i(_index: GLuint, _x: GLint) void {
return (function_pointers.glVertexAttribI1i orelse @panic("glVertexAttribI1i was not bound."))(_index, _x);
}
pub fn vertexAttribI2i(_index: GLuint, _x: GLint, _y: GLint) void {
return (function_pointers.glVertexAttribI2i orelse @panic("glVertexAttribI2i was not bound."))(_index, _x, _y);
}
pub fn vertexAttribI3i(_index: GLuint, _x: GLint, _y: GLint, _z: GLint) void {
return (function_pointers.glVertexAttribI3i orelse @panic("glVertexAttribI3i was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttribI4i(_index: GLuint, _x: GLint, _y: GLint, _z: GLint, _w: GLint) void {
return (function_pointers.glVertexAttribI4i orelse @panic("glVertexAttribI4i was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttribI1ui(_index: GLuint, _x: GLuint) void {
return (function_pointers.glVertexAttribI1ui orelse @panic("glVertexAttribI1ui was not bound."))(_index, _x);
}
pub fn vertexAttribI2ui(_index: GLuint, _x: GLuint, _y: GLuint) void {
return (function_pointers.glVertexAttribI2ui orelse @panic("glVertexAttribI2ui was not bound."))(_index, _x, _y);
}
pub fn vertexAttribI3ui(_index: GLuint, _x: GLuint, _y: GLuint, _z: GLuint) void {
return (function_pointers.glVertexAttribI3ui orelse @panic("glVertexAttribI3ui was not bound."))(_index, _x, _y, _z);
}
pub fn vertexAttribI4ui(_index: GLuint, _x: GLuint, _y: GLuint, _z: GLuint, _w: GLuint) void {
return (function_pointers.glVertexAttribI4ui orelse @panic("glVertexAttribI4ui was not bound."))(_index, _x, _y, _z, _w);
}
pub fn vertexAttribI1iv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttribI1iv orelse @panic("glVertexAttribI1iv was not bound."))(_index, _v);
}
pub fn vertexAttribI2iv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttribI2iv orelse @panic("glVertexAttribI2iv was not bound."))(_index, _v);
}
pub fn vertexAttribI3iv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttribI3iv orelse @panic("glVertexAttribI3iv was not bound."))(_index, _v);
}
pub fn vertexAttribI4iv(_index: GLuint, _v: [*c]const GLint) void {
return (function_pointers.glVertexAttribI4iv orelse @panic("glVertexAttribI4iv was not bound."))(_index, _v);
}
pub fn vertexAttribI1uiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttribI1uiv orelse @panic("glVertexAttribI1uiv was not bound."))(_index, _v);
}
pub fn vertexAttribI2uiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttribI2uiv orelse @panic("glVertexAttribI2uiv was not bound."))(_index, _v);
}
pub fn vertexAttribI3uiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttribI3uiv orelse @panic("glVertexAttribI3uiv was not bound."))(_index, _v);
}
pub fn vertexAttribI4uiv(_index: GLuint, _v: [*c]const GLuint) void {
return (function_pointers.glVertexAttribI4uiv orelse @panic("glVertexAttribI4uiv was not bound."))(_index, _v);
}
pub fn vertexAttribI4bv(_index: GLuint, _v: [*c]const GLbyte) void {
return (function_pointers.glVertexAttribI4bv orelse @panic("glVertexAttribI4bv was not bound."))(_index, _v);
}
pub fn vertexAttribI4sv(_index: GLuint, _v: [*c]const GLshort) void {
return (function_pointers.glVertexAttribI4sv orelse @panic("glVertexAttribI4sv was not bound."))(_index, _v);
}
pub fn vertexAttribI4ubv(_index: GLuint, _v: ?[*:0]const GLubyte) void {
return (function_pointers.glVertexAttribI4ubv orelse @panic("glVertexAttribI4ubv was not bound."))(_index, _v);
}
pub fn vertexAttribI4usv(_index: GLuint, _v: [*c]const GLushort) void {
return (function_pointers.glVertexAttribI4usv orelse @panic("glVertexAttribI4usv was not bound."))(_index, _v);
}
pub fn getUniformuiv(_program: GLuint, _location: GLint, _params: [*c]GLuint) void {
return (function_pointers.glGetUniformuiv orelse @panic("glGetUniformuiv was not bound."))(_program, _location, _params);
}
pub fn bindFragDataLocation(_program: GLuint, _color: GLuint, _name: [*c]const GLchar) void {
return (function_pointers.glBindFragDataLocation orelse @panic("glBindFragDataLocation was not bound."))(_program, _color, _name);
}
pub fn getFragDataLocation(_program: GLuint, _name: [*c]const GLchar) GLint {
return (function_pointers.glGetFragDataLocation orelse @panic("glGetFragDataLocation was not bound."))(_program, _name);
}
pub fn uniform1ui(_location: GLint, _v0: GLuint) void {
return (function_pointers.glUniform1ui orelse @panic("glUniform1ui was not bound."))(_location, _v0);
}
pub fn uniform2ui(_location: GLint, _v0: GLuint, _v1: GLuint) void {
return (function_pointers.glUniform2ui orelse @panic("glUniform2ui was not bound."))(_location, _v0, _v1);
}
pub fn uniform3ui(_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint) void {
return (function_pointers.glUniform3ui orelse @panic("glUniform3ui was not bound."))(_location, _v0, _v1, _v2);
}
pub fn uniform4ui(_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint, _v3: GLuint) void {
return (function_pointers.glUniform4ui orelse @panic("glUniform4ui was not bound."))(_location, _v0, _v1, _v2, _v3);
}
pub fn uniform1uiv(_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glUniform1uiv orelse @panic("glUniform1uiv was not bound."))(_location, _count, _value);
}
pub fn uniform2uiv(_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glUniform2uiv orelse @panic("glUniform2uiv was not bound."))(_location, _count, _value);
}
pub fn uniform3uiv(_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glUniform3uiv orelse @panic("glUniform3uiv was not bound."))(_location, _count, _value);
}
pub fn uniform4uiv(_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void {
return (function_pointers.glUniform4uiv orelse @panic("glUniform4uiv was not bound."))(_location, _count, _value);
}
pub fn texParameterIiv(_target: GLenum, _pname: GLenum, _params: [*c]const GLint) void {
return (function_pointers.glTexParameterIiv orelse @panic("glTexParameterIiv was not bound."))(_target, _pname, _params);
}
pub fn texParameterIuiv(_target: GLenum, _pname: GLenum, _params: [*c]const GLuint) void {
return (function_pointers.glTexParameterIuiv orelse @panic("glTexParameterIuiv was not bound."))(_target, _pname, _params);
}
pub fn getTexParameterIiv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetTexParameterIiv orelse @panic("glGetTexParameterIiv was not bound."))(_target, _pname, _params);
}
pub fn getTexParameterIuiv(_target: GLenum, _pname: GLenum, _params: [*c]GLuint) void {
return (function_pointers.glGetTexParameterIuiv orelse @panic("glGetTexParameterIuiv was not bound."))(_target, _pname, _params);
}
pub fn clearBufferiv(_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLint) void {
return (function_pointers.glClearBufferiv orelse @panic("glClearBufferiv was not bound."))(_buffer, _drawbuffer, _value);
}
pub fn clearBufferuiv(_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLuint) void {
return (function_pointers.glClearBufferuiv orelse @panic("glClearBufferuiv was not bound."))(_buffer, _drawbuffer, _value);
}
pub fn clearBufferfv(_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLfloat) void {
return (function_pointers.glClearBufferfv orelse @panic("glClearBufferfv was not bound."))(_buffer, _drawbuffer, _value);
}
pub fn clearBufferfi(_buffer: GLenum, _drawbuffer: GLint, _depth: GLfloat, _stencil: GLint) void {
return (function_pointers.glClearBufferfi orelse @panic("glClearBufferfi was not bound."))(_buffer, _drawbuffer, _depth, _stencil);
}
pub fn getStringi(_name: GLenum, _index: GLuint) ?[*:0]const GLubyte {
return (function_pointers.glGetStringi orelse @panic("glGetStringi was not bound."))(_name, _index);
}
pub fn isRenderbuffer(_renderbuffer: GLuint) GLboolean {
return (function_pointers.glIsRenderbuffer orelse @panic("glIsRenderbuffer was not bound."))(_renderbuffer);
}
pub fn bindRenderbuffer(_target: GLenum, _renderbuffer: GLuint) void {
return (function_pointers.glBindRenderbuffer orelse @panic("glBindRenderbuffer was not bound."))(_target, _renderbuffer);
}
pub fn deleteRenderbuffers(_n: GLsizei, _renderbuffers: [*c]const GLuint) void {
return (function_pointers.glDeleteRenderbuffers orelse @panic("glDeleteRenderbuffers was not bound."))(_n, _renderbuffers);
}
pub fn genRenderbuffers(_n: GLsizei, _renderbuffers: [*c]GLuint) void {
return (function_pointers.glGenRenderbuffers orelse @panic("glGenRenderbuffers was not bound."))(_n, _renderbuffers);
}
pub fn renderbufferStorage(_target: GLenum, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glRenderbufferStorage orelse @panic("glRenderbufferStorage was not bound."))(_target, _internalformat, _width, _height);
}
pub fn getRenderbufferParameteriv(_target: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetRenderbufferParameteriv orelse @panic("glGetRenderbufferParameteriv was not bound."))(_target, _pname, _params);
}
pub fn isFramebuffer(_framebuffer: GLuint) GLboolean {
return (function_pointers.glIsFramebuffer orelse @panic("glIsFramebuffer was not bound."))(_framebuffer);
}
pub fn bindFramebuffer(_target: GLenum, _framebuffer: GLuint) void {
return (function_pointers.glBindFramebuffer orelse @panic("glBindFramebuffer was not bound."))(_target, _framebuffer);
}
pub fn deleteFramebuffers(_n: GLsizei, _framebuffers: [*c]const GLuint) void {
return (function_pointers.glDeleteFramebuffers orelse @panic("glDeleteFramebuffers was not bound."))(_n, _framebuffers);
}
pub fn genFramebuffers(_n: GLsizei, _framebuffers: [*c]GLuint) void {
return (function_pointers.glGenFramebuffers orelse @panic("glGenFramebuffers was not bound."))(_n, _framebuffers);
}
pub fn checkFramebufferStatus(_target: GLenum) GLenum {
return (function_pointers.glCheckFramebufferStatus orelse @panic("glCheckFramebufferStatus was not bound."))(_target);
}
pub fn framebufferTexture1D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) void {
return (function_pointers.glFramebufferTexture1D orelse @panic("glFramebufferTexture1D was not bound."))(_target, _attachment, _textarget, _texture, _level);
}
pub fn framebufferTexture2D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) void {
return (function_pointers.glFramebufferTexture2D orelse @panic("glFramebufferTexture2D was not bound."))(_target, _attachment, _textarget, _texture, _level);
}
pub fn framebufferTexture3D(_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint, _zoffset: GLint) void {
return (function_pointers.glFramebufferTexture3D orelse @panic("glFramebufferTexture3D was not bound."))(_target, _attachment, _textarget, _texture, _level, _zoffset);
}
pub fn framebufferRenderbuffer(_target: GLenum, _attachment: GLenum, _renderbuffertarget: GLenum, _renderbuffer: GLuint) void {
return (function_pointers.glFramebufferRenderbuffer orelse @panic("glFramebufferRenderbuffer was not bound."))(_target, _attachment, _renderbuffertarget, _renderbuffer);
}
pub fn getFramebufferAttachmentParameteriv(_target: GLenum, _attachment: GLenum, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetFramebufferAttachmentParameteriv orelse @panic("glGetFramebufferAttachmentParameteriv was not bound."))(_target, _attachment, _pname, _params);
}
pub fn generateMipmap(_target: GLenum) void {
return (function_pointers.glGenerateMipmap orelse @panic("glGenerateMipmap was not bound."))(_target);
}
pub fn blitFramebuffer(_srcX0: GLint, _srcY0: GLint, _srcX1: GLint, _srcY1: GLint, _dstX0: GLint, _dstY0: GLint, _dstX1: GLint, _dstY1: GLint, _mask: GLbitfield, _filter: GLenum) void {
return (function_pointers.glBlitFramebuffer orelse @panic("glBlitFramebuffer was not bound."))(_srcX0, _srcY0, _srcX1, _srcY1, _dstX0, _dstY0, _dstX1, _dstY1, _mask, _filter);
}
pub fn renderbufferStorageMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void {
return (function_pointers.glRenderbufferStorageMultisample orelse @panic("glRenderbufferStorageMultisample was not bound."))(_target, _samples, _internalformat, _width, _height);
}
pub fn framebufferTextureLayer(_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint, _layer: GLint) void {
return (function_pointers.glFramebufferTextureLayer orelse @panic("glFramebufferTextureLayer was not bound."))(_target, _attachment, _texture, _level, _layer);
}
pub fn mapBufferRange(_target: GLenum, _offset: GLintptr, _length: GLsizeiptr, _access: GLbitfield) ?*anyopaque {
return (function_pointers.glMapBufferRange orelse @panic("glMapBufferRange was not bound."))(_target, _offset, _length, _access);
}
pub fn flushMappedBufferRange(_target: GLenum, _offset: GLintptr, _length: GLsizeiptr) void {
return (function_pointers.glFlushMappedBufferRange orelse @panic("glFlushMappedBufferRange was not bound."))(_target, _offset, _length);
}
pub fn bindVertexArray(_array: GLuint) void {
return (function_pointers.glBindVertexArray orelse @panic("glBindVertexArray was not bound."))(_array);
}
pub fn deleteVertexArrays(_n: GLsizei, _arrays: [*c]const GLuint) void {
return (function_pointers.glDeleteVertexArrays orelse @panic("glDeleteVertexArrays was not bound."))(_n, _arrays);
}
pub fn genVertexArrays(_n: GLsizei, _arrays: [*c]GLuint) void {
return (function_pointers.glGenVertexArrays orelse @panic("glGenVertexArrays was not bound."))(_n, _arrays);
}
pub fn isVertexArray(_array: GLuint) GLboolean {
return (function_pointers.glIsVertexArray orelse @panic("glIsVertexArray was not bound."))(_array);
}
pub fn drawArraysInstanced(_mode: GLenum, _first: GLint, _count: GLsizei, _instancecount: GLsizei) void {
return (function_pointers.glDrawArraysInstanced orelse @panic("glDrawArraysInstanced was not bound."))(_mode, _first, _count, _instancecount);
}
pub fn drawElementsInstanced(_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei) void {
return (function_pointers.glDrawElementsInstanced orelse @panic("glDrawElementsInstanced was not bound."))(_mode, _count, _type, _indices, _instancecount);
}
pub fn texBuffer(_target: GLenum, _internalformat: GLenum, _buffer: GLuint) void {
return (function_pointers.glTexBuffer orelse @panic("glTexBuffer was not bound."))(_target, _internalformat, _buffer);
}
pub fn primitiveRestartIndex(_index: GLuint) void {
return (function_pointers.glPrimitiveRestartIndex orelse @panic("glPrimitiveRestartIndex was not bound."))(_index);
}
pub fn copyBufferSubData(_readTarget: GLenum, _writeTarget: GLenum, _readOffset: GLintptr, _writeOffset: GLintptr, _size: GLsizeiptr) void {
return (function_pointers.glCopyBufferSubData orelse @panic("glCopyBufferSubData was not bound."))(_readTarget, _writeTarget, _readOffset, _writeOffset, _size);
}
pub fn getUniformIndices(_program: GLuint, _uniformCount: GLsizei, _uniformNames: [*c]const [*c]const GLchar, _uniformIndices: [*c]GLuint) void {
return (function_pointers.glGetUniformIndices orelse @panic("glGetUniformIndices was not bound."))(_program, _uniformCount, _uniformNames, _uniformIndices);
}
pub fn getActiveUniformsiv(_program: GLuint, _uniformCount: GLsizei, _uniformIndices: [*c]const GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetActiveUniformsiv orelse @panic("glGetActiveUniformsiv was not bound."))(_program, _uniformCount, _uniformIndices, _pname, _params);
}
pub fn getActiveUniformName(_program: GLuint, _uniformIndex: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _uniformName: [*c]GLchar) void {
return (function_pointers.glGetActiveUniformName orelse @panic("glGetActiveUniformName was not bound."))(_program, _uniformIndex, _bufSize, _length, _uniformName);
}
pub fn getUniformBlockIndex(_program: GLuint, _uniformBlockName: [*c]const GLchar) GLuint {
return (function_pointers.glGetUniformBlockIndex orelse @panic("glGetUniformBlockIndex was not bound."))(_program, _uniformBlockName);
}
pub fn getActiveUniformBlockiv(_program: GLuint, _uniformBlockIndex: GLuint, _pname: GLenum, _params: [*c]GLint) void {
return (function_pointers.glGetActiveUniformBlockiv orelse @panic("glGetActiveUniformBlockiv was not bound."))(_program, _uniformBlockIndex, _pname, _params);
}
pub fn getActiveUniformBlockName(_program: GLuint, _uniformBlockIndex: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _uniformBlockName: [*c]GLchar) void {
return (function_pointers.glGetActiveUniformBlockName orelse @panic("glGetActiveUniformBlockName was not bound."))(_program, _uniformBlockIndex, _bufSize, _length, _uniformBlockName);
}
pub fn uniformBlockBinding(_program: GLuint, _uniformBlockIndex: GLuint, _uniformBlockBinding: GLuint) void {
return (function_pointers.glUniformBlockBinding orelse @panic("glUniformBlockBinding was not bound."))(_program, _uniformBlockIndex, _uniformBlockBinding);
}
pub fn texStorage3DMultisample(_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _fixedsamplelocations: GLboolean) void {
return (function_pointers.glTexStorage3DMultisample orelse @panic("glTexStorage3DMultisample was not bound."))(_target, _samples, _internalformat, _width, _height, _depth, _fixedsamplelocations);
}
pub fn textureView(_texture: GLuint, _target: GLenum, _origtexture: GLuint, _internalformat: GLenum, _minlevel: GLuint, _numlevels: GLuint, _minlayer: GLuint, _numlayers: GLuint) void {
return (function_pointers.glTextureView orelse @panic("glTextureView was not bound."))(_texture, _target, _origtexture, _internalformat, _minlevel, _numlevels, _minlayer, _numlayers);
}
pub fn bindVertexBuffer(_bindingindex: GLuint, _buffer: GLuint, _offset: GLintptr, _stride: GLsizei) void {
return (function_pointers.glBindVertexBuffer orelse @panic("glBindVertexBuffer was not bound."))(_bindingindex, _buffer, _offset, _stride);
}
pub fn vertexAttribFormat(_attribindex: GLuint, _size: GLint, _type: GLenum, _normalized: GLboolean, _relativeoffset: GLuint) void {
return (function_pointers.glVertexAttribFormat orelse @panic("glVertexAttribFormat was not bound."))(_attribindex, _size, _type, _normalized, _relativeoffset);
}
pub fn vertexAttribIFormat(_attribindex: GLuint, _size: GLint, _type: GLenum, _relativeoffset: GLuint) void {
return (function_pointers.glVertexAttribIFormat orelse @panic("glVertexAttribIFormat was not bound."))(_attribindex, _size, _type, _relativeoffset);
}
pub fn vertexAttribLFormat(_attribindex: GLuint, _size: GLint, _type: GLenum, _relativeoffset: GLuint) void {
return (function_pointers.glVertexAttribLFormat orelse @panic("glVertexAttribLFormat was not bound."))(_attribindex, _size, _type, _relativeoffset);
}
pub fn vertexAttribBinding(_attribindex: GLuint, _bindingindex: GLuint) void {
return (function_pointers.glVertexAttribBinding orelse @panic("glVertexAttribBinding was not bound."))(_attribindex, _bindingindex);
}
pub fn vertexBindingDivisor(_bindingindex: GLuint, _divisor: GLuint) void {
return (function_pointers.glVertexBindingDivisor orelse @panic("glVertexBindingDivisor was not bound."))(_bindingindex, _divisor);
}
pub fn debugMessageControl(_source: GLenum, _type: GLenum, _severity: GLenum, _count: GLsizei, _ids: [*c]const GLuint, _enabled: GLboolean) void {
return (function_pointers.glDebugMessageControl orelse @panic("glDebugMessageControl was not bound."))(_source, _type, _severity, _count, _ids, _enabled);
}
pub fn debugMessageInsert(_source: GLenum, _type: GLenum, _id: GLuint, _severity: GLenum, _length: GLsizei, _buf: [*c]const GLchar) void {
return (function_pointers.glDebugMessageInsert orelse @panic("glDebugMessageInsert was not bound."))(_source, _type, _id, _severity, _length, _buf);
}
pub fn debugMessageCallback(_callback: GLDEBUGPROC, _userParam: ?*const anyopaque) void {
return (function_pointers.glDebugMessageCallback orelse @panic("glDebugMessageCallback was not bound."))(_callback, _userParam);
}
pub fn getDebugMessageLog(_count: GLuint, _bufSize: GLsizei, _sources: [*c]GLenum, _types: [*c]GLenum, _ids: [*c]GLuint, _severities: [*c]GLenum, _lengths: [*c]GLsizei, _messageLog: [*c]GLchar) GLuint {
return (function_pointers.glGetDebugMessageLog orelse @panic("glGetDebugMessageLog was not bound."))(_count, _bufSize, _sources, _types, _ids, _severities, _lengths, _messageLog);
}
pub fn pushDebugGroup(_source: GLenum, _id: GLuint, _length: GLsizei, _message: [*c]const GLchar) void {
return (function_pointers.glPushDebugGroup orelse @panic("glPushDebugGroup was not bound."))(_source, _id, _length, _message);
}
pub fn popDebugGroup() void {
return (function_pointers.glPopDebugGroup orelse @panic("glPopDebugGroup was not bound."))();
}
pub fn objectLabel(_identifier: GLenum, _name: GLuint, _length: GLsizei, _label: [*c]const GLchar) void {
return (function_pointers.glObjectLabel orelse @panic("glObjectLabel was not bound."))(_identifier, _name, _length, _label);
}
pub fn getObjectLabel(_identifier: GLenum, _name: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _label: [*c]GLchar) void {
return (function_pointers.glGetObjectLabel orelse @panic("glGetObjectLabel was not bound."))(_identifier, _name, _bufSize, _length, _label);
}
pub fn objectPtrLabel(_ptr: ?*const anyopaque, _length: GLsizei, _label: [*c]const GLchar) void {
return (function_pointers.glObjectPtrLabel orelse @panic("glObjectPtrLabel was not bound."))(_ptr, _length, _label);
}
pub fn getObjectPtrLabel(_ptr: ?*const anyopaque, _bufSize: GLsizei, _length: [*c]GLsizei, _label: [*c]GLchar) void {
return (function_pointers.glGetObjectPtrLabel orelse @panic("glGetObjectPtrLabel was not bound."))(_ptr, _bufSize, _length, _label);
}
pub fn getPointerv(_pname: GLenum, _params: ?*?*anyopaque) void {
return (function_pointers.glGetPointerv orelse @panic("glGetPointerv was not bound."))(_pname, _params);
}
pub fn bufferStorage(_target: GLenum, _size: GLsizeiptr, _data: ?*const anyopaque, _flags: GLbitfield) void {
return (function_pointers.glBufferStorage orelse @panic("glBufferStorage was not bound."))(_target, _size, _data, _flags);
}
pub fn clearTexImage(_texture: GLuint, _level: GLint, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void {
return (function_pointers.glClearTexImage orelse @panic("glClearTexImage was not bound."))(_texture, _level, _format, _type, _data);
}
pub fn clearTexSubImage(_texture: GLuint, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void {
return (function_pointers.glClearTexSubImage orelse @panic("glClearTexSubImage was not bound."))(_texture, _level, _xoffset, _yoffset, _zoffset, _width, _height, _depth, _format, _type, _data);
}
pub fn bindBuffersBase(_target: GLenum, _first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint) void {
return (function_pointers.glBindBuffersBase orelse @panic("glBindBuffersBase was not bound."))(_target, _first, _count, _buffers);
}
pub fn bindBuffersRange(_target: GLenum, _first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint, _offsets: [*c]const GLintptr, _sizes: [*c]const GLsizeiptr) void {
return (function_pointers.glBindBuffersRange orelse @panic("glBindBuffersRange was not bound."))(_target, _first, _count, _buffers, _offsets, _sizes);
}
pub fn bindTextures(_first: GLuint, _count: GLsizei, _textures: [*c]const GLuint) void {
return (function_pointers.glBindTextures orelse @panic("glBindTextures was not bound."))(_first, _count, _textures);
}
pub fn bindSamplers(_first: GLuint, _count: GLsizei, _samplers: [*c]const GLuint) void {
return (function_pointers.glBindSamplers orelse @panic("glBindSamplers was not bound."))(_first, _count, _samplers);
}
pub fn bindImageTextures(_first: GLuint, _count: GLsizei, _textures: [*c]const GLuint) void {
return (function_pointers.glBindImageTextures orelse @panic("glBindImageTextures was not bound."))(_first, _count, _textures);
}
pub fn bindVertexBuffers(_first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint, _offsets: [*c]const GLintptr, _strides: [*c]const GLsizei) void {
return (function_pointers.glBindVertexBuffers orelse @panic("glBindVertexBuffers was not bound."))(_first, _count, _buffers, _offsets, _strides);
}
// Extensions:
// Loader API:
pub fn load(load_ctx: anytype, get_proc_address: fn (@TypeOf(load_ctx), [:0]const u8) ?*const anyopaque) !void {
var success = true;
if (get_proc_address(load_ctx, "glTexStorage2D")) |proc| {
function_pointers.glTexStorage2D = @ptrCast(?function_signatures.glTexStorage2D, proc);
} else {
log.err("entry point glTexStorage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexStorage1D")) |proc| {
function_pointers.glTexStorage1D = @ptrCast(?function_signatures.glTexStorage1D, proc);
} else {
log.err("entry point glTexStorage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawTransformFeedbackStreamInstanced")) |proc| {
function_pointers.glDrawTransformFeedbackStreamInstanced = @ptrCast(?function_signatures.glDrawTransformFeedbackStreamInstanced, proc);
} else {
log.err("entry point glDrawTransformFeedbackStreamInstanced not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawTransformFeedbackInstanced")) |proc| {
function_pointers.glDrawTransformFeedbackInstanced = @ptrCast(?function_signatures.glDrawTransformFeedbackInstanced, proc);
} else {
log.err("entry point glDrawTransformFeedbackInstanced not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexStorage3D")) |proc| {
function_pointers.glTexStorage3D = @ptrCast(?function_signatures.glTexStorage3D, proc);
} else {
log.err("entry point glTexStorage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMemoryBarrier")) |proc| {
function_pointers.glMemoryBarrier = @ptrCast(?function_signatures.glMemoryBarrier, proc);
} else {
log.err("entry point glMemoryBarrier not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindImageTexture")) |proc| {
function_pointers.glBindImageTexture = @ptrCast(?function_signatures.glBindImageTexture, proc);
} else {
log.err("entry point glBindImageTexture not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveAtomicCounterBufferiv")) |proc| {
function_pointers.glGetActiveAtomicCounterBufferiv = @ptrCast(?function_signatures.glGetActiveAtomicCounterBufferiv, proc);
} else {
log.err("entry point glGetActiveAtomicCounterBufferiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetInternalformativ")) |proc| {
function_pointers.glGetInternalformativ = @ptrCast(?function_signatures.glGetInternalformativ, proc);
} else {
log.err("entry point glGetInternalformativ not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsInstancedBaseVertexBaseInstance")) |proc| {
function_pointers.glDrawElementsInstancedBaseVertexBaseInstance = @ptrCast(?function_signatures.glDrawElementsInstancedBaseVertexBaseInstance, proc);
} else {
log.err("entry point glDrawElementsInstancedBaseVertexBaseInstance not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsInstancedBaseInstance")) |proc| {
function_pointers.glDrawElementsInstancedBaseInstance = @ptrCast(?function_signatures.glDrawElementsInstancedBaseInstance, proc);
} else {
log.err("entry point glDrawElementsInstancedBaseInstance not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawArraysInstancedBaseInstance")) |proc| {
function_pointers.glDrawArraysInstancedBaseInstance = @ptrCast(?function_signatures.glDrawArraysInstancedBaseInstance, proc);
} else {
log.err("entry point glDrawArraysInstancedBaseInstance not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetDoublei_v")) |proc| {
function_pointers.glGetDoublei_v = @ptrCast(?function_signatures.glGetDoublei_v, proc);
} else {
log.err("entry point glGetDoublei_v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFloati_v")) |proc| {
function_pointers.glGetFloati_v = @ptrCast(?function_signatures.glGetFloati_v, proc);
} else {
log.err("entry point glGetFloati_v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthRangeIndexed")) |proc| {
function_pointers.glDepthRangeIndexed = @ptrCast(?function_signatures.glDepthRangeIndexed, proc);
} else {
log.err("entry point glDepthRangeIndexed not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthRangeArrayv")) |proc| {
function_pointers.glDepthRangeArrayv = @ptrCast(?function_signatures.glDepthRangeArrayv, proc);
} else {
log.err("entry point glDepthRangeArrayv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glScissorIndexedv")) |proc| {
function_pointers.glScissorIndexedv = @ptrCast(?function_signatures.glScissorIndexedv, proc);
} else {
log.err("entry point glScissorIndexedv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glScissorIndexed")) |proc| {
function_pointers.glScissorIndexed = @ptrCast(?function_signatures.glScissorIndexed, proc);
} else {
log.err("entry point glScissorIndexed not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glScissorArrayv")) |proc| {
function_pointers.glScissorArrayv = @ptrCast(?function_signatures.glScissorArrayv, proc);
} else {
log.err("entry point glScissorArrayv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glViewportIndexedfv")) |proc| {
function_pointers.glViewportIndexedfv = @ptrCast(?function_signatures.glViewportIndexedfv, proc);
} else {
log.err("entry point glViewportIndexedfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glViewportIndexedf")) |proc| {
function_pointers.glViewportIndexedf = @ptrCast(?function_signatures.glViewportIndexedf, proc);
} else {
log.err("entry point glViewportIndexedf not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glViewportArrayv")) |proc| {
function_pointers.glViewportArrayv = @ptrCast(?function_signatures.glViewportArrayv, proc);
} else {
log.err("entry point glViewportArrayv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribLdv")) |proc| {
function_pointers.glGetVertexAttribLdv = @ptrCast(?function_signatures.glGetVertexAttribLdv, proc);
} else {
log.err("entry point glGetVertexAttribLdv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribLPointer")) |proc| {
function_pointers.glVertexAttribLPointer = @ptrCast(?function_signatures.glVertexAttribLPointer, proc);
} else {
log.err("entry point glVertexAttribLPointer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL4dv")) |proc| {
function_pointers.glVertexAttribL4dv = @ptrCast(?function_signatures.glVertexAttribL4dv, proc);
} else {
log.err("entry point glVertexAttribL4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL3dv")) |proc| {
function_pointers.glVertexAttribL3dv = @ptrCast(?function_signatures.glVertexAttribL3dv, proc);
} else {
log.err("entry point glVertexAttribL3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL2dv")) |proc| {
function_pointers.glVertexAttribL2dv = @ptrCast(?function_signatures.glVertexAttribL2dv, proc);
} else {
log.err("entry point glVertexAttribL2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL1dv")) |proc| {
function_pointers.glVertexAttribL1dv = @ptrCast(?function_signatures.glVertexAttribL1dv, proc);
} else {
log.err("entry point glVertexAttribL1dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL4d")) |proc| {
function_pointers.glVertexAttribL4d = @ptrCast(?function_signatures.glVertexAttribL4d, proc);
} else {
log.err("entry point glVertexAttribL4d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL3d")) |proc| {
function_pointers.glVertexAttribL3d = @ptrCast(?function_signatures.glVertexAttribL3d, proc);
} else {
log.err("entry point glVertexAttribL3d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL2d")) |proc| {
function_pointers.glVertexAttribL2d = @ptrCast(?function_signatures.glVertexAttribL2d, proc);
} else {
log.err("entry point glVertexAttribL2d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribL1d")) |proc| {
function_pointers.glVertexAttribL1d = @ptrCast(?function_signatures.glVertexAttribL1d, proc);
} else {
log.err("entry point glVertexAttribL1d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glValidateProgramPipeline")) |proc| {
function_pointers.glValidateProgramPipeline = @ptrCast(?function_signatures.glValidateProgramPipeline, proc);
} else {
log.err("entry point glValidateProgramPipeline not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4x3dv")) |proc| {
function_pointers.glProgramUniformMatrix4x3dv = @ptrCast(?function_signatures.glProgramUniformMatrix4x3dv, proc);
} else {
log.err("entry point glProgramUniformMatrix4x3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3x4dv")) |proc| {
function_pointers.glProgramUniformMatrix3x4dv = @ptrCast(?function_signatures.glProgramUniformMatrix3x4dv, proc);
} else {
log.err("entry point glProgramUniformMatrix3x4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4x2dv")) |proc| {
function_pointers.glProgramUniformMatrix4x2dv = @ptrCast(?function_signatures.glProgramUniformMatrix4x2dv, proc);
} else {
log.err("entry point glProgramUniformMatrix4x2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2x4dv")) |proc| {
function_pointers.glProgramUniformMatrix2x4dv = @ptrCast(?function_signatures.glProgramUniformMatrix2x4dv, proc);
} else {
log.err("entry point glProgramUniformMatrix2x4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3x2dv")) |proc| {
function_pointers.glProgramUniformMatrix3x2dv = @ptrCast(?function_signatures.glProgramUniformMatrix3x2dv, proc);
} else {
log.err("entry point glProgramUniformMatrix3x2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2x3dv")) |proc| {
function_pointers.glProgramUniformMatrix2x3dv = @ptrCast(?function_signatures.glProgramUniformMatrix2x3dv, proc);
} else {
log.err("entry point glProgramUniformMatrix2x3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4x3fv")) |proc| {
function_pointers.glProgramUniformMatrix4x3fv = @ptrCast(?function_signatures.glProgramUniformMatrix4x3fv, proc);
} else {
log.err("entry point glProgramUniformMatrix4x3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3x4fv")) |proc| {
function_pointers.glProgramUniformMatrix3x4fv = @ptrCast(?function_signatures.glProgramUniformMatrix3x4fv, proc);
} else {
log.err("entry point glProgramUniformMatrix3x4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4x2fv")) |proc| {
function_pointers.glProgramUniformMatrix4x2fv = @ptrCast(?function_signatures.glProgramUniformMatrix4x2fv, proc);
} else {
log.err("entry point glProgramUniformMatrix4x2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2x4fv")) |proc| {
function_pointers.glProgramUniformMatrix2x4fv = @ptrCast(?function_signatures.glProgramUniformMatrix2x4fv, proc);
} else {
log.err("entry point glProgramUniformMatrix2x4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3x2fv")) |proc| {
function_pointers.glProgramUniformMatrix3x2fv = @ptrCast(?function_signatures.glProgramUniformMatrix3x2fv, proc);
} else {
log.err("entry point glProgramUniformMatrix3x2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2x3fv")) |proc| {
function_pointers.glProgramUniformMatrix2x3fv = @ptrCast(?function_signatures.glProgramUniformMatrix2x3fv, proc);
} else {
log.err("entry point glProgramUniformMatrix2x3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4dv")) |proc| {
function_pointers.glProgramUniformMatrix4dv = @ptrCast(?function_signatures.glProgramUniformMatrix4dv, proc);
} else {
log.err("entry point glProgramUniformMatrix4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3dv")) |proc| {
function_pointers.glProgramUniformMatrix3dv = @ptrCast(?function_signatures.glProgramUniformMatrix3dv, proc);
} else {
log.err("entry point glProgramUniformMatrix3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2dv")) |proc| {
function_pointers.glProgramUniformMatrix2dv = @ptrCast(?function_signatures.glProgramUniformMatrix2dv, proc);
} else {
log.err("entry point glProgramUniformMatrix2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix4fv")) |proc| {
function_pointers.glProgramUniformMatrix4fv = @ptrCast(?function_signatures.glProgramUniformMatrix4fv, proc);
} else {
log.err("entry point glProgramUniformMatrix4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix3fv")) |proc| {
function_pointers.glProgramUniformMatrix3fv = @ptrCast(?function_signatures.glProgramUniformMatrix3fv, proc);
} else {
log.err("entry point glProgramUniformMatrix3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniformMatrix2fv")) |proc| {
function_pointers.glProgramUniformMatrix2fv = @ptrCast(?function_signatures.glProgramUniformMatrix2fv, proc);
} else {
log.err("entry point glProgramUniformMatrix2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4uiv")) |proc| {
function_pointers.glProgramUniform4uiv = @ptrCast(?function_signatures.glProgramUniform4uiv, proc);
} else {
log.err("entry point glProgramUniform4uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4ui")) |proc| {
function_pointers.glProgramUniform4ui = @ptrCast(?function_signatures.glProgramUniform4ui, proc);
} else {
log.err("entry point glProgramUniform4ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4dv")) |proc| {
function_pointers.glProgramUniform4dv = @ptrCast(?function_signatures.glProgramUniform4dv, proc);
} else {
log.err("entry point glProgramUniform4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4d")) |proc| {
function_pointers.glProgramUniform4d = @ptrCast(?function_signatures.glProgramUniform4d, proc);
} else {
log.err("entry point glProgramUniform4d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4fv")) |proc| {
function_pointers.glProgramUniform4fv = @ptrCast(?function_signatures.glProgramUniform4fv, proc);
} else {
log.err("entry point glProgramUniform4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4f")) |proc| {
function_pointers.glProgramUniform4f = @ptrCast(?function_signatures.glProgramUniform4f, proc);
} else {
log.err("entry point glProgramUniform4f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4iv")) |proc| {
function_pointers.glProgramUniform4iv = @ptrCast(?function_signatures.glProgramUniform4iv, proc);
} else {
log.err("entry point glProgramUniform4iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform4i")) |proc| {
function_pointers.glProgramUniform4i = @ptrCast(?function_signatures.glProgramUniform4i, proc);
} else {
log.err("entry point glProgramUniform4i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3uiv")) |proc| {
function_pointers.glProgramUniform3uiv = @ptrCast(?function_signatures.glProgramUniform3uiv, proc);
} else {
log.err("entry point glProgramUniform3uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3ui")) |proc| {
function_pointers.glProgramUniform3ui = @ptrCast(?function_signatures.glProgramUniform3ui, proc);
} else {
log.err("entry point glProgramUniform3ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3dv")) |proc| {
function_pointers.glProgramUniform3dv = @ptrCast(?function_signatures.glProgramUniform3dv, proc);
} else {
log.err("entry point glProgramUniform3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3d")) |proc| {
function_pointers.glProgramUniform3d = @ptrCast(?function_signatures.glProgramUniform3d, proc);
} else {
log.err("entry point glProgramUniform3d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3fv")) |proc| {
function_pointers.glProgramUniform3fv = @ptrCast(?function_signatures.glProgramUniform3fv, proc);
} else {
log.err("entry point glProgramUniform3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3f")) |proc| {
function_pointers.glProgramUniform3f = @ptrCast(?function_signatures.glProgramUniform3f, proc);
} else {
log.err("entry point glProgramUniform3f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3iv")) |proc| {
function_pointers.glProgramUniform3iv = @ptrCast(?function_signatures.glProgramUniform3iv, proc);
} else {
log.err("entry point glProgramUniform3iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform3i")) |proc| {
function_pointers.glProgramUniform3i = @ptrCast(?function_signatures.glProgramUniform3i, proc);
} else {
log.err("entry point glProgramUniform3i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUseProgramStages")) |proc| {
function_pointers.glUseProgramStages = @ptrCast(?function_signatures.glUseProgramStages, proc);
} else {
log.err("entry point glUseProgramStages not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramParameteri")) |proc| {
function_pointers.glProgramParameteri = @ptrCast(?function_signatures.glProgramParameteri, proc);
} else {
log.err("entry point glProgramParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetShaderPrecisionFormat")) |proc| {
function_pointers.glGetShaderPrecisionFormat = @ptrCast(?function_signatures.glGetShaderPrecisionFormat, proc);
} else {
log.err("entry point glGetShaderPrecisionFormat not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glShaderBinary")) |proc| {
function_pointers.glShaderBinary = @ptrCast(?function_signatures.glShaderBinary, proc);
} else {
log.err("entry point glShaderBinary not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glReleaseShaderCompiler")) |proc| {
function_pointers.glReleaseShaderCompiler = @ptrCast(?function_signatures.glReleaseShaderCompiler, proc);
} else {
log.err("entry point glReleaseShaderCompiler not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryIndexediv")) |proc| {
function_pointers.glGetQueryIndexediv = @ptrCast(?function_signatures.glGetQueryIndexediv, proc);
} else {
log.err("entry point glGetQueryIndexediv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEndQueryIndexed")) |proc| {
function_pointers.glEndQueryIndexed = @ptrCast(?function_signatures.glEndQueryIndexed, proc);
} else {
log.err("entry point glEndQueryIndexed not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBeginQueryIndexed")) |proc| {
function_pointers.glBeginQueryIndexed = @ptrCast(?function_signatures.glBeginQueryIndexed, proc);
} else {
log.err("entry point glBeginQueryIndexed not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawTransformFeedbackStream")) |proc| {
function_pointers.glDrawTransformFeedbackStream = @ptrCast(?function_signatures.glDrawTransformFeedbackStream, proc);
} else {
log.err("entry point glDrawTransformFeedbackStream not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawTransformFeedback")) |proc| {
function_pointers.glDrawTransformFeedback = @ptrCast(?function_signatures.glDrawTransformFeedback, proc);
} else {
log.err("entry point glDrawTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glResumeTransformFeedback")) |proc| {
function_pointers.glResumeTransformFeedback = @ptrCast(?function_signatures.glResumeTransformFeedback, proc);
} else {
log.err("entry point glResumeTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPauseTransformFeedback")) |proc| {
function_pointers.glPauseTransformFeedback = @ptrCast(?function_signatures.glPauseTransformFeedback, proc);
} else {
log.err("entry point glPauseTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramStageiv")) |proc| {
function_pointers.glGetProgramStageiv = @ptrCast(?function_signatures.glGetProgramStageiv, proc);
} else {
log.err("entry point glGetProgramStageiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformSubroutineuiv")) |proc| {
function_pointers.glGetUniformSubroutineuiv = @ptrCast(?function_signatures.glGetUniformSubroutineuiv, proc);
} else {
log.err("entry point glGetUniformSubroutineuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformSubroutinesuiv")) |proc| {
function_pointers.glUniformSubroutinesuiv = @ptrCast(?function_signatures.glUniformSubroutinesuiv, proc);
} else {
log.err("entry point glUniformSubroutinesuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveSubroutineName")) |proc| {
function_pointers.glGetActiveSubroutineName = @ptrCast(?function_signatures.glGetActiveSubroutineName, proc);
} else {
log.err("entry point glGetActiveSubroutineName not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCullFace")) |proc| {
function_pointers.glCullFace = @ptrCast(?function_signatures.glCullFace, proc);
} else {
log.err("entry point glCullFace not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFrontFace")) |proc| {
function_pointers.glFrontFace = @ptrCast(?function_signatures.glFrontFace, proc);
} else {
log.err("entry point glFrontFace not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glHint")) |proc| {
function_pointers.glHint = @ptrCast(?function_signatures.glHint, proc);
} else {
log.err("entry point glHint not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glLineWidth")) |proc| {
function_pointers.glLineWidth = @ptrCast(?function_signatures.glLineWidth, proc);
} else {
log.err("entry point glLineWidth not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPointSize")) |proc| {
function_pointers.glPointSize = @ptrCast(?function_signatures.glPointSize, proc);
} else {
log.err("entry point glPointSize not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPolygonMode")) |proc| {
function_pointers.glPolygonMode = @ptrCast(?function_signatures.glPolygonMode, proc);
} else {
log.err("entry point glPolygonMode not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glScissor")) |proc| {
function_pointers.glScissor = @ptrCast(?function_signatures.glScissor, proc);
} else {
log.err("entry point glScissor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameterf")) |proc| {
function_pointers.glTexParameterf = @ptrCast(?function_signatures.glTexParameterf, proc);
} else {
log.err("entry point glTexParameterf not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameterfv")) |proc| {
function_pointers.glTexParameterfv = @ptrCast(?function_signatures.glTexParameterfv, proc);
} else {
log.err("entry point glTexParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameteri")) |proc| {
function_pointers.glTexParameteri = @ptrCast(?function_signatures.glTexParameteri, proc);
} else {
log.err("entry point glTexParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameteriv")) |proc| {
function_pointers.glTexParameteriv = @ptrCast(?function_signatures.glTexParameteriv, proc);
} else {
log.err("entry point glTexParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexImage1D")) |proc| {
function_pointers.glTexImage1D = @ptrCast(?function_signatures.glTexImage1D, proc);
} else {
log.err("entry point glTexImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexImage2D")) |proc| {
function_pointers.glTexImage2D = @ptrCast(?function_signatures.glTexImage2D, proc);
} else {
log.err("entry point glTexImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawBuffer")) |proc| {
function_pointers.glDrawBuffer = @ptrCast(?function_signatures.glDrawBuffer, proc);
} else {
log.err("entry point glDrawBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClear")) |proc| {
function_pointers.glClear = @ptrCast(?function_signatures.glClear, proc);
} else {
log.err("entry point glClear not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearColor")) |proc| {
function_pointers.glClearColor = @ptrCast(?function_signatures.glClearColor, proc);
} else {
log.err("entry point glClearColor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearStencil")) |proc| {
function_pointers.glClearStencil = @ptrCast(?function_signatures.glClearStencil, proc);
} else {
log.err("entry point glClearStencil not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearDepth")) |proc| {
function_pointers.glClearDepth = @ptrCast(?function_signatures.glClearDepth, proc);
} else {
log.err("entry point glClearDepth not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilMask")) |proc| {
function_pointers.glStencilMask = @ptrCast(?function_signatures.glStencilMask, proc);
} else {
log.err("entry point glStencilMask not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glColorMask")) |proc| {
function_pointers.glColorMask = @ptrCast(?function_signatures.glColorMask, proc);
} else {
log.err("entry point glColorMask not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthMask")) |proc| {
function_pointers.glDepthMask = @ptrCast(?function_signatures.glDepthMask, proc);
} else {
log.err("entry point glDepthMask not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDisable")) |proc| {
function_pointers.glDisable = @ptrCast(?function_signatures.glDisable, proc);
} else {
log.err("entry point glDisable not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEnable")) |proc| {
function_pointers.glEnable = @ptrCast(?function_signatures.glEnable, proc);
} else {
log.err("entry point glEnable not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFinish")) |proc| {
function_pointers.glFinish = @ptrCast(?function_signatures.glFinish, proc);
} else {
log.err("entry point glFinish not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFlush")) |proc| {
function_pointers.glFlush = @ptrCast(?function_signatures.glFlush, proc);
} else {
log.err("entry point glFlush not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendFunc")) |proc| {
function_pointers.glBlendFunc = @ptrCast(?function_signatures.glBlendFunc, proc);
} else {
log.err("entry point glBlendFunc not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glLogicOp")) |proc| {
function_pointers.glLogicOp = @ptrCast(?function_signatures.glLogicOp, proc);
} else {
log.err("entry point glLogicOp not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilFunc")) |proc| {
function_pointers.glStencilFunc = @ptrCast(?function_signatures.glStencilFunc, proc);
} else {
log.err("entry point glStencilFunc not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilOp")) |proc| {
function_pointers.glStencilOp = @ptrCast(?function_signatures.glStencilOp, proc);
} else {
log.err("entry point glStencilOp not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthFunc")) |proc| {
function_pointers.glDepthFunc = @ptrCast(?function_signatures.glDepthFunc, proc);
} else {
log.err("entry point glDepthFunc not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPixelStoref")) |proc| {
function_pointers.glPixelStoref = @ptrCast(?function_signatures.glPixelStoref, proc);
} else {
log.err("entry point glPixelStoref not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPixelStorei")) |proc| {
function_pointers.glPixelStorei = @ptrCast(?function_signatures.glPixelStorei, proc);
} else {
log.err("entry point glPixelStorei not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glReadBuffer")) |proc| {
function_pointers.glReadBuffer = @ptrCast(?function_signatures.glReadBuffer, proc);
} else {
log.err("entry point glReadBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glReadPixels")) |proc| {
function_pointers.glReadPixels = @ptrCast(?function_signatures.glReadPixels, proc);
} else {
log.err("entry point glReadPixels not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBooleanv")) |proc| {
function_pointers.glGetBooleanv = @ptrCast(?function_signatures.glGetBooleanv, proc);
} else {
log.err("entry point glGetBooleanv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetDoublev")) |proc| {
function_pointers.glGetDoublev = @ptrCast(?function_signatures.glGetDoublev, proc);
} else {
log.err("entry point glGetDoublev not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetError")) |proc| {
function_pointers.glGetError = @ptrCast(?function_signatures.glGetError, proc);
} else {
log.err("entry point glGetError not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFloatv")) |proc| {
function_pointers.glGetFloatv = @ptrCast(?function_signatures.glGetFloatv, proc);
} else {
log.err("entry point glGetFloatv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetIntegerv")) |proc| {
function_pointers.glGetIntegerv = @ptrCast(?function_signatures.glGetIntegerv, proc);
} else {
log.err("entry point glGetIntegerv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetString")) |proc| {
function_pointers.glGetString = @ptrCast(?function_signatures.glGetString, proc);
} else {
log.err("entry point glGetString not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexImage")) |proc| {
function_pointers.glGetTexImage = @ptrCast(?function_signatures.glGetTexImage, proc);
} else {
log.err("entry point glGetTexImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexParameterfv")) |proc| {
function_pointers.glGetTexParameterfv = @ptrCast(?function_signatures.glGetTexParameterfv, proc);
} else {
log.err("entry point glGetTexParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexParameteriv")) |proc| {
function_pointers.glGetTexParameteriv = @ptrCast(?function_signatures.glGetTexParameteriv, proc);
} else {
log.err("entry point glGetTexParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexLevelParameterfv")) |proc| {
function_pointers.glGetTexLevelParameterfv = @ptrCast(?function_signatures.glGetTexLevelParameterfv, proc);
} else {
log.err("entry point glGetTexLevelParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexLevelParameteriv")) |proc| {
function_pointers.glGetTexLevelParameteriv = @ptrCast(?function_signatures.glGetTexLevelParameteriv, proc);
} else {
log.err("entry point glGetTexLevelParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsEnabled")) |proc| {
function_pointers.glIsEnabled = @ptrCast(?function_signatures.glIsEnabled, proc);
} else {
log.err("entry point glIsEnabled not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthRange")) |proc| {
function_pointers.glDepthRange = @ptrCast(?function_signatures.glDepthRange, proc);
} else {
log.err("entry point glDepthRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glViewport")) |proc| {
function_pointers.glViewport = @ptrCast(?function_signatures.glViewport, proc);
} else {
log.err("entry point glViewport not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexStorage2DMultisample")) |proc| {
function_pointers.glTexStorage2DMultisample = @ptrCast(?function_signatures.glTexStorage2DMultisample, proc);
} else {
log.err("entry point glTexStorage2DMultisample not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexBufferRange")) |proc| {
function_pointers.glTexBufferRange = @ptrCast(?function_signatures.glTexBufferRange, proc);
} else {
log.err("entry point glTexBufferRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glShaderStorageBlockBinding")) |proc| {
function_pointers.glShaderStorageBlockBinding = @ptrCast(?function_signatures.glShaderStorageBlockBinding, proc);
} else {
log.err("entry point glShaderStorageBlockBinding not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramResourceLocationIndex")) |proc| {
function_pointers.glGetProgramResourceLocationIndex = @ptrCast(?function_signatures.glGetProgramResourceLocationIndex, proc);
} else {
log.err("entry point glGetProgramResourceLocationIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramResourceLocation")) |proc| {
function_pointers.glGetProgramResourceLocation = @ptrCast(?function_signatures.glGetProgramResourceLocation, proc);
} else {
log.err("entry point glGetProgramResourceLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramResourceiv")) |proc| {
function_pointers.glGetProgramResourceiv = @ptrCast(?function_signatures.glGetProgramResourceiv, proc);
} else {
log.err("entry point glGetProgramResourceiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramResourceName")) |proc| {
function_pointers.glGetProgramResourceName = @ptrCast(?function_signatures.glGetProgramResourceName, proc);
} else {
log.err("entry point glGetProgramResourceName not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramResourceIndex")) |proc| {
function_pointers.glGetProgramResourceIndex = @ptrCast(?function_signatures.glGetProgramResourceIndex, proc);
} else {
log.err("entry point glGetProgramResourceIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramInterfaceiv")) |proc| {
function_pointers.glGetProgramInterfaceiv = @ptrCast(?function_signatures.glGetProgramInterfaceiv, proc);
} else {
log.err("entry point glGetProgramInterfaceiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMultiDrawElementsIndirect")) |proc| {
function_pointers.glMultiDrawElementsIndirect = @ptrCast(?function_signatures.glMultiDrawElementsIndirect, proc);
} else {
log.err("entry point glMultiDrawElementsIndirect not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMultiDrawArraysIndirect")) |proc| {
function_pointers.glMultiDrawArraysIndirect = @ptrCast(?function_signatures.glMultiDrawArraysIndirect, proc);
} else {
log.err("entry point glMultiDrawArraysIndirect not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateSubFramebuffer")) |proc| {
function_pointers.glInvalidateSubFramebuffer = @ptrCast(?function_signatures.glInvalidateSubFramebuffer, proc);
} else {
log.err("entry point glInvalidateSubFramebuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateFramebuffer")) |proc| {
function_pointers.glInvalidateFramebuffer = @ptrCast(?function_signatures.glInvalidateFramebuffer, proc);
} else {
log.err("entry point glInvalidateFramebuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateBufferData")) |proc| {
function_pointers.glInvalidateBufferData = @ptrCast(?function_signatures.glInvalidateBufferData, proc);
} else {
log.err("entry point glInvalidateBufferData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateBufferSubData")) |proc| {
function_pointers.glInvalidateBufferSubData = @ptrCast(?function_signatures.glInvalidateBufferSubData, proc);
} else {
log.err("entry point glInvalidateBufferSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateTexImage")) |proc| {
function_pointers.glInvalidateTexImage = @ptrCast(?function_signatures.glInvalidateTexImage, proc);
} else {
log.err("entry point glInvalidateTexImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glInvalidateTexSubImage")) |proc| {
function_pointers.glInvalidateTexSubImage = @ptrCast(?function_signatures.glInvalidateTexSubImage, proc);
} else {
log.err("entry point glInvalidateTexSubImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetInternalformati64v")) |proc| {
function_pointers.glGetInternalformati64v = @ptrCast(?function_signatures.glGetInternalformati64v, proc);
} else {
log.err("entry point glGetInternalformati64v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFramebufferParameteriv")) |proc| {
function_pointers.glGetFramebufferParameteriv = @ptrCast(?function_signatures.glGetFramebufferParameteriv, proc);
} else {
log.err("entry point glGetFramebufferParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferParameteri")) |proc| {
function_pointers.glFramebufferParameteri = @ptrCast(?function_signatures.glFramebufferParameteri, proc);
} else {
log.err("entry point glFramebufferParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyImageSubData")) |proc| {
function_pointers.glCopyImageSubData = @ptrCast(?function_signatures.glCopyImageSubData, proc);
} else {
log.err("entry point glCopyImageSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDispatchComputeIndirect")) |proc| {
function_pointers.glDispatchComputeIndirect = @ptrCast(?function_signatures.glDispatchComputeIndirect, proc);
} else {
log.err("entry point glDispatchComputeIndirect not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDispatchCompute")) |proc| {
function_pointers.glDispatchCompute = @ptrCast(?function_signatures.glDispatchCompute, proc);
} else {
log.err("entry point glDispatchCompute not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferSubData")) |proc| {
function_pointers.glClearBufferSubData = @ptrCast(?function_signatures.glClearBufferSubData, proc);
} else {
log.err("entry point glClearBufferSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferData")) |proc| {
function_pointers.glClearBufferData = @ptrCast(?function_signatures.glClearBufferData, proc);
} else {
log.err("entry point glClearBufferData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramPipelineInfoLog")) |proc| {
function_pointers.glGetProgramPipelineInfoLog = @ptrCast(?function_signatures.glGetProgramPipelineInfoLog, proc);
} else {
log.err("entry point glGetProgramPipelineInfoLog not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2uiv")) |proc| {
function_pointers.glProgramUniform2uiv = @ptrCast(?function_signatures.glProgramUniform2uiv, proc);
} else {
log.err("entry point glProgramUniform2uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2ui")) |proc| {
function_pointers.glProgramUniform2ui = @ptrCast(?function_signatures.glProgramUniform2ui, proc);
} else {
log.err("entry point glProgramUniform2ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2dv")) |proc| {
function_pointers.glProgramUniform2dv = @ptrCast(?function_signatures.glProgramUniform2dv, proc);
} else {
log.err("entry point glProgramUniform2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2d")) |proc| {
function_pointers.glProgramUniform2d = @ptrCast(?function_signatures.glProgramUniform2d, proc);
} else {
log.err("entry point glProgramUniform2d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2fv")) |proc| {
function_pointers.glProgramUniform2fv = @ptrCast(?function_signatures.glProgramUniform2fv, proc);
} else {
log.err("entry point glProgramUniform2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2f")) |proc| {
function_pointers.glProgramUniform2f = @ptrCast(?function_signatures.glProgramUniform2f, proc);
} else {
log.err("entry point glProgramUniform2f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2iv")) |proc| {
function_pointers.glProgramUniform2iv = @ptrCast(?function_signatures.glProgramUniform2iv, proc);
} else {
log.err("entry point glProgramUniform2iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform2i")) |proc| {
function_pointers.glProgramUniform2i = @ptrCast(?function_signatures.glProgramUniform2i, proc);
} else {
log.err("entry point glProgramUniform2i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1uiv")) |proc| {
function_pointers.glProgramUniform1uiv = @ptrCast(?function_signatures.glProgramUniform1uiv, proc);
} else {
log.err("entry point glProgramUniform1uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1ui")) |proc| {
function_pointers.glProgramUniform1ui = @ptrCast(?function_signatures.glProgramUniform1ui, proc);
} else {
log.err("entry point glProgramUniform1ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1dv")) |proc| {
function_pointers.glProgramUniform1dv = @ptrCast(?function_signatures.glProgramUniform1dv, proc);
} else {
log.err("entry point glProgramUniform1dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1d")) |proc| {
function_pointers.glProgramUniform1d = @ptrCast(?function_signatures.glProgramUniform1d, proc);
} else {
log.err("entry point glProgramUniform1d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1fv")) |proc| {
function_pointers.glProgramUniform1fv = @ptrCast(?function_signatures.glProgramUniform1fv, proc);
} else {
log.err("entry point glProgramUniform1fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1f")) |proc| {
function_pointers.glProgramUniform1f = @ptrCast(?function_signatures.glProgramUniform1f, proc);
} else {
log.err("entry point glProgramUniform1f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1iv")) |proc| {
function_pointers.glProgramUniform1iv = @ptrCast(?function_signatures.glProgramUniform1iv, proc);
} else {
log.err("entry point glProgramUniform1iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramUniform1i")) |proc| {
function_pointers.glProgramUniform1i = @ptrCast(?function_signatures.glProgramUniform1i, proc);
} else {
log.err("entry point glProgramUniform1i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramPipelineiv")) |proc| {
function_pointers.glGetProgramPipelineiv = @ptrCast(?function_signatures.glGetProgramPipelineiv, proc);
} else {
log.err("entry point glGetProgramPipelineiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsProgramPipeline")) |proc| {
function_pointers.glIsProgramPipeline = @ptrCast(?function_signatures.glIsProgramPipeline, proc);
} else {
log.err("entry point glIsProgramPipeline not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenProgramPipelines")) |proc| {
function_pointers.glGenProgramPipelines = @ptrCast(?function_signatures.glGenProgramPipelines, proc);
} else {
log.err("entry point glGenProgramPipelines not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteProgramPipelines")) |proc| {
function_pointers.glDeleteProgramPipelines = @ptrCast(?function_signatures.glDeleteProgramPipelines, proc);
} else {
log.err("entry point glDeleteProgramPipelines not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindProgramPipeline")) |proc| {
function_pointers.glBindProgramPipeline = @ptrCast(?function_signatures.glBindProgramPipeline, proc);
} else {
log.err("entry point glBindProgramPipeline not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCreateShaderProgramv")) |proc| {
function_pointers.glCreateShaderProgramv = @ptrCast(?function_signatures.glCreateShaderProgramv, proc);
} else {
log.err("entry point glCreateShaderProgramv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glActiveShaderProgram")) |proc| {
function_pointers.glActiveShaderProgram = @ptrCast(?function_signatures.glActiveShaderProgram, proc);
} else {
log.err("entry point glActiveShaderProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProgramBinary")) |proc| {
function_pointers.glProgramBinary = @ptrCast(?function_signatures.glProgramBinary, proc);
} else {
log.err("entry point glProgramBinary not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramBinary")) |proc| {
function_pointers.glGetProgramBinary = @ptrCast(?function_signatures.glGetProgramBinary, proc);
} else {
log.err("entry point glGetProgramBinary not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearDepthf")) |proc| {
function_pointers.glClearDepthf = @ptrCast(?function_signatures.glClearDepthf, proc);
} else {
log.err("entry point glClearDepthf not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDepthRangef")) |proc| {
function_pointers.glDepthRangef = @ptrCast(?function_signatures.glDepthRangef, proc);
} else {
log.err("entry point glDepthRangef not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsTransformFeedback")) |proc| {
function_pointers.glIsTransformFeedback = @ptrCast(?function_signatures.glIsTransformFeedback, proc);
} else {
log.err("entry point glIsTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenTransformFeedbacks")) |proc| {
function_pointers.glGenTransformFeedbacks = @ptrCast(?function_signatures.glGenTransformFeedbacks, proc);
} else {
log.err("entry point glGenTransformFeedbacks not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteTransformFeedbacks")) |proc| {
function_pointers.glDeleteTransformFeedbacks = @ptrCast(?function_signatures.glDeleteTransformFeedbacks, proc);
} else {
log.err("entry point glDeleteTransformFeedbacks not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindTransformFeedback")) |proc| {
function_pointers.glBindTransformFeedback = @ptrCast(?function_signatures.glBindTransformFeedback, proc);
} else {
log.err("entry point glBindTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPatchParameterfv")) |proc| {
function_pointers.glPatchParameterfv = @ptrCast(?function_signatures.glPatchParameterfv, proc);
} else {
log.err("entry point glPatchParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPatchParameteri")) |proc| {
function_pointers.glPatchParameteri = @ptrCast(?function_signatures.glPatchParameteri, proc);
} else {
log.err("entry point glPatchParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawArrays")) |proc| {
function_pointers.glDrawArrays = @ptrCast(?function_signatures.glDrawArrays, proc);
} else {
log.err("entry point glDrawArrays not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElements")) |proc| {
function_pointers.glDrawElements = @ptrCast(?function_signatures.glDrawElements, proc);
} else {
log.err("entry point glDrawElements not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPolygonOffset")) |proc| {
function_pointers.glPolygonOffset = @ptrCast(?function_signatures.glPolygonOffset, proc);
} else {
log.err("entry point glPolygonOffset not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyTexImage1D")) |proc| {
function_pointers.glCopyTexImage1D = @ptrCast(?function_signatures.glCopyTexImage1D, proc);
} else {
log.err("entry point glCopyTexImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyTexImage2D")) |proc| {
function_pointers.glCopyTexImage2D = @ptrCast(?function_signatures.glCopyTexImage2D, proc);
} else {
log.err("entry point glCopyTexImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyTexSubImage1D")) |proc| {
function_pointers.glCopyTexSubImage1D = @ptrCast(?function_signatures.glCopyTexSubImage1D, proc);
} else {
log.err("entry point glCopyTexSubImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyTexSubImage2D")) |proc| {
function_pointers.glCopyTexSubImage2D = @ptrCast(?function_signatures.glCopyTexSubImage2D, proc);
} else {
log.err("entry point glCopyTexSubImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexSubImage1D")) |proc| {
function_pointers.glTexSubImage1D = @ptrCast(?function_signatures.glTexSubImage1D, proc);
} else {
log.err("entry point glTexSubImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexSubImage2D")) |proc| {
function_pointers.glTexSubImage2D = @ptrCast(?function_signatures.glTexSubImage2D, proc);
} else {
log.err("entry point glTexSubImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindTexture")) |proc| {
function_pointers.glBindTexture = @ptrCast(?function_signatures.glBindTexture, proc);
} else {
log.err("entry point glBindTexture not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteTextures")) |proc| {
function_pointers.glDeleteTextures = @ptrCast(?function_signatures.glDeleteTextures, proc);
} else {
log.err("entry point glDeleteTextures not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenTextures")) |proc| {
function_pointers.glGenTextures = @ptrCast(?function_signatures.glGenTextures, proc);
} else {
log.err("entry point glGenTextures not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsTexture")) |proc| {
function_pointers.glIsTexture = @ptrCast(?function_signatures.glIsTexture, proc);
} else {
log.err("entry point glIsTexture not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveSubroutineUniformName")) |proc| {
function_pointers.glGetActiveSubroutineUniformName = @ptrCast(?function_signatures.glGetActiveSubroutineUniformName, proc);
} else {
log.err("entry point glGetActiveSubroutineUniformName not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveSubroutineUniformiv")) |proc| {
function_pointers.glGetActiveSubroutineUniformiv = @ptrCast(?function_signatures.glGetActiveSubroutineUniformiv, proc);
} else {
log.err("entry point glGetActiveSubroutineUniformiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSubroutineIndex")) |proc| {
function_pointers.glGetSubroutineIndex = @ptrCast(?function_signatures.glGetSubroutineIndex, proc);
} else {
log.err("entry point glGetSubroutineIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSubroutineUniformLocation")) |proc| {
function_pointers.glGetSubroutineUniformLocation = @ptrCast(?function_signatures.glGetSubroutineUniformLocation, proc);
} else {
log.err("entry point glGetSubroutineUniformLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformdv")) |proc| {
function_pointers.glGetUniformdv = @ptrCast(?function_signatures.glGetUniformdv, proc);
} else {
log.err("entry point glGetUniformdv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4x3dv")) |proc| {
function_pointers.glUniformMatrix4x3dv = @ptrCast(?function_signatures.glUniformMatrix4x3dv, proc);
} else {
log.err("entry point glUniformMatrix4x3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4x2dv")) |proc| {
function_pointers.glUniformMatrix4x2dv = @ptrCast(?function_signatures.glUniformMatrix4x2dv, proc);
} else {
log.err("entry point glUniformMatrix4x2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3x4dv")) |proc| {
function_pointers.glUniformMatrix3x4dv = @ptrCast(?function_signatures.glUniformMatrix3x4dv, proc);
} else {
log.err("entry point glUniformMatrix3x4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3x2dv")) |proc| {
function_pointers.glUniformMatrix3x2dv = @ptrCast(?function_signatures.glUniformMatrix3x2dv, proc);
} else {
log.err("entry point glUniformMatrix3x2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2x4dv")) |proc| {
function_pointers.glUniformMatrix2x4dv = @ptrCast(?function_signatures.glUniformMatrix2x4dv, proc);
} else {
log.err("entry point glUniformMatrix2x4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2x3dv")) |proc| {
function_pointers.glUniformMatrix2x3dv = @ptrCast(?function_signatures.glUniformMatrix2x3dv, proc);
} else {
log.err("entry point glUniformMatrix2x3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4dv")) |proc| {
function_pointers.glUniformMatrix4dv = @ptrCast(?function_signatures.glUniformMatrix4dv, proc);
} else {
log.err("entry point glUniformMatrix4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3dv")) |proc| {
function_pointers.glUniformMatrix3dv = @ptrCast(?function_signatures.glUniformMatrix3dv, proc);
} else {
log.err("entry point glUniformMatrix3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawRangeElements")) |proc| {
function_pointers.glDrawRangeElements = @ptrCast(?function_signatures.glDrawRangeElements, proc);
} else {
log.err("entry point glDrawRangeElements not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexImage3D")) |proc| {
function_pointers.glTexImage3D = @ptrCast(?function_signatures.glTexImage3D, proc);
} else {
log.err("entry point glTexImage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexSubImage3D")) |proc| {
function_pointers.glTexSubImage3D = @ptrCast(?function_signatures.glTexSubImage3D, proc);
} else {
log.err("entry point glTexSubImage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyTexSubImage3D")) |proc| {
function_pointers.glCopyTexSubImage3D = @ptrCast(?function_signatures.glCopyTexSubImage3D, proc);
} else {
log.err("entry point glCopyTexSubImage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2dv")) |proc| {
function_pointers.glUniformMatrix2dv = @ptrCast(?function_signatures.glUniformMatrix2dv, proc);
} else {
log.err("entry point glUniformMatrix2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4dv")) |proc| {
function_pointers.glUniform4dv = @ptrCast(?function_signatures.glUniform4dv, proc);
} else {
log.err("entry point glUniform4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3dv")) |proc| {
function_pointers.glUniform3dv = @ptrCast(?function_signatures.glUniform3dv, proc);
} else {
log.err("entry point glUniform3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2dv")) |proc| {
function_pointers.glUniform2dv = @ptrCast(?function_signatures.glUniform2dv, proc);
} else {
log.err("entry point glUniform2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1dv")) |proc| {
function_pointers.glUniform1dv = @ptrCast(?function_signatures.glUniform1dv, proc);
} else {
log.err("entry point glUniform1dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4d")) |proc| {
function_pointers.glUniform4d = @ptrCast(?function_signatures.glUniform4d, proc);
} else {
log.err("entry point glUniform4d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3d")) |proc| {
function_pointers.glUniform3d = @ptrCast(?function_signatures.glUniform3d, proc);
} else {
log.err("entry point glUniform3d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2d")) |proc| {
function_pointers.glUniform2d = @ptrCast(?function_signatures.glUniform2d, proc);
} else {
log.err("entry point glUniform2d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1d")) |proc| {
function_pointers.glUniform1d = @ptrCast(?function_signatures.glUniform1d, proc);
} else {
log.err("entry point glUniform1d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsIndirect")) |proc| {
function_pointers.glDrawElementsIndirect = @ptrCast(?function_signatures.glDrawElementsIndirect, proc);
} else {
log.err("entry point glDrawElementsIndirect not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawArraysIndirect")) |proc| {
function_pointers.glDrawArraysIndirect = @ptrCast(?function_signatures.glDrawArraysIndirect, proc);
} else {
log.err("entry point glDrawArraysIndirect not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendFuncSeparatei")) |proc| {
function_pointers.glBlendFuncSeparatei = @ptrCast(?function_signatures.glBlendFuncSeparatei, proc);
} else {
log.err("entry point glBlendFuncSeparatei not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendFunci")) |proc| {
function_pointers.glBlendFunci = @ptrCast(?function_signatures.glBlendFunci, proc);
} else {
log.err("entry point glBlendFunci not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendEquationSeparatei")) |proc| {
function_pointers.glBlendEquationSeparatei = @ptrCast(?function_signatures.glBlendEquationSeparatei, proc);
} else {
log.err("entry point glBlendEquationSeparatei not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendEquationi")) |proc| {
function_pointers.glBlendEquationi = @ptrCast(?function_signatures.glBlendEquationi, proc);
} else {
log.err("entry point glBlendEquationi not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMinSampleShading")) |proc| {
function_pointers.glMinSampleShading = @ptrCast(?function_signatures.glMinSampleShading, proc);
} else {
log.err("entry point glMinSampleShading not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glActiveTexture")) |proc| {
function_pointers.glActiveTexture = @ptrCast(?function_signatures.glActiveTexture, proc);
} else {
log.err("entry point glActiveTexture not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSampleCoverage")) |proc| {
function_pointers.glSampleCoverage = @ptrCast(?function_signatures.glSampleCoverage, proc);
} else {
log.err("entry point glSampleCoverage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexImage3D")) |proc| {
function_pointers.glCompressedTexImage3D = @ptrCast(?function_signatures.glCompressedTexImage3D, proc);
} else {
log.err("entry point glCompressedTexImage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexImage2D")) |proc| {
function_pointers.glCompressedTexImage2D = @ptrCast(?function_signatures.glCompressedTexImage2D, proc);
} else {
log.err("entry point glCompressedTexImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexImage1D")) |proc| {
function_pointers.glCompressedTexImage1D = @ptrCast(?function_signatures.glCompressedTexImage1D, proc);
} else {
log.err("entry point glCompressedTexImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexSubImage3D")) |proc| {
function_pointers.glCompressedTexSubImage3D = @ptrCast(?function_signatures.glCompressedTexSubImage3D, proc);
} else {
log.err("entry point glCompressedTexSubImage3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexSubImage2D")) |proc| {
function_pointers.glCompressedTexSubImage2D = @ptrCast(?function_signatures.glCompressedTexSubImage2D, proc);
} else {
log.err("entry point glCompressedTexSubImage2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompressedTexSubImage1D")) |proc| {
function_pointers.glCompressedTexSubImage1D = @ptrCast(?function_signatures.glCompressedTexSubImage1D, proc);
} else {
log.err("entry point glCompressedTexSubImage1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetCompressedTexImage")) |proc| {
function_pointers.glGetCompressedTexImage = @ptrCast(?function_signatures.glGetCompressedTexImage, proc);
} else {
log.err("entry point glGetCompressedTexImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP4uiv")) |proc| {
function_pointers.glVertexAttribP4uiv = @ptrCast(?function_signatures.glVertexAttribP4uiv, proc);
} else {
log.err("entry point glVertexAttribP4uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP4ui")) |proc| {
function_pointers.glVertexAttribP4ui = @ptrCast(?function_signatures.glVertexAttribP4ui, proc);
} else {
log.err("entry point glVertexAttribP4ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP3uiv")) |proc| {
function_pointers.glVertexAttribP3uiv = @ptrCast(?function_signatures.glVertexAttribP3uiv, proc);
} else {
log.err("entry point glVertexAttribP3uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP3ui")) |proc| {
function_pointers.glVertexAttribP3ui = @ptrCast(?function_signatures.glVertexAttribP3ui, proc);
} else {
log.err("entry point glVertexAttribP3ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP2uiv")) |proc| {
function_pointers.glVertexAttribP2uiv = @ptrCast(?function_signatures.glVertexAttribP2uiv, proc);
} else {
log.err("entry point glVertexAttribP2uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP2ui")) |proc| {
function_pointers.glVertexAttribP2ui = @ptrCast(?function_signatures.glVertexAttribP2ui, proc);
} else {
log.err("entry point glVertexAttribP2ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP1uiv")) |proc| {
function_pointers.glVertexAttribP1uiv = @ptrCast(?function_signatures.glVertexAttribP1uiv, proc);
} else {
log.err("entry point glVertexAttribP1uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribP1ui")) |proc| {
function_pointers.glVertexAttribP1ui = @ptrCast(?function_signatures.glVertexAttribP1ui, proc);
} else {
log.err("entry point glVertexAttribP1ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribDivisor")) |proc| {
function_pointers.glVertexAttribDivisor = @ptrCast(?function_signatures.glVertexAttribDivisor, proc);
} else {
log.err("entry point glVertexAttribDivisor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryObjectui64v")) |proc| {
function_pointers.glGetQueryObjectui64v = @ptrCast(?function_signatures.glGetQueryObjectui64v, proc);
} else {
log.err("entry point glGetQueryObjectui64v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryObjecti64v")) |proc| {
function_pointers.glGetQueryObjecti64v = @ptrCast(?function_signatures.glGetQueryObjecti64v, proc);
} else {
log.err("entry point glGetQueryObjecti64v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glQueryCounter")) |proc| {
function_pointers.glQueryCounter = @ptrCast(?function_signatures.glQueryCounter, proc);
} else {
log.err("entry point glQueryCounter not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSamplerParameterIuiv")) |proc| {
function_pointers.glGetSamplerParameterIuiv = @ptrCast(?function_signatures.glGetSamplerParameterIuiv, proc);
} else {
log.err("entry point glGetSamplerParameterIuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSamplerParameterfv")) |proc| {
function_pointers.glGetSamplerParameterfv = @ptrCast(?function_signatures.glGetSamplerParameterfv, proc);
} else {
log.err("entry point glGetSamplerParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSamplerParameterIiv")) |proc| {
function_pointers.glGetSamplerParameterIiv = @ptrCast(?function_signatures.glGetSamplerParameterIiv, proc);
} else {
log.err("entry point glGetSamplerParameterIiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSamplerParameteriv")) |proc| {
function_pointers.glGetSamplerParameteriv = @ptrCast(?function_signatures.glGetSamplerParameteriv, proc);
} else {
log.err("entry point glGetSamplerParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameterIuiv")) |proc| {
function_pointers.glSamplerParameterIuiv = @ptrCast(?function_signatures.glSamplerParameterIuiv, proc);
} else {
log.err("entry point glSamplerParameterIuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameterIiv")) |proc| {
function_pointers.glSamplerParameterIiv = @ptrCast(?function_signatures.glSamplerParameterIiv, proc);
} else {
log.err("entry point glSamplerParameterIiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameterfv")) |proc| {
function_pointers.glSamplerParameterfv = @ptrCast(?function_signatures.glSamplerParameterfv, proc);
} else {
log.err("entry point glSamplerParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameterf")) |proc| {
function_pointers.glSamplerParameterf = @ptrCast(?function_signatures.glSamplerParameterf, proc);
} else {
log.err("entry point glSamplerParameterf not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameteriv")) |proc| {
function_pointers.glSamplerParameteriv = @ptrCast(?function_signatures.glSamplerParameteriv, proc);
} else {
log.err("entry point glSamplerParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSamplerParameteri")) |proc| {
function_pointers.glSamplerParameteri = @ptrCast(?function_signatures.glSamplerParameteri, proc);
} else {
log.err("entry point glSamplerParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindSampler")) |proc| {
function_pointers.glBindSampler = @ptrCast(?function_signatures.glBindSampler, proc);
} else {
log.err("entry point glBindSampler not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsSampler")) |proc| {
function_pointers.glIsSampler = @ptrCast(?function_signatures.glIsSampler, proc);
} else {
log.err("entry point glIsSampler not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteSamplers")) |proc| {
function_pointers.glDeleteSamplers = @ptrCast(?function_signatures.glDeleteSamplers, proc);
} else {
log.err("entry point glDeleteSamplers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenSamplers")) |proc| {
function_pointers.glGenSamplers = @ptrCast(?function_signatures.glGenSamplers, proc);
} else {
log.err("entry point glGenSamplers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFragDataIndex")) |proc| {
function_pointers.glGetFragDataIndex = @ptrCast(?function_signatures.glGetFragDataIndex, proc);
} else {
log.err("entry point glGetFragDataIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindFragDataLocationIndexed")) |proc| {
function_pointers.glBindFragDataLocationIndexed = @ptrCast(?function_signatures.glBindFragDataLocationIndexed, proc);
} else {
log.err("entry point glBindFragDataLocationIndexed not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glSampleMaski")) |proc| {
function_pointers.glSampleMaski = @ptrCast(?function_signatures.glSampleMaski, proc);
} else {
log.err("entry point glSampleMaski not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetMultisamplefv")) |proc| {
function_pointers.glGetMultisamplefv = @ptrCast(?function_signatures.glGetMultisamplefv, proc);
} else {
log.err("entry point glGetMultisamplefv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexImage3DMultisample")) |proc| {
function_pointers.glTexImage3DMultisample = @ptrCast(?function_signatures.glTexImage3DMultisample, proc);
} else {
log.err("entry point glTexImage3DMultisample not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexImage2DMultisample")) |proc| {
function_pointers.glTexImage2DMultisample = @ptrCast(?function_signatures.glTexImage2DMultisample, proc);
} else {
log.err("entry point glTexImage2DMultisample not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferTexture")) |proc| {
function_pointers.glFramebufferTexture = @ptrCast(?function_signatures.glFramebufferTexture, proc);
} else {
log.err("entry point glFramebufferTexture not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBufferParameteri64v")) |proc| {
function_pointers.glGetBufferParameteri64v = @ptrCast(?function_signatures.glGetBufferParameteri64v, proc);
} else {
log.err("entry point glGetBufferParameteri64v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendFuncSeparate")) |proc| {
function_pointers.glBlendFuncSeparate = @ptrCast(?function_signatures.glBlendFuncSeparate, proc);
} else {
log.err("entry point glBlendFuncSeparate not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMultiDrawArrays")) |proc| {
function_pointers.glMultiDrawArrays = @ptrCast(?function_signatures.glMultiDrawArrays, proc);
} else {
log.err("entry point glMultiDrawArrays not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMultiDrawElements")) |proc| {
function_pointers.glMultiDrawElements = @ptrCast(?function_signatures.glMultiDrawElements, proc);
} else {
log.err("entry point glMultiDrawElements not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPointParameterf")) |proc| {
function_pointers.glPointParameterf = @ptrCast(?function_signatures.glPointParameterf, proc);
} else {
log.err("entry point glPointParameterf not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPointParameterfv")) |proc| {
function_pointers.glPointParameterfv = @ptrCast(?function_signatures.glPointParameterfv, proc);
} else {
log.err("entry point glPointParameterfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPointParameteri")) |proc| {
function_pointers.glPointParameteri = @ptrCast(?function_signatures.glPointParameteri, proc);
} else {
log.err("entry point glPointParameteri not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPointParameteriv")) |proc| {
function_pointers.glPointParameteriv = @ptrCast(?function_signatures.glPointParameteriv, proc);
} else {
log.err("entry point glPointParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetInteger64i_v")) |proc| {
function_pointers.glGetInteger64i_v = @ptrCast(?function_signatures.glGetInteger64i_v, proc);
} else {
log.err("entry point glGetInteger64i_v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetSynciv")) |proc| {
function_pointers.glGetSynciv = @ptrCast(?function_signatures.glGetSynciv, proc);
} else {
log.err("entry point glGetSynciv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetInteger64v")) |proc| {
function_pointers.glGetInteger64v = @ptrCast(?function_signatures.glGetInteger64v, proc);
} else {
log.err("entry point glGetInteger64v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glWaitSync")) |proc| {
function_pointers.glWaitSync = @ptrCast(?function_signatures.glWaitSync, proc);
} else {
log.err("entry point glWaitSync not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClientWaitSync")) |proc| {
function_pointers.glClientWaitSync = @ptrCast(?function_signatures.glClientWaitSync, proc);
} else {
log.err("entry point glClientWaitSync not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteSync")) |proc| {
function_pointers.glDeleteSync = @ptrCast(?function_signatures.glDeleteSync, proc);
} else {
log.err("entry point glDeleteSync not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsSync")) |proc| {
function_pointers.glIsSync = @ptrCast(?function_signatures.glIsSync, proc);
} else {
log.err("entry point glIsSync not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFenceSync")) |proc| {
function_pointers.glFenceSync = @ptrCast(?function_signatures.glFenceSync, proc);
} else {
log.err("entry point glFenceSync not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendColor")) |proc| {
function_pointers.glBlendColor = @ptrCast(?function_signatures.glBlendColor, proc);
} else {
log.err("entry point glBlendColor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendEquation")) |proc| {
function_pointers.glBlendEquation = @ptrCast(?function_signatures.glBlendEquation, proc);
} else {
log.err("entry point glBlendEquation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glProvokingVertex")) |proc| {
function_pointers.glProvokingVertex = @ptrCast(?function_signatures.glProvokingVertex, proc);
} else {
log.err("entry point glProvokingVertex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMultiDrawElementsBaseVertex")) |proc| {
function_pointers.glMultiDrawElementsBaseVertex = @ptrCast(?function_signatures.glMultiDrawElementsBaseVertex, proc);
} else {
log.err("entry point glMultiDrawElementsBaseVertex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsInstancedBaseVertex")) |proc| {
function_pointers.glDrawElementsInstancedBaseVertex = @ptrCast(?function_signatures.glDrawElementsInstancedBaseVertex, proc);
} else {
log.err("entry point glDrawElementsInstancedBaseVertex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawRangeElementsBaseVertex")) |proc| {
function_pointers.glDrawRangeElementsBaseVertex = @ptrCast(?function_signatures.glDrawRangeElementsBaseVertex, proc);
} else {
log.err("entry point glDrawRangeElementsBaseVertex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsBaseVertex")) |proc| {
function_pointers.glDrawElementsBaseVertex = @ptrCast(?function_signatures.glDrawElementsBaseVertex, proc);
} else {
log.err("entry point glDrawElementsBaseVertex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenQueries")) |proc| {
function_pointers.glGenQueries = @ptrCast(?function_signatures.glGenQueries, proc);
} else {
log.err("entry point glGenQueries not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteQueries")) |proc| {
function_pointers.glDeleteQueries = @ptrCast(?function_signatures.glDeleteQueries, proc);
} else {
log.err("entry point glDeleteQueries not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsQuery")) |proc| {
function_pointers.glIsQuery = @ptrCast(?function_signatures.glIsQuery, proc);
} else {
log.err("entry point glIsQuery not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBeginQuery")) |proc| {
function_pointers.glBeginQuery = @ptrCast(?function_signatures.glBeginQuery, proc);
} else {
log.err("entry point glBeginQuery not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEndQuery")) |proc| {
function_pointers.glEndQuery = @ptrCast(?function_signatures.glEndQuery, proc);
} else {
log.err("entry point glEndQuery not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryiv")) |proc| {
function_pointers.glGetQueryiv = @ptrCast(?function_signatures.glGetQueryiv, proc);
} else {
log.err("entry point glGetQueryiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryObjectiv")) |proc| {
function_pointers.glGetQueryObjectiv = @ptrCast(?function_signatures.glGetQueryObjectiv, proc);
} else {
log.err("entry point glGetQueryObjectiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetQueryObjectuiv")) |proc| {
function_pointers.glGetQueryObjectuiv = @ptrCast(?function_signatures.glGetQueryObjectuiv, proc);
} else {
log.err("entry point glGetQueryObjectuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindBuffer")) |proc| {
function_pointers.glBindBuffer = @ptrCast(?function_signatures.glBindBuffer, proc);
} else {
log.err("entry point glBindBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteBuffers")) |proc| {
function_pointers.glDeleteBuffers = @ptrCast(?function_signatures.glDeleteBuffers, proc);
} else {
log.err("entry point glDeleteBuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenBuffers")) |proc| {
function_pointers.glGenBuffers = @ptrCast(?function_signatures.glGenBuffers, proc);
} else {
log.err("entry point glGenBuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsBuffer")) |proc| {
function_pointers.glIsBuffer = @ptrCast(?function_signatures.glIsBuffer, proc);
} else {
log.err("entry point glIsBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBufferData")) |proc| {
function_pointers.glBufferData = @ptrCast(?function_signatures.glBufferData, proc);
} else {
log.err("entry point glBufferData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBufferSubData")) |proc| {
function_pointers.glBufferSubData = @ptrCast(?function_signatures.glBufferSubData, proc);
} else {
log.err("entry point glBufferSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBufferSubData")) |proc| {
function_pointers.glGetBufferSubData = @ptrCast(?function_signatures.glGetBufferSubData, proc);
} else {
log.err("entry point glGetBufferSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMapBuffer")) |proc| {
function_pointers.glMapBuffer = @ptrCast(?function_signatures.glMapBuffer, proc);
} else {
log.err("entry point glMapBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUnmapBuffer")) |proc| {
function_pointers.glUnmapBuffer = @ptrCast(?function_signatures.glUnmapBuffer, proc);
} else {
log.err("entry point glUnmapBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBufferParameteriv")) |proc| {
function_pointers.glGetBufferParameteriv = @ptrCast(?function_signatures.glGetBufferParameteriv, proc);
} else {
log.err("entry point glGetBufferParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBufferPointerv")) |proc| {
function_pointers.glGetBufferPointerv = @ptrCast(?function_signatures.glGetBufferPointerv, proc);
} else {
log.err("entry point glGetBufferPointerv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlendEquationSeparate")) |proc| {
function_pointers.glBlendEquationSeparate = @ptrCast(?function_signatures.glBlendEquationSeparate, proc);
} else {
log.err("entry point glBlendEquationSeparate not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawBuffers")) |proc| {
function_pointers.glDrawBuffers = @ptrCast(?function_signatures.glDrawBuffers, proc);
} else {
log.err("entry point glDrawBuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilOpSeparate")) |proc| {
function_pointers.glStencilOpSeparate = @ptrCast(?function_signatures.glStencilOpSeparate, proc);
} else {
log.err("entry point glStencilOpSeparate not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilFuncSeparate")) |proc| {
function_pointers.glStencilFuncSeparate = @ptrCast(?function_signatures.glStencilFuncSeparate, proc);
} else {
log.err("entry point glStencilFuncSeparate not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glStencilMaskSeparate")) |proc| {
function_pointers.glStencilMaskSeparate = @ptrCast(?function_signatures.glStencilMaskSeparate, proc);
} else {
log.err("entry point glStencilMaskSeparate not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glAttachShader")) |proc| {
function_pointers.glAttachShader = @ptrCast(?function_signatures.glAttachShader, proc);
} else {
log.err("entry point glAttachShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindAttribLocation")) |proc| {
function_pointers.glBindAttribLocation = @ptrCast(?function_signatures.glBindAttribLocation, proc);
} else {
log.err("entry point glBindAttribLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCompileShader")) |proc| {
function_pointers.glCompileShader = @ptrCast(?function_signatures.glCompileShader, proc);
} else {
log.err("entry point glCompileShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCreateProgram")) |proc| {
function_pointers.glCreateProgram = @ptrCast(?function_signatures.glCreateProgram, proc);
} else {
log.err("entry point glCreateProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCreateShader")) |proc| {
function_pointers.glCreateShader = @ptrCast(?function_signatures.glCreateShader, proc);
} else {
log.err("entry point glCreateShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteProgram")) |proc| {
function_pointers.glDeleteProgram = @ptrCast(?function_signatures.glDeleteProgram, proc);
} else {
log.err("entry point glDeleteProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteShader")) |proc| {
function_pointers.glDeleteShader = @ptrCast(?function_signatures.glDeleteShader, proc);
} else {
log.err("entry point glDeleteShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDetachShader")) |proc| {
function_pointers.glDetachShader = @ptrCast(?function_signatures.glDetachShader, proc);
} else {
log.err("entry point glDetachShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDisableVertexAttribArray")) |proc| {
function_pointers.glDisableVertexAttribArray = @ptrCast(?function_signatures.glDisableVertexAttribArray, proc);
} else {
log.err("entry point glDisableVertexAttribArray not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEnableVertexAttribArray")) |proc| {
function_pointers.glEnableVertexAttribArray = @ptrCast(?function_signatures.glEnableVertexAttribArray, proc);
} else {
log.err("entry point glEnableVertexAttribArray not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveAttrib")) |proc| {
function_pointers.glGetActiveAttrib = @ptrCast(?function_signatures.glGetActiveAttrib, proc);
} else {
log.err("entry point glGetActiveAttrib not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveUniform")) |proc| {
function_pointers.glGetActiveUniform = @ptrCast(?function_signatures.glGetActiveUniform, proc);
} else {
log.err("entry point glGetActiveUniform not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetAttachedShaders")) |proc| {
function_pointers.glGetAttachedShaders = @ptrCast(?function_signatures.glGetAttachedShaders, proc);
} else {
log.err("entry point glGetAttachedShaders not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetAttribLocation")) |proc| {
function_pointers.glGetAttribLocation = @ptrCast(?function_signatures.glGetAttribLocation, proc);
} else {
log.err("entry point glGetAttribLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramiv")) |proc| {
function_pointers.glGetProgramiv = @ptrCast(?function_signatures.glGetProgramiv, proc);
} else {
log.err("entry point glGetProgramiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetProgramInfoLog")) |proc| {
function_pointers.glGetProgramInfoLog = @ptrCast(?function_signatures.glGetProgramInfoLog, proc);
} else {
log.err("entry point glGetProgramInfoLog not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetShaderiv")) |proc| {
function_pointers.glGetShaderiv = @ptrCast(?function_signatures.glGetShaderiv, proc);
} else {
log.err("entry point glGetShaderiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetShaderInfoLog")) |proc| {
function_pointers.glGetShaderInfoLog = @ptrCast(?function_signatures.glGetShaderInfoLog, proc);
} else {
log.err("entry point glGetShaderInfoLog not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetShaderSource")) |proc| {
function_pointers.glGetShaderSource = @ptrCast(?function_signatures.glGetShaderSource, proc);
} else {
log.err("entry point glGetShaderSource not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformLocation")) |proc| {
function_pointers.glGetUniformLocation = @ptrCast(?function_signatures.glGetUniformLocation, proc);
} else {
log.err("entry point glGetUniformLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformfv")) |proc| {
function_pointers.glGetUniformfv = @ptrCast(?function_signatures.glGetUniformfv, proc);
} else {
log.err("entry point glGetUniformfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformiv")) |proc| {
function_pointers.glGetUniformiv = @ptrCast(?function_signatures.glGetUniformiv, proc);
} else {
log.err("entry point glGetUniformiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribdv")) |proc| {
function_pointers.glGetVertexAttribdv = @ptrCast(?function_signatures.glGetVertexAttribdv, proc);
} else {
log.err("entry point glGetVertexAttribdv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribfv")) |proc| {
function_pointers.glGetVertexAttribfv = @ptrCast(?function_signatures.glGetVertexAttribfv, proc);
} else {
log.err("entry point glGetVertexAttribfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribiv")) |proc| {
function_pointers.glGetVertexAttribiv = @ptrCast(?function_signatures.glGetVertexAttribiv, proc);
} else {
log.err("entry point glGetVertexAttribiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribPointerv")) |proc| {
function_pointers.glGetVertexAttribPointerv = @ptrCast(?function_signatures.glGetVertexAttribPointerv, proc);
} else {
log.err("entry point glGetVertexAttribPointerv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsProgram")) |proc| {
function_pointers.glIsProgram = @ptrCast(?function_signatures.glIsProgram, proc);
} else {
log.err("entry point glIsProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsShader")) |proc| {
function_pointers.glIsShader = @ptrCast(?function_signatures.glIsShader, proc);
} else {
log.err("entry point glIsShader not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glLinkProgram")) |proc| {
function_pointers.glLinkProgram = @ptrCast(?function_signatures.glLinkProgram, proc);
} else {
log.err("entry point glLinkProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glShaderSource")) |proc| {
function_pointers.glShaderSource = @ptrCast(?function_signatures.glShaderSource, proc);
} else {
log.err("entry point glShaderSource not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUseProgram")) |proc| {
function_pointers.glUseProgram = @ptrCast(?function_signatures.glUseProgram, proc);
} else {
log.err("entry point glUseProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1f")) |proc| {
function_pointers.glUniform1f = @ptrCast(?function_signatures.glUniform1f, proc);
} else {
log.err("entry point glUniform1f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2f")) |proc| {
function_pointers.glUniform2f = @ptrCast(?function_signatures.glUniform2f, proc);
} else {
log.err("entry point glUniform2f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3f")) |proc| {
function_pointers.glUniform3f = @ptrCast(?function_signatures.glUniform3f, proc);
} else {
log.err("entry point glUniform3f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4f")) |proc| {
function_pointers.glUniform4f = @ptrCast(?function_signatures.glUniform4f, proc);
} else {
log.err("entry point glUniform4f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1i")) |proc| {
function_pointers.glUniform1i = @ptrCast(?function_signatures.glUniform1i, proc);
} else {
log.err("entry point glUniform1i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2i")) |proc| {
function_pointers.glUniform2i = @ptrCast(?function_signatures.glUniform2i, proc);
} else {
log.err("entry point glUniform2i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3i")) |proc| {
function_pointers.glUniform3i = @ptrCast(?function_signatures.glUniform3i, proc);
} else {
log.err("entry point glUniform3i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4i")) |proc| {
function_pointers.glUniform4i = @ptrCast(?function_signatures.glUniform4i, proc);
} else {
log.err("entry point glUniform4i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1fv")) |proc| {
function_pointers.glUniform1fv = @ptrCast(?function_signatures.glUniform1fv, proc);
} else {
log.err("entry point glUniform1fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2fv")) |proc| {
function_pointers.glUniform2fv = @ptrCast(?function_signatures.glUniform2fv, proc);
} else {
log.err("entry point glUniform2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3fv")) |proc| {
function_pointers.glUniform3fv = @ptrCast(?function_signatures.glUniform3fv, proc);
} else {
log.err("entry point glUniform3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4fv")) |proc| {
function_pointers.glUniform4fv = @ptrCast(?function_signatures.glUniform4fv, proc);
} else {
log.err("entry point glUniform4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1iv")) |proc| {
function_pointers.glUniform1iv = @ptrCast(?function_signatures.glUniform1iv, proc);
} else {
log.err("entry point glUniform1iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2iv")) |proc| {
function_pointers.glUniform2iv = @ptrCast(?function_signatures.glUniform2iv, proc);
} else {
log.err("entry point glUniform2iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3iv")) |proc| {
function_pointers.glUniform3iv = @ptrCast(?function_signatures.glUniform3iv, proc);
} else {
log.err("entry point glUniform3iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4iv")) |proc| {
function_pointers.glUniform4iv = @ptrCast(?function_signatures.glUniform4iv, proc);
} else {
log.err("entry point glUniform4iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2fv")) |proc| {
function_pointers.glUniformMatrix2fv = @ptrCast(?function_signatures.glUniformMatrix2fv, proc);
} else {
log.err("entry point glUniformMatrix2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3fv")) |proc| {
function_pointers.glUniformMatrix3fv = @ptrCast(?function_signatures.glUniformMatrix3fv, proc);
} else {
log.err("entry point glUniformMatrix3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4fv")) |proc| {
function_pointers.glUniformMatrix4fv = @ptrCast(?function_signatures.glUniformMatrix4fv, proc);
} else {
log.err("entry point glUniformMatrix4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glValidateProgram")) |proc| {
function_pointers.glValidateProgram = @ptrCast(?function_signatures.glValidateProgram, proc);
} else {
log.err("entry point glValidateProgram not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1d")) |proc| {
function_pointers.glVertexAttrib1d = @ptrCast(?function_signatures.glVertexAttrib1d, proc);
} else {
log.err("entry point glVertexAttrib1d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1dv")) |proc| {
function_pointers.glVertexAttrib1dv = @ptrCast(?function_signatures.glVertexAttrib1dv, proc);
} else {
log.err("entry point glVertexAttrib1dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1f")) |proc| {
function_pointers.glVertexAttrib1f = @ptrCast(?function_signatures.glVertexAttrib1f, proc);
} else {
log.err("entry point glVertexAttrib1f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1fv")) |proc| {
function_pointers.glVertexAttrib1fv = @ptrCast(?function_signatures.glVertexAttrib1fv, proc);
} else {
log.err("entry point glVertexAttrib1fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1s")) |proc| {
function_pointers.glVertexAttrib1s = @ptrCast(?function_signatures.glVertexAttrib1s, proc);
} else {
log.err("entry point glVertexAttrib1s not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib1sv")) |proc| {
function_pointers.glVertexAttrib1sv = @ptrCast(?function_signatures.glVertexAttrib1sv, proc);
} else {
log.err("entry point glVertexAttrib1sv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2d")) |proc| {
function_pointers.glVertexAttrib2d = @ptrCast(?function_signatures.glVertexAttrib2d, proc);
} else {
log.err("entry point glVertexAttrib2d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2dv")) |proc| {
function_pointers.glVertexAttrib2dv = @ptrCast(?function_signatures.glVertexAttrib2dv, proc);
} else {
log.err("entry point glVertexAttrib2dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2f")) |proc| {
function_pointers.glVertexAttrib2f = @ptrCast(?function_signatures.glVertexAttrib2f, proc);
} else {
log.err("entry point glVertexAttrib2f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2fv")) |proc| {
function_pointers.glVertexAttrib2fv = @ptrCast(?function_signatures.glVertexAttrib2fv, proc);
} else {
log.err("entry point glVertexAttrib2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2s")) |proc| {
function_pointers.glVertexAttrib2s = @ptrCast(?function_signatures.glVertexAttrib2s, proc);
} else {
log.err("entry point glVertexAttrib2s not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib2sv")) |proc| {
function_pointers.glVertexAttrib2sv = @ptrCast(?function_signatures.glVertexAttrib2sv, proc);
} else {
log.err("entry point glVertexAttrib2sv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3d")) |proc| {
function_pointers.glVertexAttrib3d = @ptrCast(?function_signatures.glVertexAttrib3d, proc);
} else {
log.err("entry point glVertexAttrib3d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3dv")) |proc| {
function_pointers.glVertexAttrib3dv = @ptrCast(?function_signatures.glVertexAttrib3dv, proc);
} else {
log.err("entry point glVertexAttrib3dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3f")) |proc| {
function_pointers.glVertexAttrib3f = @ptrCast(?function_signatures.glVertexAttrib3f, proc);
} else {
log.err("entry point glVertexAttrib3f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3fv")) |proc| {
function_pointers.glVertexAttrib3fv = @ptrCast(?function_signatures.glVertexAttrib3fv, proc);
} else {
log.err("entry point glVertexAttrib3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3s")) |proc| {
function_pointers.glVertexAttrib3s = @ptrCast(?function_signatures.glVertexAttrib3s, proc);
} else {
log.err("entry point glVertexAttrib3s not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib3sv")) |proc| {
function_pointers.glVertexAttrib3sv = @ptrCast(?function_signatures.glVertexAttrib3sv, proc);
} else {
log.err("entry point glVertexAttrib3sv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nbv")) |proc| {
function_pointers.glVertexAttrib4Nbv = @ptrCast(?function_signatures.glVertexAttrib4Nbv, proc);
} else {
log.err("entry point glVertexAttrib4Nbv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Niv")) |proc| {
function_pointers.glVertexAttrib4Niv = @ptrCast(?function_signatures.glVertexAttrib4Niv, proc);
} else {
log.err("entry point glVertexAttrib4Niv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nsv")) |proc| {
function_pointers.glVertexAttrib4Nsv = @ptrCast(?function_signatures.glVertexAttrib4Nsv, proc);
} else {
log.err("entry point glVertexAttrib4Nsv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nub")) |proc| {
function_pointers.glVertexAttrib4Nub = @ptrCast(?function_signatures.glVertexAttrib4Nub, proc);
} else {
log.err("entry point glVertexAttrib4Nub not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nubv")) |proc| {
function_pointers.glVertexAttrib4Nubv = @ptrCast(?function_signatures.glVertexAttrib4Nubv, proc);
} else {
log.err("entry point glVertexAttrib4Nubv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nuiv")) |proc| {
function_pointers.glVertexAttrib4Nuiv = @ptrCast(?function_signatures.glVertexAttrib4Nuiv, proc);
} else {
log.err("entry point glVertexAttrib4Nuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4Nusv")) |proc| {
function_pointers.glVertexAttrib4Nusv = @ptrCast(?function_signatures.glVertexAttrib4Nusv, proc);
} else {
log.err("entry point glVertexAttrib4Nusv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4bv")) |proc| {
function_pointers.glVertexAttrib4bv = @ptrCast(?function_signatures.glVertexAttrib4bv, proc);
} else {
log.err("entry point glVertexAttrib4bv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4d")) |proc| {
function_pointers.glVertexAttrib4d = @ptrCast(?function_signatures.glVertexAttrib4d, proc);
} else {
log.err("entry point glVertexAttrib4d not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4dv")) |proc| {
function_pointers.glVertexAttrib4dv = @ptrCast(?function_signatures.glVertexAttrib4dv, proc);
} else {
log.err("entry point glVertexAttrib4dv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4f")) |proc| {
function_pointers.glVertexAttrib4f = @ptrCast(?function_signatures.glVertexAttrib4f, proc);
} else {
log.err("entry point glVertexAttrib4f not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4fv")) |proc| {
function_pointers.glVertexAttrib4fv = @ptrCast(?function_signatures.glVertexAttrib4fv, proc);
} else {
log.err("entry point glVertexAttrib4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4iv")) |proc| {
function_pointers.glVertexAttrib4iv = @ptrCast(?function_signatures.glVertexAttrib4iv, proc);
} else {
log.err("entry point glVertexAttrib4iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4s")) |proc| {
function_pointers.glVertexAttrib4s = @ptrCast(?function_signatures.glVertexAttrib4s, proc);
} else {
log.err("entry point glVertexAttrib4s not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4sv")) |proc| {
function_pointers.glVertexAttrib4sv = @ptrCast(?function_signatures.glVertexAttrib4sv, proc);
} else {
log.err("entry point glVertexAttrib4sv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4ubv")) |proc| {
function_pointers.glVertexAttrib4ubv = @ptrCast(?function_signatures.glVertexAttrib4ubv, proc);
} else {
log.err("entry point glVertexAttrib4ubv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4uiv")) |proc| {
function_pointers.glVertexAttrib4uiv = @ptrCast(?function_signatures.glVertexAttrib4uiv, proc);
} else {
log.err("entry point glVertexAttrib4uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttrib4usv")) |proc| {
function_pointers.glVertexAttrib4usv = @ptrCast(?function_signatures.glVertexAttrib4usv, proc);
} else {
log.err("entry point glVertexAttrib4usv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribPointer")) |proc| {
function_pointers.glVertexAttribPointer = @ptrCast(?function_signatures.glVertexAttribPointer, proc);
} else {
log.err("entry point glVertexAttribPointer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2x3fv")) |proc| {
function_pointers.glUniformMatrix2x3fv = @ptrCast(?function_signatures.glUniformMatrix2x3fv, proc);
} else {
log.err("entry point glUniformMatrix2x3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3x2fv")) |proc| {
function_pointers.glUniformMatrix3x2fv = @ptrCast(?function_signatures.glUniformMatrix3x2fv, proc);
} else {
log.err("entry point glUniformMatrix3x2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix2x4fv")) |proc| {
function_pointers.glUniformMatrix2x4fv = @ptrCast(?function_signatures.glUniformMatrix2x4fv, proc);
} else {
log.err("entry point glUniformMatrix2x4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4x2fv")) |proc| {
function_pointers.glUniformMatrix4x2fv = @ptrCast(?function_signatures.glUniformMatrix4x2fv, proc);
} else {
log.err("entry point glUniformMatrix4x2fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix3x4fv")) |proc| {
function_pointers.glUniformMatrix3x4fv = @ptrCast(?function_signatures.glUniformMatrix3x4fv, proc);
} else {
log.err("entry point glUniformMatrix3x4fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformMatrix4x3fv")) |proc| {
function_pointers.glUniformMatrix4x3fv = @ptrCast(?function_signatures.glUniformMatrix4x3fv, proc);
} else {
log.err("entry point glUniformMatrix4x3fv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glColorMaski")) |proc| {
function_pointers.glColorMaski = @ptrCast(?function_signatures.glColorMaski, proc);
} else {
log.err("entry point glColorMaski not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetBooleani_v")) |proc| {
function_pointers.glGetBooleani_v = @ptrCast(?function_signatures.glGetBooleani_v, proc);
} else {
log.err("entry point glGetBooleani_v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetIntegeri_v")) |proc| {
function_pointers.glGetIntegeri_v = @ptrCast(?function_signatures.glGetIntegeri_v, proc);
} else {
log.err("entry point glGetIntegeri_v not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEnablei")) |proc| {
function_pointers.glEnablei = @ptrCast(?function_signatures.glEnablei, proc);
} else {
log.err("entry point glEnablei not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDisablei")) |proc| {
function_pointers.glDisablei = @ptrCast(?function_signatures.glDisablei, proc);
} else {
log.err("entry point glDisablei not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsEnabledi")) |proc| {
function_pointers.glIsEnabledi = @ptrCast(?function_signatures.glIsEnabledi, proc);
} else {
log.err("entry point glIsEnabledi not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBeginTransformFeedback")) |proc| {
function_pointers.glBeginTransformFeedback = @ptrCast(?function_signatures.glBeginTransformFeedback, proc);
} else {
log.err("entry point glBeginTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEndTransformFeedback")) |proc| {
function_pointers.glEndTransformFeedback = @ptrCast(?function_signatures.glEndTransformFeedback, proc);
} else {
log.err("entry point glEndTransformFeedback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindBufferRange")) |proc| {
function_pointers.glBindBufferRange = @ptrCast(?function_signatures.glBindBufferRange, proc);
} else {
log.err("entry point glBindBufferRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindBufferBase")) |proc| {
function_pointers.glBindBufferBase = @ptrCast(?function_signatures.glBindBufferBase, proc);
} else {
log.err("entry point glBindBufferBase not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTransformFeedbackVaryings")) |proc| {
function_pointers.glTransformFeedbackVaryings = @ptrCast(?function_signatures.glTransformFeedbackVaryings, proc);
} else {
log.err("entry point glTransformFeedbackVaryings not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTransformFeedbackVarying")) |proc| {
function_pointers.glGetTransformFeedbackVarying = @ptrCast(?function_signatures.glGetTransformFeedbackVarying, proc);
} else {
log.err("entry point glGetTransformFeedbackVarying not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClampColor")) |proc| {
function_pointers.glClampColor = @ptrCast(?function_signatures.glClampColor, proc);
} else {
log.err("entry point glClampColor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBeginConditionalRender")) |proc| {
function_pointers.glBeginConditionalRender = @ptrCast(?function_signatures.glBeginConditionalRender, proc);
} else {
log.err("entry point glBeginConditionalRender not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glEndConditionalRender")) |proc| {
function_pointers.glEndConditionalRender = @ptrCast(?function_signatures.glEndConditionalRender, proc);
} else {
log.err("entry point glEndConditionalRender not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribIPointer")) |proc| {
function_pointers.glVertexAttribIPointer = @ptrCast(?function_signatures.glVertexAttribIPointer, proc);
} else {
log.err("entry point glVertexAttribIPointer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribIiv")) |proc| {
function_pointers.glGetVertexAttribIiv = @ptrCast(?function_signatures.glGetVertexAttribIiv, proc);
} else {
log.err("entry point glGetVertexAttribIiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetVertexAttribIuiv")) |proc| {
function_pointers.glGetVertexAttribIuiv = @ptrCast(?function_signatures.glGetVertexAttribIuiv, proc);
} else {
log.err("entry point glGetVertexAttribIuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI1i")) |proc| {
function_pointers.glVertexAttribI1i = @ptrCast(?function_signatures.glVertexAttribI1i, proc);
} else {
log.err("entry point glVertexAttribI1i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI2i")) |proc| {
function_pointers.glVertexAttribI2i = @ptrCast(?function_signatures.glVertexAttribI2i, proc);
} else {
log.err("entry point glVertexAttribI2i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI3i")) |proc| {
function_pointers.glVertexAttribI3i = @ptrCast(?function_signatures.glVertexAttribI3i, proc);
} else {
log.err("entry point glVertexAttribI3i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4i")) |proc| {
function_pointers.glVertexAttribI4i = @ptrCast(?function_signatures.glVertexAttribI4i, proc);
} else {
log.err("entry point glVertexAttribI4i not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI1ui")) |proc| {
function_pointers.glVertexAttribI1ui = @ptrCast(?function_signatures.glVertexAttribI1ui, proc);
} else {
log.err("entry point glVertexAttribI1ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI2ui")) |proc| {
function_pointers.glVertexAttribI2ui = @ptrCast(?function_signatures.glVertexAttribI2ui, proc);
} else {
log.err("entry point glVertexAttribI2ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI3ui")) |proc| {
function_pointers.glVertexAttribI3ui = @ptrCast(?function_signatures.glVertexAttribI3ui, proc);
} else {
log.err("entry point glVertexAttribI3ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4ui")) |proc| {
function_pointers.glVertexAttribI4ui = @ptrCast(?function_signatures.glVertexAttribI4ui, proc);
} else {
log.err("entry point glVertexAttribI4ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI1iv")) |proc| {
function_pointers.glVertexAttribI1iv = @ptrCast(?function_signatures.glVertexAttribI1iv, proc);
} else {
log.err("entry point glVertexAttribI1iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI2iv")) |proc| {
function_pointers.glVertexAttribI2iv = @ptrCast(?function_signatures.glVertexAttribI2iv, proc);
} else {
log.err("entry point glVertexAttribI2iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI3iv")) |proc| {
function_pointers.glVertexAttribI3iv = @ptrCast(?function_signatures.glVertexAttribI3iv, proc);
} else {
log.err("entry point glVertexAttribI3iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4iv")) |proc| {
function_pointers.glVertexAttribI4iv = @ptrCast(?function_signatures.glVertexAttribI4iv, proc);
} else {
log.err("entry point glVertexAttribI4iv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI1uiv")) |proc| {
function_pointers.glVertexAttribI1uiv = @ptrCast(?function_signatures.glVertexAttribI1uiv, proc);
} else {
log.err("entry point glVertexAttribI1uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI2uiv")) |proc| {
function_pointers.glVertexAttribI2uiv = @ptrCast(?function_signatures.glVertexAttribI2uiv, proc);
} else {
log.err("entry point glVertexAttribI2uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI3uiv")) |proc| {
function_pointers.glVertexAttribI3uiv = @ptrCast(?function_signatures.glVertexAttribI3uiv, proc);
} else {
log.err("entry point glVertexAttribI3uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4uiv")) |proc| {
function_pointers.glVertexAttribI4uiv = @ptrCast(?function_signatures.glVertexAttribI4uiv, proc);
} else {
log.err("entry point glVertexAttribI4uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4bv")) |proc| {
function_pointers.glVertexAttribI4bv = @ptrCast(?function_signatures.glVertexAttribI4bv, proc);
} else {
log.err("entry point glVertexAttribI4bv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4sv")) |proc| {
function_pointers.glVertexAttribI4sv = @ptrCast(?function_signatures.glVertexAttribI4sv, proc);
} else {
log.err("entry point glVertexAttribI4sv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4ubv")) |proc| {
function_pointers.glVertexAttribI4ubv = @ptrCast(?function_signatures.glVertexAttribI4ubv, proc);
} else {
log.err("entry point glVertexAttribI4ubv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribI4usv")) |proc| {
function_pointers.glVertexAttribI4usv = @ptrCast(?function_signatures.glVertexAttribI4usv, proc);
} else {
log.err("entry point glVertexAttribI4usv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformuiv")) |proc| {
function_pointers.glGetUniformuiv = @ptrCast(?function_signatures.glGetUniformuiv, proc);
} else {
log.err("entry point glGetUniformuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindFragDataLocation")) |proc| {
function_pointers.glBindFragDataLocation = @ptrCast(?function_signatures.glBindFragDataLocation, proc);
} else {
log.err("entry point glBindFragDataLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFragDataLocation")) |proc| {
function_pointers.glGetFragDataLocation = @ptrCast(?function_signatures.glGetFragDataLocation, proc);
} else {
log.err("entry point glGetFragDataLocation not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1ui")) |proc| {
function_pointers.glUniform1ui = @ptrCast(?function_signatures.glUniform1ui, proc);
} else {
log.err("entry point glUniform1ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2ui")) |proc| {
function_pointers.glUniform2ui = @ptrCast(?function_signatures.glUniform2ui, proc);
} else {
log.err("entry point glUniform2ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3ui")) |proc| {
function_pointers.glUniform3ui = @ptrCast(?function_signatures.glUniform3ui, proc);
} else {
log.err("entry point glUniform3ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4ui")) |proc| {
function_pointers.glUniform4ui = @ptrCast(?function_signatures.glUniform4ui, proc);
} else {
log.err("entry point glUniform4ui not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform1uiv")) |proc| {
function_pointers.glUniform1uiv = @ptrCast(?function_signatures.glUniform1uiv, proc);
} else {
log.err("entry point glUniform1uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform2uiv")) |proc| {
function_pointers.glUniform2uiv = @ptrCast(?function_signatures.glUniform2uiv, proc);
} else {
log.err("entry point glUniform2uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform3uiv")) |proc| {
function_pointers.glUniform3uiv = @ptrCast(?function_signatures.glUniform3uiv, proc);
} else {
log.err("entry point glUniform3uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniform4uiv")) |proc| {
function_pointers.glUniform4uiv = @ptrCast(?function_signatures.glUniform4uiv, proc);
} else {
log.err("entry point glUniform4uiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameterIiv")) |proc| {
function_pointers.glTexParameterIiv = @ptrCast(?function_signatures.glTexParameterIiv, proc);
} else {
log.err("entry point glTexParameterIiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexParameterIuiv")) |proc| {
function_pointers.glTexParameterIuiv = @ptrCast(?function_signatures.glTexParameterIuiv, proc);
} else {
log.err("entry point glTexParameterIuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexParameterIiv")) |proc| {
function_pointers.glGetTexParameterIiv = @ptrCast(?function_signatures.glGetTexParameterIiv, proc);
} else {
log.err("entry point glGetTexParameterIiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetTexParameterIuiv")) |proc| {
function_pointers.glGetTexParameterIuiv = @ptrCast(?function_signatures.glGetTexParameterIuiv, proc);
} else {
log.err("entry point glGetTexParameterIuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferiv")) |proc| {
function_pointers.glClearBufferiv = @ptrCast(?function_signatures.glClearBufferiv, proc);
} else {
log.err("entry point glClearBufferiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferuiv")) |proc| {
function_pointers.glClearBufferuiv = @ptrCast(?function_signatures.glClearBufferuiv, proc);
} else {
log.err("entry point glClearBufferuiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferfv")) |proc| {
function_pointers.glClearBufferfv = @ptrCast(?function_signatures.glClearBufferfv, proc);
} else {
log.err("entry point glClearBufferfv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearBufferfi")) |proc| {
function_pointers.glClearBufferfi = @ptrCast(?function_signatures.glClearBufferfi, proc);
} else {
log.err("entry point glClearBufferfi not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetStringi")) |proc| {
function_pointers.glGetStringi = @ptrCast(?function_signatures.glGetStringi, proc);
} else {
log.err("entry point glGetStringi not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsRenderbuffer")) |proc| {
function_pointers.glIsRenderbuffer = @ptrCast(?function_signatures.glIsRenderbuffer, proc);
} else {
log.err("entry point glIsRenderbuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindRenderbuffer")) |proc| {
function_pointers.glBindRenderbuffer = @ptrCast(?function_signatures.glBindRenderbuffer, proc);
} else {
log.err("entry point glBindRenderbuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteRenderbuffers")) |proc| {
function_pointers.glDeleteRenderbuffers = @ptrCast(?function_signatures.glDeleteRenderbuffers, proc);
} else {
log.err("entry point glDeleteRenderbuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenRenderbuffers")) |proc| {
function_pointers.glGenRenderbuffers = @ptrCast(?function_signatures.glGenRenderbuffers, proc);
} else {
log.err("entry point glGenRenderbuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glRenderbufferStorage")) |proc| {
function_pointers.glRenderbufferStorage = @ptrCast(?function_signatures.glRenderbufferStorage, proc);
} else {
log.err("entry point glRenderbufferStorage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetRenderbufferParameteriv")) |proc| {
function_pointers.glGetRenderbufferParameteriv = @ptrCast(?function_signatures.glGetRenderbufferParameteriv, proc);
} else {
log.err("entry point glGetRenderbufferParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsFramebuffer")) |proc| {
function_pointers.glIsFramebuffer = @ptrCast(?function_signatures.glIsFramebuffer, proc);
} else {
log.err("entry point glIsFramebuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindFramebuffer")) |proc| {
function_pointers.glBindFramebuffer = @ptrCast(?function_signatures.glBindFramebuffer, proc);
} else {
log.err("entry point glBindFramebuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteFramebuffers")) |proc| {
function_pointers.glDeleteFramebuffers = @ptrCast(?function_signatures.glDeleteFramebuffers, proc);
} else {
log.err("entry point glDeleteFramebuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenFramebuffers")) |proc| {
function_pointers.glGenFramebuffers = @ptrCast(?function_signatures.glGenFramebuffers, proc);
} else {
log.err("entry point glGenFramebuffers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCheckFramebufferStatus")) |proc| {
function_pointers.glCheckFramebufferStatus = @ptrCast(?function_signatures.glCheckFramebufferStatus, proc);
} else {
log.err("entry point glCheckFramebufferStatus not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferTexture1D")) |proc| {
function_pointers.glFramebufferTexture1D = @ptrCast(?function_signatures.glFramebufferTexture1D, proc);
} else {
log.err("entry point glFramebufferTexture1D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferTexture2D")) |proc| {
function_pointers.glFramebufferTexture2D = @ptrCast(?function_signatures.glFramebufferTexture2D, proc);
} else {
log.err("entry point glFramebufferTexture2D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferTexture3D")) |proc| {
function_pointers.glFramebufferTexture3D = @ptrCast(?function_signatures.glFramebufferTexture3D, proc);
} else {
log.err("entry point glFramebufferTexture3D not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferRenderbuffer")) |proc| {
function_pointers.glFramebufferRenderbuffer = @ptrCast(?function_signatures.glFramebufferRenderbuffer, proc);
} else {
log.err("entry point glFramebufferRenderbuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetFramebufferAttachmentParameteriv")) |proc| {
function_pointers.glGetFramebufferAttachmentParameteriv = @ptrCast(?function_signatures.glGetFramebufferAttachmentParameteriv, proc);
} else {
log.err("entry point glGetFramebufferAttachmentParameteriv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenerateMipmap")) |proc| {
function_pointers.glGenerateMipmap = @ptrCast(?function_signatures.glGenerateMipmap, proc);
} else {
log.err("entry point glGenerateMipmap not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBlitFramebuffer")) |proc| {
function_pointers.glBlitFramebuffer = @ptrCast(?function_signatures.glBlitFramebuffer, proc);
} else {
log.err("entry point glBlitFramebuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glRenderbufferStorageMultisample")) |proc| {
function_pointers.glRenderbufferStorageMultisample = @ptrCast(?function_signatures.glRenderbufferStorageMultisample, proc);
} else {
log.err("entry point glRenderbufferStorageMultisample not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFramebufferTextureLayer")) |proc| {
function_pointers.glFramebufferTextureLayer = @ptrCast(?function_signatures.glFramebufferTextureLayer, proc);
} else {
log.err("entry point glFramebufferTextureLayer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glMapBufferRange")) |proc| {
function_pointers.glMapBufferRange = @ptrCast(?function_signatures.glMapBufferRange, proc);
} else {
log.err("entry point glMapBufferRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glFlushMappedBufferRange")) |proc| {
function_pointers.glFlushMappedBufferRange = @ptrCast(?function_signatures.glFlushMappedBufferRange, proc);
} else {
log.err("entry point glFlushMappedBufferRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindVertexArray")) |proc| {
function_pointers.glBindVertexArray = @ptrCast(?function_signatures.glBindVertexArray, proc);
} else {
log.err("entry point glBindVertexArray not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDeleteVertexArrays")) |proc| {
function_pointers.glDeleteVertexArrays = @ptrCast(?function_signatures.glDeleteVertexArrays, proc);
} else {
log.err("entry point glDeleteVertexArrays not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGenVertexArrays")) |proc| {
function_pointers.glGenVertexArrays = @ptrCast(?function_signatures.glGenVertexArrays, proc);
} else {
log.err("entry point glGenVertexArrays not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glIsVertexArray")) |proc| {
function_pointers.glIsVertexArray = @ptrCast(?function_signatures.glIsVertexArray, proc);
} else {
log.err("entry point glIsVertexArray not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawArraysInstanced")) |proc| {
function_pointers.glDrawArraysInstanced = @ptrCast(?function_signatures.glDrawArraysInstanced, proc);
} else {
log.err("entry point glDrawArraysInstanced not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDrawElementsInstanced")) |proc| {
function_pointers.glDrawElementsInstanced = @ptrCast(?function_signatures.glDrawElementsInstanced, proc);
} else {
log.err("entry point glDrawElementsInstanced not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexBuffer")) |proc| {
function_pointers.glTexBuffer = @ptrCast(?function_signatures.glTexBuffer, proc);
} else {
log.err("entry point glTexBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPrimitiveRestartIndex")) |proc| {
function_pointers.glPrimitiveRestartIndex = @ptrCast(?function_signatures.glPrimitiveRestartIndex, proc);
} else {
log.err("entry point glPrimitiveRestartIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glCopyBufferSubData")) |proc| {
function_pointers.glCopyBufferSubData = @ptrCast(?function_signatures.glCopyBufferSubData, proc);
} else {
log.err("entry point glCopyBufferSubData not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformIndices")) |proc| {
function_pointers.glGetUniformIndices = @ptrCast(?function_signatures.glGetUniformIndices, proc);
} else {
log.err("entry point glGetUniformIndices not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveUniformsiv")) |proc| {
function_pointers.glGetActiveUniformsiv = @ptrCast(?function_signatures.glGetActiveUniformsiv, proc);
} else {
log.err("entry point glGetActiveUniformsiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveUniformName")) |proc| {
function_pointers.glGetActiveUniformName = @ptrCast(?function_signatures.glGetActiveUniformName, proc);
} else {
log.err("entry point glGetActiveUniformName not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetUniformBlockIndex")) |proc| {
function_pointers.glGetUniformBlockIndex = @ptrCast(?function_signatures.glGetUniformBlockIndex, proc);
} else {
log.err("entry point glGetUniformBlockIndex not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveUniformBlockiv")) |proc| {
function_pointers.glGetActiveUniformBlockiv = @ptrCast(?function_signatures.glGetActiveUniformBlockiv, proc);
} else {
log.err("entry point glGetActiveUniformBlockiv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetActiveUniformBlockName")) |proc| {
function_pointers.glGetActiveUniformBlockName = @ptrCast(?function_signatures.glGetActiveUniformBlockName, proc);
} else {
log.err("entry point glGetActiveUniformBlockName not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glUniformBlockBinding")) |proc| {
function_pointers.glUniformBlockBinding = @ptrCast(?function_signatures.glUniformBlockBinding, proc);
} else {
log.err("entry point glUniformBlockBinding not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTexStorage3DMultisample")) |proc| {
function_pointers.glTexStorage3DMultisample = @ptrCast(?function_signatures.glTexStorage3DMultisample, proc);
} else {
log.err("entry point glTexStorage3DMultisample not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glTextureView")) |proc| {
function_pointers.glTextureView = @ptrCast(?function_signatures.glTextureView, proc);
} else {
log.err("entry point glTextureView not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindVertexBuffer")) |proc| {
function_pointers.glBindVertexBuffer = @ptrCast(?function_signatures.glBindVertexBuffer, proc);
} else {
log.err("entry point glBindVertexBuffer not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribFormat")) |proc| {
function_pointers.glVertexAttribFormat = @ptrCast(?function_signatures.glVertexAttribFormat, proc);
} else {
log.err("entry point glVertexAttribFormat not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribIFormat")) |proc| {
function_pointers.glVertexAttribIFormat = @ptrCast(?function_signatures.glVertexAttribIFormat, proc);
} else {
log.err("entry point glVertexAttribIFormat not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribLFormat")) |proc| {
function_pointers.glVertexAttribLFormat = @ptrCast(?function_signatures.glVertexAttribLFormat, proc);
} else {
log.err("entry point glVertexAttribLFormat not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexAttribBinding")) |proc| {
function_pointers.glVertexAttribBinding = @ptrCast(?function_signatures.glVertexAttribBinding, proc);
} else {
log.err("entry point glVertexAttribBinding not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glVertexBindingDivisor")) |proc| {
function_pointers.glVertexBindingDivisor = @ptrCast(?function_signatures.glVertexBindingDivisor, proc);
} else {
log.err("entry point glVertexBindingDivisor not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDebugMessageControl")) |proc| {
function_pointers.glDebugMessageControl = @ptrCast(?function_signatures.glDebugMessageControl, proc);
} else {
log.err("entry point glDebugMessageControl not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDebugMessageInsert")) |proc| {
function_pointers.glDebugMessageInsert = @ptrCast(?function_signatures.glDebugMessageInsert, proc);
} else {
log.err("entry point glDebugMessageInsert not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glDebugMessageCallback")) |proc| {
function_pointers.glDebugMessageCallback = @ptrCast(?function_signatures.glDebugMessageCallback, proc);
} else {
log.err("entry point glDebugMessageCallback not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetDebugMessageLog")) |proc| {
function_pointers.glGetDebugMessageLog = @ptrCast(?function_signatures.glGetDebugMessageLog, proc);
} else {
log.err("entry point glGetDebugMessageLog not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPushDebugGroup")) |proc| {
function_pointers.glPushDebugGroup = @ptrCast(?function_signatures.glPushDebugGroup, proc);
} else {
log.err("entry point glPushDebugGroup not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glPopDebugGroup")) |proc| {
function_pointers.glPopDebugGroup = @ptrCast(?function_signatures.glPopDebugGroup, proc);
} else {
log.err("entry point glPopDebugGroup not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glObjectLabel")) |proc| {
function_pointers.glObjectLabel = @ptrCast(?function_signatures.glObjectLabel, proc);
} else {
log.err("entry point glObjectLabel not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetObjectLabel")) |proc| {
function_pointers.glGetObjectLabel = @ptrCast(?function_signatures.glGetObjectLabel, proc);
} else {
log.err("entry point glGetObjectLabel not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glObjectPtrLabel")) |proc| {
function_pointers.glObjectPtrLabel = @ptrCast(?function_signatures.glObjectPtrLabel, proc);
} else {
log.err("entry point glObjectPtrLabel not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetObjectPtrLabel")) |proc| {
function_pointers.glGetObjectPtrLabel = @ptrCast(?function_signatures.glGetObjectPtrLabel, proc);
} else {
log.err("entry point glGetObjectPtrLabel not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glGetPointerv")) |proc| {
function_pointers.glGetPointerv = @ptrCast(?function_signatures.glGetPointerv, proc);
} else {
log.err("entry point glGetPointerv not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBufferStorage")) |proc| {
function_pointers.glBufferStorage = @ptrCast(?function_signatures.glBufferStorage, proc);
} else {
log.err("entry point glBufferStorage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearTexImage")) |proc| {
function_pointers.glClearTexImage = @ptrCast(?function_signatures.glClearTexImage, proc);
} else {
log.err("entry point glClearTexImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glClearTexSubImage")) |proc| {
function_pointers.glClearTexSubImage = @ptrCast(?function_signatures.glClearTexSubImage, proc);
} else {
log.err("entry point glClearTexSubImage not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindBuffersBase")) |proc| {
function_pointers.glBindBuffersBase = @ptrCast(?function_signatures.glBindBuffersBase, proc);
} else {
log.err("entry point glBindBuffersBase not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindBuffersRange")) |proc| {
function_pointers.glBindBuffersRange = @ptrCast(?function_signatures.glBindBuffersRange, proc);
} else {
log.err("entry point glBindBuffersRange not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindTextures")) |proc| {
function_pointers.glBindTextures = @ptrCast(?function_signatures.glBindTextures, proc);
} else {
log.err("entry point glBindTextures not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindSamplers")) |proc| {
function_pointers.glBindSamplers = @ptrCast(?function_signatures.glBindSamplers, proc);
} else {
log.err("entry point glBindSamplers not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindImageTextures")) |proc| {
function_pointers.glBindImageTextures = @ptrCast(?function_signatures.glBindImageTextures, proc);
} else {
log.err("entry point glBindImageTextures not found!", .{});
success = false;
}
if (get_proc_address(load_ctx, "glBindVertexBuffers")) |proc| {
function_pointers.glBindVertexBuffers = @ptrCast(?function_signatures.glBindVertexBuffers, proc);
} else {
log.err("entry point glBindVertexBuffers not found!", .{});
success = false;
}
if (!success)
return error.EntryPointNotFound;
}
const function_signatures = struct {
const glTexStorage2D = fn (_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void;
const glTexStorage1D = fn (_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei) void;
const glDrawTransformFeedbackStreamInstanced = fn (_mode: GLenum, _id: GLuint, _stream: GLuint, _instancecount: GLsizei) void;
const glDrawTransformFeedbackInstanced = fn (_mode: GLenum, _id: GLuint, _instancecount: GLsizei) void;
const glTexStorage3D = fn (_target: GLenum, _levels: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei) void;
const glMemoryBarrier = fn (_barriers: GLbitfield) void;
const glBindImageTexture = fn (_unit: GLuint, _texture: GLuint, _level: GLint, _layered: GLboolean, _layer: GLint, _access: GLenum, _format: GLenum) void;
const glGetActiveAtomicCounterBufferiv = fn (_program: GLuint, _bufferIndex: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetInternalformativ = fn (_target: GLenum, _internalformat: GLenum, _pname: GLenum, _count: GLsizei, _params: [*c]GLint) void;
const glDrawElementsInstancedBaseVertexBaseInstance = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _basevertex: GLint, _baseinstance: GLuint) void;
const glDrawElementsInstancedBaseInstance = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _baseinstance: GLuint) void;
const glDrawArraysInstancedBaseInstance = fn (_mode: GLenum, _first: GLint, _count: GLsizei, _instancecount: GLsizei, _baseinstance: GLuint) void;
const glGetDoublei_v = fn (_target: GLenum, _index: GLuint, _data: [*c]GLdouble) void;
const glGetFloati_v = fn (_target: GLenum, _index: GLuint, _data: [*c]GLfloat) void;
const glDepthRangeIndexed = fn (_index: GLuint, _n: GLdouble, _f: GLdouble) void;
const glDepthRangeArrayv = fn (_first: GLuint, _count: GLsizei, _v: [*c]const GLdouble) void;
const glScissorIndexedv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glScissorIndexed = fn (_index: GLuint, _left: GLint, _bottom: GLint, _width: GLsizei, _height: GLsizei) void;
const glScissorArrayv = fn (_first: GLuint, _count: GLsizei, _v: [*c]const GLint) void;
const glViewportIndexedfv = fn (_index: GLuint, _v: [*c]const GLfloat) void;
const glViewportIndexedf = fn (_index: GLuint, _x: GLfloat, _y: GLfloat, _w: GLfloat, _h: GLfloat) void;
const glViewportArrayv = fn (_first: GLuint, _count: GLsizei, _v: [*c]const GLfloat) void;
const glGetVertexAttribLdv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLdouble) void;
const glVertexAttribLPointer = fn (_index: GLuint, _size: GLint, _type: GLenum, _stride: GLsizei, _pointer: ?*const anyopaque) void;
const glVertexAttribL4dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttribL3dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttribL2dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttribL1dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttribL4d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void;
const glVertexAttribL3d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void;
const glVertexAttribL2d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble) void;
const glVertexAttribL1d = fn (_index: GLuint, _x: GLdouble) void;
const glValidateProgramPipeline = fn (_pipeline: GLuint) void;
const glProgramUniformMatrix4x3dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix3x4dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix4x2dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix2x4dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix3x2dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix2x3dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix4x3fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix3x4fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix4x2fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix2x4fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix3x2fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix2x3fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix4dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix3dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix2dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glProgramUniformMatrix4fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix3fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniformMatrix2fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glProgramUniform4uiv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glProgramUniform4ui = fn (_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint, _v3: GLuint) void;
const glProgramUniform4dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glProgramUniform4d = fn (_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble, _v2: GLdouble, _v3: GLdouble) void;
const glProgramUniform4fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glProgramUniform4f = fn (_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat, _v3: GLfloat) void;
const glProgramUniform4iv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glProgramUniform4i = fn (_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint, _v2: GLint, _v3: GLint) void;
const glProgramUniform3uiv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glProgramUniform3ui = fn (_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint) void;
const glProgramUniform3dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glProgramUniform3d = fn (_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble, _v2: GLdouble) void;
const glProgramUniform3fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glProgramUniform3f = fn (_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat) void;
const glProgramUniform3iv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glProgramUniform3i = fn (_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint, _v2: GLint) void;
const glUseProgramStages = fn (_pipeline: GLuint, _stages: GLbitfield, _program: GLuint) void;
const glProgramParameteri = fn (_program: GLuint, _pname: GLenum, _value: GLint) void;
const glGetShaderPrecisionFormat = fn (_shadertype: GLenum, _precisiontype: GLenum, _range: [*c]GLint, _precision: [*c]GLint) void;
const glShaderBinary = fn (_count: GLsizei, _shaders: [*c]const GLuint, _binaryFormat: GLenum, _binary: ?*const anyopaque, _length: GLsizei) void;
const glReleaseShaderCompiler = fn () void;
const glGetQueryIndexediv = fn (_target: GLenum, _index: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glEndQueryIndexed = fn (_target: GLenum, _index: GLuint) void;
const glBeginQueryIndexed = fn (_target: GLenum, _index: GLuint, _id: GLuint) void;
const glDrawTransformFeedbackStream = fn (_mode: GLenum, _id: GLuint, _stream: GLuint) void;
const glDrawTransformFeedback = fn (_mode: GLenum, _id: GLuint) void;
const glResumeTransformFeedback = fn () void;
const glPauseTransformFeedback = fn () void;
const glGetProgramStageiv = fn (_program: GLuint, _shadertype: GLenum, _pname: GLenum, _values: [*c]GLint) void;
const glGetUniformSubroutineuiv = fn (_shadertype: GLenum, _location: GLint, _params: [*c]GLuint) void;
const glUniformSubroutinesuiv = fn (_shadertype: GLenum, _count: GLsizei, _indices: [*c]const GLuint) void;
const glGetActiveSubroutineName = fn (_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void;
const glCullFace = fn (_mode: GLenum) void;
const glFrontFace = fn (_mode: GLenum) void;
const glHint = fn (_target: GLenum, _mode: GLenum) void;
const glLineWidth = fn (_width: GLfloat) void;
const glPointSize = fn (_size: GLfloat) void;
const glPolygonMode = fn (_face: GLenum, _mode: GLenum) void;
const glScissor = fn (_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void;
const glTexParameterf = fn (_target: GLenum, _pname: GLenum, _param: GLfloat) void;
const glTexParameterfv = fn (_target: GLenum, _pname: GLenum, _params: [*c]const GLfloat) void;
const glTexParameteri = fn (_target: GLenum, _pname: GLenum, _param: GLint) void;
const glTexParameteriv = fn (_target: GLenum, _pname: GLenum, _params: [*c]const GLint) void;
const glTexImage1D = fn (_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glTexImage2D = fn (_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glDrawBuffer = fn (_buf: GLenum) void;
const glClear = fn (_mask: GLbitfield) void;
const glClearColor = fn (_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) void;
const glClearStencil = fn (_s: GLint) void;
const glClearDepth = fn (_depth: GLdouble) void;
const glStencilMask = fn (_mask: GLuint) void;
const glColorMask = fn (_red: GLboolean, _green: GLboolean, _blue: GLboolean, _alpha: GLboolean) void;
const glDepthMask = fn (_flag: GLboolean) void;
const glDisable = fn (_cap: GLenum) void;
const glEnable = fn (_cap: GLenum) void;
const glFinish = fn () void;
const glFlush = fn () void;
const glBlendFunc = fn (_sfactor: GLenum, _dfactor: GLenum) void;
const glLogicOp = fn (_opcode: GLenum) void;
const glStencilFunc = fn (_func: GLenum, _ref: GLint, _mask: GLuint) void;
const glStencilOp = fn (_fail: GLenum, _zfail: GLenum, _zpass: GLenum) void;
const glDepthFunc = fn (_func: GLenum) void;
const glPixelStoref = fn (_pname: GLenum, _param: GLfloat) void;
const glPixelStorei = fn (_pname: GLenum, _param: GLint) void;
const glReadBuffer = fn (_src: GLenum) void;
const glReadPixels = fn (_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*anyopaque) void;
const glGetBooleanv = fn (_pname: GLenum, _data: [*c]GLboolean) void;
const glGetDoublev = fn (_pname: GLenum, _data: [*c]GLdouble) void;
const glGetError = fn () GLenum;
const glGetFloatv = fn (_pname: GLenum, _data: [*c]GLfloat) void;
const glGetIntegerv = fn (_pname: GLenum, _data: [*c]GLint) void;
const glGetString = fn (_name: GLenum) ?[*:0]const GLubyte;
const glGetTexImage = fn (_target: GLenum, _level: GLint, _format: GLenum, _type: GLenum, _pixels: ?*anyopaque) void;
const glGetTexParameterfv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLfloat) void;
const glGetTexParameteriv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glGetTexLevelParameterfv = fn (_target: GLenum, _level: GLint, _pname: GLenum, _params: [*c]GLfloat) void;
const glGetTexLevelParameteriv = fn (_target: GLenum, _level: GLint, _pname: GLenum, _params: [*c]GLint) void;
const glIsEnabled = fn (_cap: GLenum) GLboolean;
const glDepthRange = fn (_n: GLdouble, _f: GLdouble) void;
const glViewport = fn (_x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void;
const glTexStorage2DMultisample = fn (_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _fixedsamplelocations: GLboolean) void;
const glTexBufferRange = fn (_target: GLenum, _internalformat: GLenum, _buffer: GLuint, _offset: GLintptr, _size: GLsizeiptr) void;
const glShaderStorageBlockBinding = fn (_program: GLuint, _storageBlockIndex: GLuint, _storageBlockBinding: GLuint) void;
const glGetProgramResourceLocationIndex = fn (_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLint;
const glGetProgramResourceLocation = fn (_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLint;
const glGetProgramResourceiv = fn (_program: GLuint, _programInterface: GLenum, _index: GLuint, _propCount: GLsizei, _props: [*c]const GLenum, _count: GLsizei, _length: [*c]GLsizei, _params: [*c]GLint) void;
const glGetProgramResourceName = fn (_program: GLuint, _programInterface: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void;
const glGetProgramResourceIndex = fn (_program: GLuint, _programInterface: GLenum, _name: [*c]const GLchar) GLuint;
const glGetProgramInterfaceiv = fn (_program: GLuint, _programInterface: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glMultiDrawElementsIndirect = fn (_mode: GLenum, _type: GLenum, _indirect: ?*const anyopaque, _drawcount: GLsizei, _stride: GLsizei) void;
const glMultiDrawArraysIndirect = fn (_mode: GLenum, _indirect: ?*const anyopaque, _drawcount: GLsizei, _stride: GLsizei) void;
const glInvalidateSubFramebuffer = fn (_target: GLenum, _numAttachments: GLsizei, _attachments: [*c]const GLenum, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void;
const glInvalidateFramebuffer = fn (_target: GLenum, _numAttachments: GLsizei, _attachments: [*c]const GLenum) void;
const glInvalidateBufferData = fn (_buffer: GLuint) void;
const glInvalidateBufferSubData = fn (_buffer: GLuint, _offset: GLintptr, _length: GLsizeiptr) void;
const glInvalidateTexImage = fn (_texture: GLuint, _level: GLint) void;
const glInvalidateTexSubImage = fn (_texture: GLuint, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei) void;
const glGetInternalformati64v = fn (_target: GLenum, _internalformat: GLenum, _pname: GLenum, _count: GLsizei, _params: [*c]GLint64) void;
const glGetFramebufferParameteriv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glFramebufferParameteri = fn (_target: GLenum, _pname: GLenum, _param: GLint) void;
const glCopyImageSubData = fn (_srcName: GLuint, _srcTarget: GLenum, _srcLevel: GLint, _srcX: GLint, _srcY: GLint, _srcZ: GLint, _dstName: GLuint, _dstTarget: GLenum, _dstLevel: GLint, _dstX: GLint, _dstY: GLint, _dstZ: GLint, _srcWidth: GLsizei, _srcHeight: GLsizei, _srcDepth: GLsizei) void;
const glDispatchComputeIndirect = fn (_indirect: GLintptr) void;
const glDispatchCompute = fn (_num_groups_x: GLuint, _num_groups_y: GLuint, _num_groups_z: GLuint) void;
const glClearBufferSubData = fn (_target: GLenum, _internalformat: GLenum, _offset: GLintptr, _size: GLsizeiptr, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void;
const glClearBufferData = fn (_target: GLenum, _internalformat: GLenum, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void;
const glGetProgramPipelineInfoLog = fn (_pipeline: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void;
const glProgramUniform2uiv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glProgramUniform2ui = fn (_program: GLuint, _location: GLint, _v0: GLuint, _v1: GLuint) void;
const glProgramUniform2dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glProgramUniform2d = fn (_program: GLuint, _location: GLint, _v0: GLdouble, _v1: GLdouble) void;
const glProgramUniform2fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glProgramUniform2f = fn (_program: GLuint, _location: GLint, _v0: GLfloat, _v1: GLfloat) void;
const glProgramUniform2iv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glProgramUniform2i = fn (_program: GLuint, _location: GLint, _v0: GLint, _v1: GLint) void;
const glProgramUniform1uiv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glProgramUniform1ui = fn (_program: GLuint, _location: GLint, _v0: GLuint) void;
const glProgramUniform1dv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glProgramUniform1d = fn (_program: GLuint, _location: GLint, _v0: GLdouble) void;
const glProgramUniform1fv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glProgramUniform1f = fn (_program: GLuint, _location: GLint, _v0: GLfloat) void;
const glProgramUniform1iv = fn (_program: GLuint, _location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glProgramUniform1i = fn (_program: GLuint, _location: GLint, _v0: GLint) void;
const glGetProgramPipelineiv = fn (_pipeline: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glIsProgramPipeline = fn (_pipeline: GLuint) GLboolean;
const glGenProgramPipelines = fn (_n: GLsizei, _pipelines: [*c]GLuint) void;
const glDeleteProgramPipelines = fn (_n: GLsizei, _pipelines: [*c]const GLuint) void;
const glBindProgramPipeline = fn (_pipeline: GLuint) void;
const glCreateShaderProgramv = fn (_type: GLenum, _count: GLsizei, _strings: [*c]const [*c]const GLchar) GLuint;
const glActiveShaderProgram = fn (_pipeline: GLuint, _program: GLuint) void;
const glProgramBinary = fn (_program: GLuint, _binaryFormat: GLenum, _binary: ?*const anyopaque, _length: GLsizei) void;
const glGetProgramBinary = fn (_program: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _binaryFormat: [*c]GLenum, _binary: ?*anyopaque) void;
const glClearDepthf = fn (_d: GLfloat) void;
const glDepthRangef = fn (_n: GLfloat, _f: GLfloat) void;
const glIsTransformFeedback = fn (_id: GLuint) GLboolean;
const glGenTransformFeedbacks = fn (_n: GLsizei, _ids: [*c]GLuint) void;
const glDeleteTransformFeedbacks = fn (_n: GLsizei, _ids: [*c]const GLuint) void;
const glBindTransformFeedback = fn (_target: GLenum, _id: GLuint) void;
const glPatchParameterfv = fn (_pname: GLenum, _values: [*c]const GLfloat) void;
const glPatchParameteri = fn (_pname: GLenum, _value: GLint) void;
const glDrawArrays = fn (_mode: GLenum, _first: GLint, _count: GLsizei) void;
const glDrawElements = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque) void;
const glPolygonOffset = fn (_factor: GLfloat, _units: GLfloat) void;
const glCopyTexImage1D = fn (_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _border: GLint) void;
const glCopyTexImage2D = fn (_target: GLenum, _level: GLint, _internalformat: GLenum, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei, _border: GLint) void;
const glCopyTexSubImage1D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei) void;
const glCopyTexSubImage2D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void;
const glTexSubImage1D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glTexSubImage2D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glBindTexture = fn (_target: GLenum, _texture: GLuint) void;
const glDeleteTextures = fn (_n: GLsizei, _textures: [*c]const GLuint) void;
const glGenTextures = fn (_n: GLsizei, _textures: [*c]GLuint) void;
const glIsTexture = fn (_texture: GLuint) GLboolean;
const glGetActiveSubroutineUniformName = fn (_program: GLuint, _shadertype: GLenum, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _name: [*c]GLchar) void;
const glGetActiveSubroutineUniformiv = fn (_program: GLuint, _shadertype: GLenum, _index: GLuint, _pname: GLenum, _values: [*c]GLint) void;
const glGetSubroutineIndex = fn (_program: GLuint, _shadertype: GLenum, _name: [*c]const GLchar) GLuint;
const glGetSubroutineUniformLocation = fn (_program: GLuint, _shadertype: GLenum, _name: [*c]const GLchar) GLint;
const glGetUniformdv = fn (_program: GLuint, _location: GLint, _params: [*c]GLdouble) void;
const glUniformMatrix4x3dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix4x2dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix3x4dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix3x2dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix2x4dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix2x3dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix4dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniformMatrix3dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glDrawRangeElements = fn (_mode: GLenum, _start: GLuint, _end: GLuint, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque) void;
const glTexImage3D = fn (_target: GLenum, _level: GLint, _internalformat: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glTexSubImage3D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _type: GLenum, _pixels: ?*const anyopaque) void;
const glCopyTexSubImage3D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _x: GLint, _y: GLint, _width: GLsizei, _height: GLsizei) void;
const glUniformMatrix2dv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLdouble) void;
const glUniform4dv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glUniform3dv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glUniform2dv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glUniform1dv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLdouble) void;
const glUniform4d = fn (_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void;
const glUniform3d = fn (_location: GLint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void;
const glUniform2d = fn (_location: GLint, _x: GLdouble, _y: GLdouble) void;
const glUniform1d = fn (_location: GLint, _x: GLdouble) void;
const glDrawElementsIndirect = fn (_mode: GLenum, _type: GLenum, _indirect: ?*const anyopaque) void;
const glDrawArraysIndirect = fn (_mode: GLenum, _indirect: ?*const anyopaque) void;
const glBlendFuncSeparatei = fn (_buf: GLuint, _srcRGB: GLenum, _dstRGB: GLenum, _srcAlpha: GLenum, _dstAlpha: GLenum) void;
const glBlendFunci = fn (_buf: GLuint, _src: GLenum, _dst: GLenum) void;
const glBlendEquationSeparatei = fn (_buf: GLuint, _modeRGB: GLenum, _modeAlpha: GLenum) void;
const glBlendEquationi = fn (_buf: GLuint, _mode: GLenum) void;
const glMinSampleShading = fn (_value: GLfloat) void;
const glActiveTexture = fn (_texture: GLenum) void;
const glSampleCoverage = fn (_value: GLfloat, _invert: GLboolean) void;
const glCompressedTexImage3D = fn (_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glCompressedTexImage2D = fn (_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glCompressedTexImage1D = fn (_target: GLenum, _level: GLint, _internalformat: GLenum, _width: GLsizei, _border: GLint, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glCompressedTexSubImage3D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glCompressedTexSubImage2D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _yoffset: GLint, _width: GLsizei, _height: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glCompressedTexSubImage1D = fn (_target: GLenum, _level: GLint, _xoffset: GLint, _width: GLsizei, _format: GLenum, _imageSize: GLsizei, _data: ?*const anyopaque) void;
const glGetCompressedTexImage = fn (_target: GLenum, _level: GLint, _img: ?*anyopaque) void;
const glVertexAttribP4uiv = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void;
const glVertexAttribP4ui = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void;
const glVertexAttribP3uiv = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void;
const glVertexAttribP3ui = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void;
const glVertexAttribP2uiv = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void;
const glVertexAttribP2ui = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void;
const glVertexAttribP1uiv = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: [*c]const GLuint) void;
const glVertexAttribP1ui = fn (_index: GLuint, _type: GLenum, _normalized: GLboolean, _value: GLuint) void;
const glVertexAttribDivisor = fn (_index: GLuint, _divisor: GLuint) void;
const glGetQueryObjectui64v = fn (_id: GLuint, _pname: GLenum, _params: [*c]GLuint64) void;
const glGetQueryObjecti64v = fn (_id: GLuint, _pname: GLenum, _params: [*c]GLint64) void;
const glQueryCounter = fn (_id: GLuint, _target: GLenum) void;
const glGetSamplerParameterIuiv = fn (_sampler: GLuint, _pname: GLenum, _params: [*c]GLuint) void;
const glGetSamplerParameterfv = fn (_sampler: GLuint, _pname: GLenum, _params: [*c]GLfloat) void;
const glGetSamplerParameterIiv = fn (_sampler: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetSamplerParameteriv = fn (_sampler: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glSamplerParameterIuiv = fn (_sampler: GLuint, _pname: GLenum, _param: [*c]const GLuint) void;
const glSamplerParameterIiv = fn (_sampler: GLuint, _pname: GLenum, _param: [*c]const GLint) void;
const glSamplerParameterfv = fn (_sampler: GLuint, _pname: GLenum, _param: [*c]const GLfloat) void;
const glSamplerParameterf = fn (_sampler: GLuint, _pname: GLenum, _param: GLfloat) void;
const glSamplerParameteriv = fn (_sampler: GLuint, _pname: GLenum, _param: [*c]const GLint) void;
const glSamplerParameteri = fn (_sampler: GLuint, _pname: GLenum, _param: GLint) void;
const glBindSampler = fn (_unit: GLuint, _sampler: GLuint) void;
const glIsSampler = fn (_sampler: GLuint) GLboolean;
const glDeleteSamplers = fn (_count: GLsizei, _samplers: [*c]const GLuint) void;
const glGenSamplers = fn (_count: GLsizei, _samplers: [*c]GLuint) void;
const glGetFragDataIndex = fn (_program: GLuint, _name: [*c]const GLchar) GLint;
const glBindFragDataLocationIndexed = fn (_program: GLuint, _colorNumber: GLuint, _index: GLuint, _name: [*c]const GLchar) void;
const glSampleMaski = fn (_maskNumber: GLuint, _mask: GLbitfield) void;
const glGetMultisamplefv = fn (_pname: GLenum, _index: GLuint, _val: [*c]GLfloat) void;
const glTexImage3DMultisample = fn (_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _fixedsamplelocations: GLboolean) void;
const glTexImage2DMultisample = fn (_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _fixedsamplelocations: GLboolean) void;
const glFramebufferTexture = fn (_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint) void;
const glGetBufferParameteri64v = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint64) void;
const glBlendFuncSeparate = fn (_sfactorRGB: GLenum, _dfactorRGB: GLenum, _sfactorAlpha: GLenum, _dfactorAlpha: GLenum) void;
const glMultiDrawArrays = fn (_mode: GLenum, _first: [*c]const GLint, _count: [*c]const GLsizei, _drawcount: GLsizei) void;
const glMultiDrawElements = fn (_mode: GLenum, _count: [*c]const GLsizei, _type: GLenum, _indices: [*c]const ?*const anyopaque, _drawcount: GLsizei) void;
const glPointParameterf = fn (_pname: GLenum, _param: GLfloat) void;
const glPointParameterfv = fn (_pname: GLenum, _params: [*c]const GLfloat) void;
const glPointParameteri = fn (_pname: GLenum, _param: GLint) void;
const glPointParameteriv = fn (_pname: GLenum, _params: [*c]const GLint) void;
const glGetInteger64i_v = fn (_target: GLenum, _index: GLuint, _data: [*c]GLint64) void;
const glGetSynciv = fn (_sync: GLsync, _pname: GLenum, _count: GLsizei, _length: [*c]GLsizei, _values: [*c]GLint) void;
const glGetInteger64v = fn (_pname: GLenum, _data: [*c]GLint64) void;
const glWaitSync = fn (_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) void;
const glClientWaitSync = fn (_sync: GLsync, _flags: GLbitfield, _timeout: GLuint64) GLenum;
const glDeleteSync = fn (_sync: GLsync) void;
const glIsSync = fn (_sync: GLsync) GLboolean;
const glFenceSync = fn (_condition: GLenum, _flags: GLbitfield) GLsync;
const glBlendColor = fn (_red: GLfloat, _green: GLfloat, _blue: GLfloat, _alpha: GLfloat) void;
const glBlendEquation = fn (_mode: GLenum) void;
const glProvokingVertex = fn (_mode: GLenum) void;
const glMultiDrawElementsBaseVertex = fn (_mode: GLenum, _count: [*c]const GLsizei, _type: GLenum, _indices: [*c]const ?*const anyopaque, _drawcount: GLsizei, _basevertex: [*c]const GLint) void;
const glDrawElementsInstancedBaseVertex = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei, _basevertex: GLint) void;
const glDrawRangeElementsBaseVertex = fn (_mode: GLenum, _start: GLuint, _end: GLuint, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _basevertex: GLint) void;
const glDrawElementsBaseVertex = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _basevertex: GLint) void;
const glGenQueries = fn (_n: GLsizei, _ids: [*c]GLuint) void;
const glDeleteQueries = fn (_n: GLsizei, _ids: [*c]const GLuint) void;
const glIsQuery = fn (_id: GLuint) GLboolean;
const glBeginQuery = fn (_target: GLenum, _id: GLuint) void;
const glEndQuery = fn (_target: GLenum) void;
const glGetQueryiv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glGetQueryObjectiv = fn (_id: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetQueryObjectuiv = fn (_id: GLuint, _pname: GLenum, _params: [*c]GLuint) void;
const glBindBuffer = fn (_target: GLenum, _buffer: GLuint) void;
const glDeleteBuffers = fn (_n: GLsizei, _buffers: [*c]const GLuint) void;
const glGenBuffers = fn (_n: GLsizei, _buffers: [*c]GLuint) void;
const glIsBuffer = fn (_buffer: GLuint) GLboolean;
const glBufferData = fn (_target: GLenum, _size: GLsizeiptr, _data: ?*const anyopaque, _usage: GLenum) void;
const glBufferSubData = fn (_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: ?*const anyopaque) void;
const glGetBufferSubData = fn (_target: GLenum, _offset: GLintptr, _size: GLsizeiptr, _data: ?*anyopaque) void;
const glMapBuffer = fn (_target: GLenum, _access: GLenum) ?*anyopaque;
const glUnmapBuffer = fn (_target: GLenum) GLboolean;
const glGetBufferParameteriv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glGetBufferPointerv = fn (_target: GLenum, _pname: GLenum, _params: ?*?*anyopaque) void;
const glBlendEquationSeparate = fn (_modeRGB: GLenum, _modeAlpha: GLenum) void;
const glDrawBuffers = fn (_n: GLsizei, _bufs: [*c]const GLenum) void;
const glStencilOpSeparate = fn (_face: GLenum, _sfail: GLenum, _dpfail: GLenum, _dppass: GLenum) void;
const glStencilFuncSeparate = fn (_face: GLenum, _func: GLenum, _ref: GLint, _mask: GLuint) void;
const glStencilMaskSeparate = fn (_face: GLenum, _mask: GLuint) void;
const glAttachShader = fn (_program: GLuint, _shader: GLuint) void;
const glBindAttribLocation = fn (_program: GLuint, _index: GLuint, _name: [*c]const GLchar) void;
const glCompileShader = fn (_shader: GLuint) void;
const glCreateProgram = fn () GLuint;
const glCreateShader = fn (_type: GLenum) GLuint;
const glDeleteProgram = fn (_program: GLuint) void;
const glDeleteShader = fn (_shader: GLuint) void;
const glDetachShader = fn (_program: GLuint, _shader: GLuint) void;
const glDisableVertexAttribArray = fn (_index: GLuint) void;
const glEnableVertexAttribArray = fn (_index: GLuint) void;
const glGetActiveAttrib = fn (_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLint, _type: [*c]GLenum, _name: [*c]GLchar) void;
const glGetActiveUniform = fn (_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLint, _type: [*c]GLenum, _name: [*c]GLchar) void;
const glGetAttachedShaders = fn (_program: GLuint, _maxCount: GLsizei, _count: [*c]GLsizei, _shaders: [*c]GLuint) void;
const glGetAttribLocation = fn (_program: GLuint, _name: [*c]const GLchar) GLint;
const glGetProgramiv = fn (_program: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetProgramInfoLog = fn (_program: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void;
const glGetShaderiv = fn (_shader: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetShaderInfoLog = fn (_shader: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _infoLog: [*c]GLchar) void;
const glGetShaderSource = fn (_shader: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _source: [*c]GLchar) void;
const glGetUniformLocation = fn (_program: GLuint, _name: [*c]const GLchar) GLint;
const glGetUniformfv = fn (_program: GLuint, _location: GLint, _params: [*c]GLfloat) void;
const glGetUniformiv = fn (_program: GLuint, _location: GLint, _params: [*c]GLint) void;
const glGetVertexAttribdv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLdouble) void;
const glGetVertexAttribfv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLfloat) void;
const glGetVertexAttribiv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetVertexAttribPointerv = fn (_index: GLuint, _pname: GLenum, _pointer: ?*?*anyopaque) void;
const glIsProgram = fn (_program: GLuint) GLboolean;
const glIsShader = fn (_shader: GLuint) GLboolean;
const glLinkProgram = fn (_program: GLuint) void;
const glShaderSource = fn (_shader: GLuint, _count: GLsizei, _string: [*c]const [*c]const GLchar, _length: [*c]const GLint) void;
const glUseProgram = fn (_program: GLuint) void;
const glUniform1f = fn (_location: GLint, _v0: GLfloat) void;
const glUniform2f = fn (_location: GLint, _v0: GLfloat, _v1: GLfloat) void;
const glUniform3f = fn (_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat) void;
const glUniform4f = fn (_location: GLint, _v0: GLfloat, _v1: GLfloat, _v2: GLfloat, _v3: GLfloat) void;
const glUniform1i = fn (_location: GLint, _v0: GLint) void;
const glUniform2i = fn (_location: GLint, _v0: GLint, _v1: GLint) void;
const glUniform3i = fn (_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint) void;
const glUniform4i = fn (_location: GLint, _v0: GLint, _v1: GLint, _v2: GLint, _v3: GLint) void;
const glUniform1fv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glUniform2fv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glUniform3fv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glUniform4fv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLfloat) void;
const glUniform1iv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glUniform2iv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glUniform3iv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glUniform4iv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLint) void;
const glUniformMatrix2fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix3fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix4fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glValidateProgram = fn (_program: GLuint) void;
const glVertexAttrib1d = fn (_index: GLuint, _x: GLdouble) void;
const glVertexAttrib1dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttrib1f = fn (_index: GLuint, _x: GLfloat) void;
const glVertexAttrib1fv = fn (_index: GLuint, _v: [*c]const GLfloat) void;
const glVertexAttrib1s = fn (_index: GLuint, _x: GLshort) void;
const glVertexAttrib1sv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttrib2d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble) void;
const glVertexAttrib2dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttrib2f = fn (_index: GLuint, _x: GLfloat, _y: GLfloat) void;
const glVertexAttrib2fv = fn (_index: GLuint, _v: [*c]const GLfloat) void;
const glVertexAttrib2s = fn (_index: GLuint, _x: GLshort, _y: GLshort) void;
const glVertexAttrib2sv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttrib3d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble) void;
const glVertexAttrib3dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttrib3f = fn (_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat) void;
const glVertexAttrib3fv = fn (_index: GLuint, _v: [*c]const GLfloat) void;
const glVertexAttrib3s = fn (_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort) void;
const glVertexAttrib3sv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttrib4Nbv = fn (_index: GLuint, _v: [*c]const GLbyte) void;
const glVertexAttrib4Niv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttrib4Nsv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttrib4Nub = fn (_index: GLuint, _x: GLubyte, _y: GLubyte, _z: GLubyte, _w: GLubyte) void;
const glVertexAttrib4Nubv = fn (_index: GLuint, _v: ?[*:0]const GLubyte) void;
const glVertexAttrib4Nuiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttrib4Nusv = fn (_index: GLuint, _v: [*c]const GLushort) void;
const glVertexAttrib4bv = fn (_index: GLuint, _v: [*c]const GLbyte) void;
const glVertexAttrib4d = fn (_index: GLuint, _x: GLdouble, _y: GLdouble, _z: GLdouble, _w: GLdouble) void;
const glVertexAttrib4dv = fn (_index: GLuint, _v: [*c]const GLdouble) void;
const glVertexAttrib4f = fn (_index: GLuint, _x: GLfloat, _y: GLfloat, _z: GLfloat, _w: GLfloat) void;
const glVertexAttrib4fv = fn (_index: GLuint, _v: [*c]const GLfloat) void;
const glVertexAttrib4iv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttrib4s = fn (_index: GLuint, _x: GLshort, _y: GLshort, _z: GLshort, _w: GLshort) void;
const glVertexAttrib4sv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttrib4ubv = fn (_index: GLuint, _v: ?[*:0]const GLubyte) void;
const glVertexAttrib4uiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttrib4usv = fn (_index: GLuint, _v: [*c]const GLushort) void;
const glVertexAttribPointer = fn (_index: GLuint, _size: GLint, _type: GLenum, _normalized: GLboolean, _stride: GLsizei, _pointer: ?*const anyopaque) void;
const glUniformMatrix2x3fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix3x2fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix2x4fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix4x2fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix3x4fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glUniformMatrix4x3fv = fn (_location: GLint, _count: GLsizei, _transpose: GLboolean, _value: [*c]const GLfloat) void;
const glColorMaski = fn (_index: GLuint, _r: GLboolean, _g: GLboolean, _b: GLboolean, _a: GLboolean) void;
const glGetBooleani_v = fn (_target: GLenum, _index: GLuint, _data: [*c]GLboolean) void;
const glGetIntegeri_v = fn (_target: GLenum, _index: GLuint, _data: [*c]GLint) void;
const glEnablei = fn (_target: GLenum, _index: GLuint) void;
const glDisablei = fn (_target: GLenum, _index: GLuint) void;
const glIsEnabledi = fn (_target: GLenum, _index: GLuint) GLboolean;
const glBeginTransformFeedback = fn (_primitiveMode: GLenum) void;
const glEndTransformFeedback = fn () void;
const glBindBufferRange = fn (_target: GLenum, _index: GLuint, _buffer: GLuint, _offset: GLintptr, _size: GLsizeiptr) void;
const glBindBufferBase = fn (_target: GLenum, _index: GLuint, _buffer: GLuint) void;
const glTransformFeedbackVaryings = fn (_program: GLuint, _count: GLsizei, _varyings: [*c]const [*c]const GLchar, _bufferMode: GLenum) void;
const glGetTransformFeedbackVarying = fn (_program: GLuint, _index: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _size: [*c]GLsizei, _type: [*c]GLenum, _name: [*c]GLchar) void;
const glClampColor = fn (_target: GLenum, _clamp: GLenum) void;
const glBeginConditionalRender = fn (_id: GLuint, _mode: GLenum) void;
const glEndConditionalRender = fn () void;
const glVertexAttribIPointer = fn (_index: GLuint, _size: GLint, _type: GLenum, _stride: GLsizei, _pointer: ?*const anyopaque) void;
const glGetVertexAttribIiv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetVertexAttribIuiv = fn (_index: GLuint, _pname: GLenum, _params: [*c]GLuint) void;
const glVertexAttribI1i = fn (_index: GLuint, _x: GLint) void;
const glVertexAttribI2i = fn (_index: GLuint, _x: GLint, _y: GLint) void;
const glVertexAttribI3i = fn (_index: GLuint, _x: GLint, _y: GLint, _z: GLint) void;
const glVertexAttribI4i = fn (_index: GLuint, _x: GLint, _y: GLint, _z: GLint, _w: GLint) void;
const glVertexAttribI1ui = fn (_index: GLuint, _x: GLuint) void;
const glVertexAttribI2ui = fn (_index: GLuint, _x: GLuint, _y: GLuint) void;
const glVertexAttribI3ui = fn (_index: GLuint, _x: GLuint, _y: GLuint, _z: GLuint) void;
const glVertexAttribI4ui = fn (_index: GLuint, _x: GLuint, _y: GLuint, _z: GLuint, _w: GLuint) void;
const glVertexAttribI1iv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttribI2iv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttribI3iv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttribI4iv = fn (_index: GLuint, _v: [*c]const GLint) void;
const glVertexAttribI1uiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttribI2uiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttribI3uiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttribI4uiv = fn (_index: GLuint, _v: [*c]const GLuint) void;
const glVertexAttribI4bv = fn (_index: GLuint, _v: [*c]const GLbyte) void;
const glVertexAttribI4sv = fn (_index: GLuint, _v: [*c]const GLshort) void;
const glVertexAttribI4ubv = fn (_index: GLuint, _v: ?[*:0]const GLubyte) void;
const glVertexAttribI4usv = fn (_index: GLuint, _v: [*c]const GLushort) void;
const glGetUniformuiv = fn (_program: GLuint, _location: GLint, _params: [*c]GLuint) void;
const glBindFragDataLocation = fn (_program: GLuint, _color: GLuint, _name: [*c]const GLchar) void;
const glGetFragDataLocation = fn (_program: GLuint, _name: [*c]const GLchar) GLint;
const glUniform1ui = fn (_location: GLint, _v0: GLuint) void;
const glUniform2ui = fn (_location: GLint, _v0: GLuint, _v1: GLuint) void;
const glUniform3ui = fn (_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint) void;
const glUniform4ui = fn (_location: GLint, _v0: GLuint, _v1: GLuint, _v2: GLuint, _v3: GLuint) void;
const glUniform1uiv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glUniform2uiv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glUniform3uiv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glUniform4uiv = fn (_location: GLint, _count: GLsizei, _value: [*c]const GLuint) void;
const glTexParameterIiv = fn (_target: GLenum, _pname: GLenum, _params: [*c]const GLint) void;
const glTexParameterIuiv = fn (_target: GLenum, _pname: GLenum, _params: [*c]const GLuint) void;
const glGetTexParameterIiv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glGetTexParameterIuiv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLuint) void;
const glClearBufferiv = fn (_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLint) void;
const glClearBufferuiv = fn (_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLuint) void;
const glClearBufferfv = fn (_buffer: GLenum, _drawbuffer: GLint, _value: [*c]const GLfloat) void;
const glClearBufferfi = fn (_buffer: GLenum, _drawbuffer: GLint, _depth: GLfloat, _stencil: GLint) void;
const glGetStringi = fn (_name: GLenum, _index: GLuint) ?[*:0]const GLubyte;
const glIsRenderbuffer = fn (_renderbuffer: GLuint) GLboolean;
const glBindRenderbuffer = fn (_target: GLenum, _renderbuffer: GLuint) void;
const glDeleteRenderbuffers = fn (_n: GLsizei, _renderbuffers: [*c]const GLuint) void;
const glGenRenderbuffers = fn (_n: GLsizei, _renderbuffers: [*c]GLuint) void;
const glRenderbufferStorage = fn (_target: GLenum, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void;
const glGetRenderbufferParameteriv = fn (_target: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glIsFramebuffer = fn (_framebuffer: GLuint) GLboolean;
const glBindFramebuffer = fn (_target: GLenum, _framebuffer: GLuint) void;
const glDeleteFramebuffers = fn (_n: GLsizei, _framebuffers: [*c]const GLuint) void;
const glGenFramebuffers = fn (_n: GLsizei, _framebuffers: [*c]GLuint) void;
const glCheckFramebufferStatus = fn (_target: GLenum) GLenum;
const glFramebufferTexture1D = fn (_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) void;
const glFramebufferTexture2D = fn (_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint) void;
const glFramebufferTexture3D = fn (_target: GLenum, _attachment: GLenum, _textarget: GLenum, _texture: GLuint, _level: GLint, _zoffset: GLint) void;
const glFramebufferRenderbuffer = fn (_target: GLenum, _attachment: GLenum, _renderbuffertarget: GLenum, _renderbuffer: GLuint) void;
const glGetFramebufferAttachmentParameteriv = fn (_target: GLenum, _attachment: GLenum, _pname: GLenum, _params: [*c]GLint) void;
const glGenerateMipmap = fn (_target: GLenum) void;
const glBlitFramebuffer = fn (_srcX0: GLint, _srcY0: GLint, _srcX1: GLint, _srcY1: GLint, _dstX0: GLint, _dstY0: GLint, _dstX1: GLint, _dstY1: GLint, _mask: GLbitfield, _filter: GLenum) void;
const glRenderbufferStorageMultisample = fn (_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei) void;
const glFramebufferTextureLayer = fn (_target: GLenum, _attachment: GLenum, _texture: GLuint, _level: GLint, _layer: GLint) void;
const glMapBufferRange = fn (_target: GLenum, _offset: GLintptr, _length: GLsizeiptr, _access: GLbitfield) ?*anyopaque;
const glFlushMappedBufferRange = fn (_target: GLenum, _offset: GLintptr, _length: GLsizeiptr) void;
const glBindVertexArray = fn (_array: GLuint) void;
const glDeleteVertexArrays = fn (_n: GLsizei, _arrays: [*c]const GLuint) void;
const glGenVertexArrays = fn (_n: GLsizei, _arrays: [*c]GLuint) void;
const glIsVertexArray = fn (_array: GLuint) GLboolean;
const glDrawArraysInstanced = fn (_mode: GLenum, _first: GLint, _count: GLsizei, _instancecount: GLsizei) void;
const glDrawElementsInstanced = fn (_mode: GLenum, _count: GLsizei, _type: GLenum, _indices: ?*const anyopaque, _instancecount: GLsizei) void;
const glTexBuffer = fn (_target: GLenum, _internalformat: GLenum, _buffer: GLuint) void;
const glPrimitiveRestartIndex = fn (_index: GLuint) void;
const glCopyBufferSubData = fn (_readTarget: GLenum, _writeTarget: GLenum, _readOffset: GLintptr, _writeOffset: GLintptr, _size: GLsizeiptr) void;
const glGetUniformIndices = fn (_program: GLuint, _uniformCount: GLsizei, _uniformNames: [*c]const [*c]const GLchar, _uniformIndices: [*c]GLuint) void;
const glGetActiveUniformsiv = fn (_program: GLuint, _uniformCount: GLsizei, _uniformIndices: [*c]const GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetActiveUniformName = fn (_program: GLuint, _uniformIndex: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _uniformName: [*c]GLchar) void;
const glGetUniformBlockIndex = fn (_program: GLuint, _uniformBlockName: [*c]const GLchar) GLuint;
const glGetActiveUniformBlockiv = fn (_program: GLuint, _uniformBlockIndex: GLuint, _pname: GLenum, _params: [*c]GLint) void;
const glGetActiveUniformBlockName = fn (_program: GLuint, _uniformBlockIndex: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _uniformBlockName: [*c]GLchar) void;
const glUniformBlockBinding = fn (_program: GLuint, _uniformBlockIndex: GLuint, _uniformBlockBinding: GLuint) void;
const glTexStorage3DMultisample = fn (_target: GLenum, _samples: GLsizei, _internalformat: GLenum, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _fixedsamplelocations: GLboolean) void;
const glTextureView = fn (_texture: GLuint, _target: GLenum, _origtexture: GLuint, _internalformat: GLenum, _minlevel: GLuint, _numlevels: GLuint, _minlayer: GLuint, _numlayers: GLuint) void;
const glBindVertexBuffer = fn (_bindingindex: GLuint, _buffer: GLuint, _offset: GLintptr, _stride: GLsizei) void;
const glVertexAttribFormat = fn (_attribindex: GLuint, _size: GLint, _type: GLenum, _normalized: GLboolean, _relativeoffset: GLuint) void;
const glVertexAttribIFormat = fn (_attribindex: GLuint, _size: GLint, _type: GLenum, _relativeoffset: GLuint) void;
const glVertexAttribLFormat = fn (_attribindex: GLuint, _size: GLint, _type: GLenum, _relativeoffset: GLuint) void;
const glVertexAttribBinding = fn (_attribindex: GLuint, _bindingindex: GLuint) void;
const glVertexBindingDivisor = fn (_bindingindex: GLuint, _divisor: GLuint) void;
const glDebugMessageControl = fn (_source: GLenum, _type: GLenum, _severity: GLenum, _count: GLsizei, _ids: [*c]const GLuint, _enabled: GLboolean) void;
const glDebugMessageInsert = fn (_source: GLenum, _type: GLenum, _id: GLuint, _severity: GLenum, _length: GLsizei, _buf: [*c]const GLchar) void;
const glDebugMessageCallback = fn (_callback: GLDEBUGPROC, _userParam: ?*const anyopaque) void;
const glGetDebugMessageLog = fn (_count: GLuint, _bufSize: GLsizei, _sources: [*c]GLenum, _types: [*c]GLenum, _ids: [*c]GLuint, _severities: [*c]GLenum, _lengths: [*c]GLsizei, _messageLog: [*c]GLchar) GLuint;
const glPushDebugGroup = fn (_source: GLenum, _id: GLuint, _length: GLsizei, _message: [*c]const GLchar) void;
const glPopDebugGroup = fn () void;
const glObjectLabel = fn (_identifier: GLenum, _name: GLuint, _length: GLsizei, _label: [*c]const GLchar) void;
const glGetObjectLabel = fn (_identifier: GLenum, _name: GLuint, _bufSize: GLsizei, _length: [*c]GLsizei, _label: [*c]GLchar) void;
const glObjectPtrLabel = fn (_ptr: ?*const anyopaque, _length: GLsizei, _label: [*c]const GLchar) void;
const glGetObjectPtrLabel = fn (_ptr: ?*const anyopaque, _bufSize: GLsizei, _length: [*c]GLsizei, _label: [*c]GLchar) void;
const glGetPointerv = fn (_pname: GLenum, _params: ?*?*anyopaque) void;
const glBufferStorage = fn (_target: GLenum, _size: GLsizeiptr, _data: ?*const anyopaque, _flags: GLbitfield) void;
const glClearTexImage = fn (_texture: GLuint, _level: GLint, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void;
const glClearTexSubImage = fn (_texture: GLuint, _level: GLint, _xoffset: GLint, _yoffset: GLint, _zoffset: GLint, _width: GLsizei, _height: GLsizei, _depth: GLsizei, _format: GLenum, _type: GLenum, _data: ?*const anyopaque) void;
const glBindBuffersBase = fn (_target: GLenum, _first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint) void;
const glBindBuffersRange = fn (_target: GLenum, _first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint, _offsets: [*c]const GLintptr, _sizes: [*c]const GLsizeiptr) void;
const glBindTextures = fn (_first: GLuint, _count: GLsizei, _textures: [*c]const GLuint) void;
const glBindSamplers = fn (_first: GLuint, _count: GLsizei, _samplers: [*c]const GLuint) void;
const glBindImageTextures = fn (_first: GLuint, _count: GLsizei, _textures: [*c]const GLuint) void;
const glBindVertexBuffers = fn (_first: GLuint, _count: GLsizei, _buffers: [*c]const GLuint, _offsets: [*c]const GLintptr, _strides: [*c]const GLsizei) void;
};
const function_pointers = struct {
var glTexStorage2D: ?function_signatures.glTexStorage2D = null;
var glTexStorage1D: ?function_signatures.glTexStorage1D = null;
var glDrawTransformFeedbackStreamInstanced: ?function_signatures.glDrawTransformFeedbackStreamInstanced = null;
var glDrawTransformFeedbackInstanced: ?function_signatures.glDrawTransformFeedbackInstanced = null;
var glTexStorage3D: ?function_signatures.glTexStorage3D = null;
var glMemoryBarrier: ?function_signatures.glMemoryBarrier = null;
var glBindImageTexture: ?function_signatures.glBindImageTexture = null;
var glGetActiveAtomicCounterBufferiv: ?function_signatures.glGetActiveAtomicCounterBufferiv = null;
var glGetInternalformativ: ?function_signatures.glGetInternalformativ = null;
var glDrawElementsInstancedBaseVertexBaseInstance: ?function_signatures.glDrawElementsInstancedBaseVertexBaseInstance = null;
var glDrawElementsInstancedBaseInstance: ?function_signatures.glDrawElementsInstancedBaseInstance = null;
var glDrawArraysInstancedBaseInstance: ?function_signatures.glDrawArraysInstancedBaseInstance = null;
var glGetDoublei_v: ?function_signatures.glGetDoublei_v = null;
var glGetFloati_v: ?function_signatures.glGetFloati_v = null;
var glDepthRangeIndexed: ?function_signatures.glDepthRangeIndexed = null;
var glDepthRangeArrayv: ?function_signatures.glDepthRangeArrayv = null;
var glScissorIndexedv: ?function_signatures.glScissorIndexedv = null;
var glScissorIndexed: ?function_signatures.glScissorIndexed = null;
var glScissorArrayv: ?function_signatures.glScissorArrayv = null;
var glViewportIndexedfv: ?function_signatures.glViewportIndexedfv = null;
var glViewportIndexedf: ?function_signatures.glViewportIndexedf = null;
var glViewportArrayv: ?function_signatures.glViewportArrayv = null;
var glGetVertexAttribLdv: ?function_signatures.glGetVertexAttribLdv = null;
var glVertexAttribLPointer: ?function_signatures.glVertexAttribLPointer = null;
var glVertexAttribL4dv: ?function_signatures.glVertexAttribL4dv = null;
var glVertexAttribL3dv: ?function_signatures.glVertexAttribL3dv = null;
var glVertexAttribL2dv: ?function_signatures.glVertexAttribL2dv = null;
var glVertexAttribL1dv: ?function_signatures.glVertexAttribL1dv = null;
var glVertexAttribL4d: ?function_signatures.glVertexAttribL4d = null;
var glVertexAttribL3d: ?function_signatures.glVertexAttribL3d = null;
var glVertexAttribL2d: ?function_signatures.glVertexAttribL2d = null;
var glVertexAttribL1d: ?function_signatures.glVertexAttribL1d = null;
var glValidateProgramPipeline: ?function_signatures.glValidateProgramPipeline = null;
var glProgramUniformMatrix4x3dv: ?function_signatures.glProgramUniformMatrix4x3dv = null;
var glProgramUniformMatrix3x4dv: ?function_signatures.glProgramUniformMatrix3x4dv = null;
var glProgramUniformMatrix4x2dv: ?function_signatures.glProgramUniformMatrix4x2dv = null;
var glProgramUniformMatrix2x4dv: ?function_signatures.glProgramUniformMatrix2x4dv = null;
var glProgramUniformMatrix3x2dv: ?function_signatures.glProgramUniformMatrix3x2dv = null;
var glProgramUniformMatrix2x3dv: ?function_signatures.glProgramUniformMatrix2x3dv = null;
var glProgramUniformMatrix4x3fv: ?function_signatures.glProgramUniformMatrix4x3fv = null;
var glProgramUniformMatrix3x4fv: ?function_signatures.glProgramUniformMatrix3x4fv = null;
var glProgramUniformMatrix4x2fv: ?function_signatures.glProgramUniformMatrix4x2fv = null;
var glProgramUniformMatrix2x4fv: ?function_signatures.glProgramUniformMatrix2x4fv = null;
var glProgramUniformMatrix3x2fv: ?function_signatures.glProgramUniformMatrix3x2fv = null;
var glProgramUniformMatrix2x3fv: ?function_signatures.glProgramUniformMatrix2x3fv = null;
var glProgramUniformMatrix4dv: ?function_signatures.glProgramUniformMatrix4dv = null;
var glProgramUniformMatrix3dv: ?function_signatures.glProgramUniformMatrix3dv = null;
var glProgramUniformMatrix2dv: ?function_signatures.glProgramUniformMatrix2dv = null;
var glProgramUniformMatrix4fv: ?function_signatures.glProgramUniformMatrix4fv = null;
var glProgramUniformMatrix3fv: ?function_signatures.glProgramUniformMatrix3fv = null;
var glProgramUniformMatrix2fv: ?function_signatures.glProgramUniformMatrix2fv = null;
var glProgramUniform4uiv: ?function_signatures.glProgramUniform4uiv = null;
var glProgramUniform4ui: ?function_signatures.glProgramUniform4ui = null;
var glProgramUniform4dv: ?function_signatures.glProgramUniform4dv = null;
var glProgramUniform4d: ?function_signatures.glProgramUniform4d = null;
var glProgramUniform4fv: ?function_signatures.glProgramUniform4fv = null;
var glProgramUniform4f: ?function_signatures.glProgramUniform4f = null;
var glProgramUniform4iv: ?function_signatures.glProgramUniform4iv = null;
var glProgramUniform4i: ?function_signatures.glProgramUniform4i = null;
var glProgramUniform3uiv: ?function_signatures.glProgramUniform3uiv = null;
var glProgramUniform3ui: ?function_signatures.glProgramUniform3ui = null;
var glProgramUniform3dv: ?function_signatures.glProgramUniform3dv = null;
var glProgramUniform3d: ?function_signatures.glProgramUniform3d = null;
var glProgramUniform3fv: ?function_signatures.glProgramUniform3fv = null;
var glProgramUniform3f: ?function_signatures.glProgramUniform3f = null;
var glProgramUniform3iv: ?function_signatures.glProgramUniform3iv = null;
var glProgramUniform3i: ?function_signatures.glProgramUniform3i = null;
var glUseProgramStages: ?function_signatures.glUseProgramStages = null;
var glProgramParameteri: ?function_signatures.glProgramParameteri = null;
var glGetShaderPrecisionFormat: ?function_signatures.glGetShaderPrecisionFormat = null;
var glShaderBinary: ?function_signatures.glShaderBinary = null;
var glReleaseShaderCompiler: ?function_signatures.glReleaseShaderCompiler = null;
var glGetQueryIndexediv: ?function_signatures.glGetQueryIndexediv = null;
var glEndQueryIndexed: ?function_signatures.glEndQueryIndexed = null;
var glBeginQueryIndexed: ?function_signatures.glBeginQueryIndexed = null;
var glDrawTransformFeedbackStream: ?function_signatures.glDrawTransformFeedbackStream = null;
var glDrawTransformFeedback: ?function_signatures.glDrawTransformFeedback = null;
var glResumeTransformFeedback: ?function_signatures.glResumeTransformFeedback = null;
var glPauseTransformFeedback: ?function_signatures.glPauseTransformFeedback = null;
var glGetProgramStageiv: ?function_signatures.glGetProgramStageiv = null;
var glGetUniformSubroutineuiv: ?function_signatures.glGetUniformSubroutineuiv = null;
var glUniformSubroutinesuiv: ?function_signatures.glUniformSubroutinesuiv = null;
var glGetActiveSubroutineName: ?function_signatures.glGetActiveSubroutineName = null;
var glCullFace: ?function_signatures.glCullFace = null;
var glFrontFace: ?function_signatures.glFrontFace = null;
var glHint: ?function_signatures.glHint = null;
var glLineWidth: ?function_signatures.glLineWidth = null;
var glPointSize: ?function_signatures.glPointSize = null;
var glPolygonMode: ?function_signatures.glPolygonMode = null;
var glScissor: ?function_signatures.glScissor = null;
var glTexParameterf: ?function_signatures.glTexParameterf = null;
var glTexParameterfv: ?function_signatures.glTexParameterfv = null;
var glTexParameteri: ?function_signatures.glTexParameteri = null;
var glTexParameteriv: ?function_signatures.glTexParameteriv = null;
var glTexImage1D: ?function_signatures.glTexImage1D = null;
var glTexImage2D: ?function_signatures.glTexImage2D = null;
var glDrawBuffer: ?function_signatures.glDrawBuffer = null;
var glClear: ?function_signatures.glClear = null;
var glClearColor: ?function_signatures.glClearColor = null;
var glClearStencil: ?function_signatures.glClearStencil = null;
var glClearDepth: ?function_signatures.glClearDepth = null;
var glStencilMask: ?function_signatures.glStencilMask = null;
var glColorMask: ?function_signatures.glColorMask = null;
var glDepthMask: ?function_signatures.glDepthMask = null;
var glDisable: ?function_signatures.glDisable = null;
var glEnable: ?function_signatures.glEnable = null;
var glFinish: ?function_signatures.glFinish = null;
var glFlush: ?function_signatures.glFlush = null;
var glBlendFunc: ?function_signatures.glBlendFunc = null;
var glLogicOp: ?function_signatures.glLogicOp = null;
var glStencilFunc: ?function_signatures.glStencilFunc = null;
var glStencilOp: ?function_signatures.glStencilOp = null;
var glDepthFunc: ?function_signatures.glDepthFunc = null;
var glPixelStoref: ?function_signatures.glPixelStoref = null;
var glPixelStorei: ?function_signatures.glPixelStorei = null;
var glReadBuffer: ?function_signatures.glReadBuffer = null;
var glReadPixels: ?function_signatures.glReadPixels = null;
var glGetBooleanv: ?function_signatures.glGetBooleanv = null;
var glGetDoublev: ?function_signatures.glGetDoublev = null;
var glGetError: ?function_signatures.glGetError = null;
var glGetFloatv: ?function_signatures.glGetFloatv = null;
var glGetIntegerv: ?function_signatures.glGetIntegerv = null;
var glGetString: ?function_signatures.glGetString = null;
var glGetTexImage: ?function_signatures.glGetTexImage = null;
var glGetTexParameterfv: ?function_signatures.glGetTexParameterfv = null;
var glGetTexParameteriv: ?function_signatures.glGetTexParameteriv = null;
var glGetTexLevelParameterfv: ?function_signatures.glGetTexLevelParameterfv = null;
var glGetTexLevelParameteriv: ?function_signatures.glGetTexLevelParameteriv = null;
var glIsEnabled: ?function_signatures.glIsEnabled = null;
var glDepthRange: ?function_signatures.glDepthRange = null;
var glViewport: ?function_signatures.glViewport = null;
var glTexStorage2DMultisample: ?function_signatures.glTexStorage2DMultisample = null;
var glTexBufferRange: ?function_signatures.glTexBufferRange = null;
var glShaderStorageBlockBinding: ?function_signatures.glShaderStorageBlockBinding = null;
var glGetProgramResourceLocationIndex: ?function_signatures.glGetProgramResourceLocationIndex = null;
var glGetProgramResourceLocation: ?function_signatures.glGetProgramResourceLocation = null;
var glGetProgramResourceiv: ?function_signatures.glGetProgramResourceiv = null;
var glGetProgramResourceName: ?function_signatures.glGetProgramResourceName = null;
var glGetProgramResourceIndex: ?function_signatures.glGetProgramResourceIndex = null;
var glGetProgramInterfaceiv: ?function_signatures.glGetProgramInterfaceiv = null;
var glMultiDrawElementsIndirect: ?function_signatures.glMultiDrawElementsIndirect = null;
var glMultiDrawArraysIndirect: ?function_signatures.glMultiDrawArraysIndirect = null;
var glInvalidateSubFramebuffer: ?function_signatures.glInvalidateSubFramebuffer = null;
var glInvalidateFramebuffer: ?function_signatures.glInvalidateFramebuffer = null;
var glInvalidateBufferData: ?function_signatures.glInvalidateBufferData = null;
var glInvalidateBufferSubData: ?function_signatures.glInvalidateBufferSubData = null;
var glInvalidateTexImage: ?function_signatures.glInvalidateTexImage = null;
var glInvalidateTexSubImage: ?function_signatures.glInvalidateTexSubImage = null;
var glGetInternalformati64v: ?function_signatures.glGetInternalformati64v = null;
var glGetFramebufferParameteriv: ?function_signatures.glGetFramebufferParameteriv = null;
var glFramebufferParameteri: ?function_signatures.glFramebufferParameteri = null;
var glCopyImageSubData: ?function_signatures.glCopyImageSubData = null;
var glDispatchComputeIndirect: ?function_signatures.glDispatchComputeIndirect = null;
var glDispatchCompute: ?function_signatures.glDispatchCompute = null;
var glClearBufferSubData: ?function_signatures.glClearBufferSubData = null;
var glClearBufferData: ?function_signatures.glClearBufferData = null;
var glGetProgramPipelineInfoLog: ?function_signatures.glGetProgramPipelineInfoLog = null;
var glProgramUniform2uiv: ?function_signatures.glProgramUniform2uiv = null;
var glProgramUniform2ui: ?function_signatures.glProgramUniform2ui = null;
var glProgramUniform2dv: ?function_signatures.glProgramUniform2dv = null;
var glProgramUniform2d: ?function_signatures.glProgramUniform2d = null;
var glProgramUniform2fv: ?function_signatures.glProgramUniform2fv = null;
var glProgramUniform2f: ?function_signatures.glProgramUniform2f = null;
var glProgramUniform2iv: ?function_signatures.glProgramUniform2iv = null;
var glProgramUniform2i: ?function_signatures.glProgramUniform2i = null;
var glProgramUniform1uiv: ?function_signatures.glProgramUniform1uiv = null;
var glProgramUniform1ui: ?function_signatures.glProgramUniform1ui = null;
var glProgramUniform1dv: ?function_signatures.glProgramUniform1dv = null;
var glProgramUniform1d: ?function_signatures.glProgramUniform1d = null;
var glProgramUniform1fv: ?function_signatures.glProgramUniform1fv = null;
var glProgramUniform1f: ?function_signatures.glProgramUniform1f = null;
var glProgramUniform1iv: ?function_signatures.glProgramUniform1iv = null;
var glProgramUniform1i: ?function_signatures.glProgramUniform1i = null;
var glGetProgramPipelineiv: ?function_signatures.glGetProgramPipelineiv = null;
var glIsProgramPipeline: ?function_signatures.glIsProgramPipeline = null;
var glGenProgramPipelines: ?function_signatures.glGenProgramPipelines = null;
var glDeleteProgramPipelines: ?function_signatures.glDeleteProgramPipelines = null;
var glBindProgramPipeline: ?function_signatures.glBindProgramPipeline = null;
var glCreateShaderProgramv: ?function_signatures.glCreateShaderProgramv = null;
var glActiveShaderProgram: ?function_signatures.glActiveShaderProgram = null;
var glProgramBinary: ?function_signatures.glProgramBinary = null;
var glGetProgramBinary: ?function_signatures.glGetProgramBinary = null;
var glClearDepthf: ?function_signatures.glClearDepthf = null;
var glDepthRangef: ?function_signatures.glDepthRangef = null;
var glIsTransformFeedback: ?function_signatures.glIsTransformFeedback = null;
var glGenTransformFeedbacks: ?function_signatures.glGenTransformFeedbacks = null;
var glDeleteTransformFeedbacks: ?function_signatures.glDeleteTransformFeedbacks = null;
var glBindTransformFeedback: ?function_signatures.glBindTransformFeedback = null;
var glPatchParameterfv: ?function_signatures.glPatchParameterfv = null;
var glPatchParameteri: ?function_signatures.glPatchParameteri = null;
var glDrawArrays: ?function_signatures.glDrawArrays = null;
var glDrawElements: ?function_signatures.glDrawElements = null;
var glPolygonOffset: ?function_signatures.glPolygonOffset = null;
var glCopyTexImage1D: ?function_signatures.glCopyTexImage1D = null;
var glCopyTexImage2D: ?function_signatures.glCopyTexImage2D = null;
var glCopyTexSubImage1D: ?function_signatures.glCopyTexSubImage1D = null;
var glCopyTexSubImage2D: ?function_signatures.glCopyTexSubImage2D = null;
var glTexSubImage1D: ?function_signatures.glTexSubImage1D = null;
var glTexSubImage2D: ?function_signatures.glTexSubImage2D = null;
var glBindTexture: ?function_signatures.glBindTexture = null;
var glDeleteTextures: ?function_signatures.glDeleteTextures = null;
var glGenTextures: ?function_signatures.glGenTextures = null;
var glIsTexture: ?function_signatures.glIsTexture = null;
var glGetActiveSubroutineUniformName: ?function_signatures.glGetActiveSubroutineUniformName = null;
var glGetActiveSubroutineUniformiv: ?function_signatures.glGetActiveSubroutineUniformiv = null;
var glGetSubroutineIndex: ?function_signatures.glGetSubroutineIndex = null;
var glGetSubroutineUniformLocation: ?function_signatures.glGetSubroutineUniformLocation = null;
var glGetUniformdv: ?function_signatures.glGetUniformdv = null;
var glUniformMatrix4x3dv: ?function_signatures.glUniformMatrix4x3dv = null;
var glUniformMatrix4x2dv: ?function_signatures.glUniformMatrix4x2dv = null;
var glUniformMatrix3x4dv: ?function_signatures.glUniformMatrix3x4dv = null;
var glUniformMatrix3x2dv: ?function_signatures.glUniformMatrix3x2dv = null;
var glUniformMatrix2x4dv: ?function_signatures.glUniformMatrix2x4dv = null;
var glUniformMatrix2x3dv: ?function_signatures.glUniformMatrix2x3dv = null;
var glUniformMatrix4dv: ?function_signatures.glUniformMatrix4dv = null;
var glUniformMatrix3dv: ?function_signatures.glUniformMatrix3dv = null;
var glDrawRangeElements: ?function_signatures.glDrawRangeElements = null;
var glTexImage3D: ?function_signatures.glTexImage3D = null;
var glTexSubImage3D: ?function_signatures.glTexSubImage3D = null;
var glCopyTexSubImage3D: ?function_signatures.glCopyTexSubImage3D = null;
var glUniformMatrix2dv: ?function_signatures.glUniformMatrix2dv = null;
var glUniform4dv: ?function_signatures.glUniform4dv = null;
var glUniform3dv: ?function_signatures.glUniform3dv = null;
var glUniform2dv: ?function_signatures.glUniform2dv = null;
var glUniform1dv: ?function_signatures.glUniform1dv = null;
var glUniform4d: ?function_signatures.glUniform4d = null;
var glUniform3d: ?function_signatures.glUniform3d = null;
var glUniform2d: ?function_signatures.glUniform2d = null;
var glUniform1d: ?function_signatures.glUniform1d = null;
var glDrawElementsIndirect: ?function_signatures.glDrawElementsIndirect = null;
var glDrawArraysIndirect: ?function_signatures.glDrawArraysIndirect = null;
var glBlendFuncSeparatei: ?function_signatures.glBlendFuncSeparatei = null;
var glBlendFunci: ?function_signatures.glBlendFunci = null;
var glBlendEquationSeparatei: ?function_signatures.glBlendEquationSeparatei = null;
var glBlendEquationi: ?function_signatures.glBlendEquationi = null;
var glMinSampleShading: ?function_signatures.glMinSampleShading = null;
var glActiveTexture: ?function_signatures.glActiveTexture = null;
var glSampleCoverage: ?function_signatures.glSampleCoverage = null;
var glCompressedTexImage3D: ?function_signatures.glCompressedTexImage3D = null;
var glCompressedTexImage2D: ?function_signatures.glCompressedTexImage2D = null;
var glCompressedTexImage1D: ?function_signatures.glCompressedTexImage1D = null;
var glCompressedTexSubImage3D: ?function_signatures.glCompressedTexSubImage3D = null;
var glCompressedTexSubImage2D: ?function_signatures.glCompressedTexSubImage2D = null;
var glCompressedTexSubImage1D: ?function_signatures.glCompressedTexSubImage1D = null;
var glGetCompressedTexImage: ?function_signatures.glGetCompressedTexImage = null;
var glVertexAttribP4uiv: ?function_signatures.glVertexAttribP4uiv = null;
var glVertexAttribP4ui: ?function_signatures.glVertexAttribP4ui = null;
var glVertexAttribP3uiv: ?function_signatures.glVertexAttribP3uiv = null;
var glVertexAttribP3ui: ?function_signatures.glVertexAttribP3ui = null;
var glVertexAttribP2uiv: ?function_signatures.glVertexAttribP2uiv = null;
var glVertexAttribP2ui: ?function_signatures.glVertexAttribP2ui = null;
var glVertexAttribP1uiv: ?function_signatures.glVertexAttribP1uiv = null;
var glVertexAttribP1ui: ?function_signatures.glVertexAttribP1ui = null;
var glVertexAttribDivisor: ?function_signatures.glVertexAttribDivisor = null;
var glGetQueryObjectui64v: ?function_signatures.glGetQueryObjectui64v = null;
var glGetQueryObjecti64v: ?function_signatures.glGetQueryObjecti64v = null;
var glQueryCounter: ?function_signatures.glQueryCounter = null;
var glGetSamplerParameterIuiv: ?function_signatures.glGetSamplerParameterIuiv = null;
var glGetSamplerParameterfv: ?function_signatures.glGetSamplerParameterfv = null;
var glGetSamplerParameterIiv: ?function_signatures.glGetSamplerParameterIiv = null;
var glGetSamplerParameteriv: ?function_signatures.glGetSamplerParameteriv = null;
var glSamplerParameterIuiv: ?function_signatures.glSamplerParameterIuiv = null;
var glSamplerParameterIiv: ?function_signatures.glSamplerParameterIiv = null;
var glSamplerParameterfv: ?function_signatures.glSamplerParameterfv = null;
var glSamplerParameterf: ?function_signatures.glSamplerParameterf = null;
var glSamplerParameteriv: ?function_signatures.glSamplerParameteriv = null;
var glSamplerParameteri: ?function_signatures.glSamplerParameteri = null;
var glBindSampler: ?function_signatures.glBindSampler = null;
var glIsSampler: ?function_signatures.glIsSampler = null;
var glDeleteSamplers: ?function_signatures.glDeleteSamplers = null;
var glGenSamplers: ?function_signatures.glGenSamplers = null;
var glGetFragDataIndex: ?function_signatures.glGetFragDataIndex = null;
var glBindFragDataLocationIndexed: ?function_signatures.glBindFragDataLocationIndexed = null;
var glSampleMaski: ?function_signatures.glSampleMaski = null;
var glGetMultisamplefv: ?function_signatures.glGetMultisamplefv = null;
var glTexImage3DMultisample: ?function_signatures.glTexImage3DMultisample = null;
var glTexImage2DMultisample: ?function_signatures.glTexImage2DMultisample = null;
var glFramebufferTexture: ?function_signatures.glFramebufferTexture = null;
var glGetBufferParameteri64v: ?function_signatures.glGetBufferParameteri64v = null;
var glBlendFuncSeparate: ?function_signatures.glBlendFuncSeparate = null;
var glMultiDrawArrays: ?function_signatures.glMultiDrawArrays = null;
var glMultiDrawElements: ?function_signatures.glMultiDrawElements = null;
var glPointParameterf: ?function_signatures.glPointParameterf = null;
var glPointParameterfv: ?function_signatures.glPointParameterfv = null;
var glPointParameteri: ?function_signatures.glPointParameteri = null;
var glPointParameteriv: ?function_signatures.glPointParameteriv = null;
var glGetInteger64i_v: ?function_signatures.glGetInteger64i_v = null;
var glGetSynciv: ?function_signatures.glGetSynciv = null;
var glGetInteger64v: ?function_signatures.glGetInteger64v = null;
var glWaitSync: ?function_signatures.glWaitSync = null;
var glClientWaitSync: ?function_signatures.glClientWaitSync = null;
var glDeleteSync: ?function_signatures.glDeleteSync = null;
var glIsSync: ?function_signatures.glIsSync = null;
var glFenceSync: ?function_signatures.glFenceSync = null;
var glBlendColor: ?function_signatures.glBlendColor = null;
var glBlendEquation: ?function_signatures.glBlendEquation = null;
var glProvokingVertex: ?function_signatures.glProvokingVertex = null;
var glMultiDrawElementsBaseVertex: ?function_signatures.glMultiDrawElementsBaseVertex = null;
var glDrawElementsInstancedBaseVertex: ?function_signatures.glDrawElementsInstancedBaseVertex = null;
var glDrawRangeElementsBaseVertex: ?function_signatures.glDrawRangeElementsBaseVertex = null;
var glDrawElementsBaseVertex: ?function_signatures.glDrawElementsBaseVertex = null;
var glGenQueries: ?function_signatures.glGenQueries = null;
var glDeleteQueries: ?function_signatures.glDeleteQueries = null;
var glIsQuery: ?function_signatures.glIsQuery = null;
var glBeginQuery: ?function_signatures.glBeginQuery = null;
var glEndQuery: ?function_signatures.glEndQuery = null;
var glGetQueryiv: ?function_signatures.glGetQueryiv = null;
var glGetQueryObjectiv: ?function_signatures.glGetQueryObjectiv = null;
var glGetQueryObjectuiv: ?function_signatures.glGetQueryObjectuiv = null;
var glBindBuffer: ?function_signatures.glBindBuffer = null;
var glDeleteBuffers: ?function_signatures.glDeleteBuffers = null;
var glGenBuffers: ?function_signatures.glGenBuffers = null;
var glIsBuffer: ?function_signatures.glIsBuffer = null;
var glBufferData: ?function_signatures.glBufferData = null;
var glBufferSubData: ?function_signatures.glBufferSubData = null;
var glGetBufferSubData: ?function_signatures.glGetBufferSubData = null;
var glMapBuffer: ?function_signatures.glMapBuffer = null;
var glUnmapBuffer: ?function_signatures.glUnmapBuffer = null;
var glGetBufferParameteriv: ?function_signatures.glGetBufferParameteriv = null;
var glGetBufferPointerv: ?function_signatures.glGetBufferPointerv = null;
var glBlendEquationSeparate: ?function_signatures.glBlendEquationSeparate = null;
var glDrawBuffers: ?function_signatures.glDrawBuffers = null;
var glStencilOpSeparate: ?function_signatures.glStencilOpSeparate = null;
var glStencilFuncSeparate: ?function_signatures.glStencilFuncSeparate = null;
var glStencilMaskSeparate: ?function_signatures.glStencilMaskSeparate = null;
var glAttachShader: ?function_signatures.glAttachShader = null;
var glBindAttribLocation: ?function_signatures.glBindAttribLocation = null;
var glCompileShader: ?function_signatures.glCompileShader = null;
var glCreateProgram: ?function_signatures.glCreateProgram = null;
var glCreateShader: ?function_signatures.glCreateShader = null;
var glDeleteProgram: ?function_signatures.glDeleteProgram = null;
var glDeleteShader: ?function_signatures.glDeleteShader = null;
var glDetachShader: ?function_signatures.glDetachShader = null;
var glDisableVertexAttribArray: ?function_signatures.glDisableVertexAttribArray = null;
var glEnableVertexAttribArray: ?function_signatures.glEnableVertexAttribArray = null;
var glGetActiveAttrib: ?function_signatures.glGetActiveAttrib = null;
var glGetActiveUniform: ?function_signatures.glGetActiveUniform = null;
var glGetAttachedShaders: ?function_signatures.glGetAttachedShaders = null;
var glGetAttribLocation: ?function_signatures.glGetAttribLocation = null;
var glGetProgramiv: ?function_signatures.glGetProgramiv = null;
var glGetProgramInfoLog: ?function_signatures.glGetProgramInfoLog = null;
var glGetShaderiv: ?function_signatures.glGetShaderiv = null;
var glGetShaderInfoLog: ?function_signatures.glGetShaderInfoLog = null;
var glGetShaderSource: ?function_signatures.glGetShaderSource = null;
var glGetUniformLocation: ?function_signatures.glGetUniformLocation = null;
var glGetUniformfv: ?function_signatures.glGetUniformfv = null;
var glGetUniformiv: ?function_signatures.glGetUniformiv = null;
var glGetVertexAttribdv: ?function_signatures.glGetVertexAttribdv = null;
var glGetVertexAttribfv: ?function_signatures.glGetVertexAttribfv = null;
var glGetVertexAttribiv: ?function_signatures.glGetVertexAttribiv = null;
var glGetVertexAttribPointerv: ?function_signatures.glGetVertexAttribPointerv = null;
var glIsProgram: ?function_signatures.glIsProgram = null;
var glIsShader: ?function_signatures.glIsShader = null;
var glLinkProgram: ?function_signatures.glLinkProgram = null;
var glShaderSource: ?function_signatures.glShaderSource = null;
var glUseProgram: ?function_signatures.glUseProgram = null;
var glUniform1f: ?function_signatures.glUniform1f = null;
var glUniform2f: ?function_signatures.glUniform2f = null;
var glUniform3f: ?function_signatures.glUniform3f = null;
var glUniform4f: ?function_signatures.glUniform4f = null;
var glUniform1i: ?function_signatures.glUniform1i = null;
var glUniform2i: ?function_signatures.glUniform2i = null;
var glUniform3i: ?function_signatures.glUniform3i = null;
var glUniform4i: ?function_signatures.glUniform4i = null;
var glUniform1fv: ?function_signatures.glUniform1fv = null;
var glUniform2fv: ?function_signatures.glUniform2fv = null;
var glUniform3fv: ?function_signatures.glUniform3fv = null;
var glUniform4fv: ?function_signatures.glUniform4fv = null;
var glUniform1iv: ?function_signatures.glUniform1iv = null;
var glUniform2iv: ?function_signatures.glUniform2iv = null;
var glUniform3iv: ?function_signatures.glUniform3iv = null;
var glUniform4iv: ?function_signatures.glUniform4iv = null;
var glUniformMatrix2fv: ?function_signatures.glUniformMatrix2fv = null;
var glUniformMatrix3fv: ?function_signatures.glUniformMatrix3fv = null;
var glUniformMatrix4fv: ?function_signatures.glUniformMatrix4fv = null;
var glValidateProgram: ?function_signatures.glValidateProgram = null;
var glVertexAttrib1d: ?function_signatures.glVertexAttrib1d = null;
var glVertexAttrib1dv: ?function_signatures.glVertexAttrib1dv = null;
var glVertexAttrib1f: ?function_signatures.glVertexAttrib1f = null;
var glVertexAttrib1fv: ?function_signatures.glVertexAttrib1fv = null;
var glVertexAttrib1s: ?function_signatures.glVertexAttrib1s = null;
var glVertexAttrib1sv: ?function_signatures.glVertexAttrib1sv = null;
var glVertexAttrib2d: ?function_signatures.glVertexAttrib2d = null;
var glVertexAttrib2dv: ?function_signatures.glVertexAttrib2dv = null;
var glVertexAttrib2f: ?function_signatures.glVertexAttrib2f = null;
var glVertexAttrib2fv: ?function_signatures.glVertexAttrib2fv = null;
var glVertexAttrib2s: ?function_signatures.glVertexAttrib2s = null;
var glVertexAttrib2sv: ?function_signatures.glVertexAttrib2sv = null;
var glVertexAttrib3d: ?function_signatures.glVertexAttrib3d = null;
var glVertexAttrib3dv: ?function_signatures.glVertexAttrib3dv = null;
var glVertexAttrib3f: ?function_signatures.glVertexAttrib3f = null;
var glVertexAttrib3fv: ?function_signatures.glVertexAttrib3fv = null;
var glVertexAttrib3s: ?function_signatures.glVertexAttrib3s = null;
var glVertexAttrib3sv: ?function_signatures.glVertexAttrib3sv = null;
var glVertexAttrib4Nbv: ?function_signatures.glVertexAttrib4Nbv = null;
var glVertexAttrib4Niv: ?function_signatures.glVertexAttrib4Niv = null;
var glVertexAttrib4Nsv: ?function_signatures.glVertexAttrib4Nsv = null;
var glVertexAttrib4Nub: ?function_signatures.glVertexAttrib4Nub = null;
var glVertexAttrib4Nubv: ?function_signatures.glVertexAttrib4Nubv = null;
var glVertexAttrib4Nuiv: ?function_signatures.glVertexAttrib4Nuiv = null;
var glVertexAttrib4Nusv: ?function_signatures.glVertexAttrib4Nusv = null;
var glVertexAttrib4bv: ?function_signatures.glVertexAttrib4bv = null;
var glVertexAttrib4d: ?function_signatures.glVertexAttrib4d = null;
var glVertexAttrib4dv: ?function_signatures.glVertexAttrib4dv = null;
var glVertexAttrib4f: ?function_signatures.glVertexAttrib4f = null;
var glVertexAttrib4fv: ?function_signatures.glVertexAttrib4fv = null;
var glVertexAttrib4iv: ?function_signatures.glVertexAttrib4iv = null;
var glVertexAttrib4s: ?function_signatures.glVertexAttrib4s = null;
var glVertexAttrib4sv: ?function_signatures.glVertexAttrib4sv = null;
var glVertexAttrib4ubv: ?function_signatures.glVertexAttrib4ubv = null;
var glVertexAttrib4uiv: ?function_signatures.glVertexAttrib4uiv = null;
var glVertexAttrib4usv: ?function_signatures.glVertexAttrib4usv = null;
var glVertexAttribPointer: ?function_signatures.glVertexAttribPointer = null;
var glUniformMatrix2x3fv: ?function_signatures.glUniformMatrix2x3fv = null;
var glUniformMatrix3x2fv: ?function_signatures.glUniformMatrix3x2fv = null;
var glUniformMatrix2x4fv: ?function_signatures.glUniformMatrix2x4fv = null;
var glUniformMatrix4x2fv: ?function_signatures.glUniformMatrix4x2fv = null;
var glUniformMatrix3x4fv: ?function_signatures.glUniformMatrix3x4fv = null;
var glUniformMatrix4x3fv: ?function_signatures.glUniformMatrix4x3fv = null;
var glColorMaski: ?function_signatures.glColorMaski = null;
var glGetBooleani_v: ?function_signatures.glGetBooleani_v = null;
var glGetIntegeri_v: ?function_signatures.glGetIntegeri_v = null;
var glEnablei: ?function_signatures.glEnablei = null;
var glDisablei: ?function_signatures.glDisablei = null;
var glIsEnabledi: ?function_signatures.glIsEnabledi = null;
var glBeginTransformFeedback: ?function_signatures.glBeginTransformFeedback = null;
var glEndTransformFeedback: ?function_signatures.glEndTransformFeedback = null;
var glBindBufferRange: ?function_signatures.glBindBufferRange = null;
var glBindBufferBase: ?function_signatures.glBindBufferBase = null;
var glTransformFeedbackVaryings: ?function_signatures.glTransformFeedbackVaryings = null;
var glGetTransformFeedbackVarying: ?function_signatures.glGetTransformFeedbackVarying = null;
var glClampColor: ?function_signatures.glClampColor = null;
var glBeginConditionalRender: ?function_signatures.glBeginConditionalRender = null;
var glEndConditionalRender: ?function_signatures.glEndConditionalRender = null;
var glVertexAttribIPointer: ?function_signatures.glVertexAttribIPointer = null;
var glGetVertexAttribIiv: ?function_signatures.glGetVertexAttribIiv = null;
var glGetVertexAttribIuiv: ?function_signatures.glGetVertexAttribIuiv = null;
var glVertexAttribI1i: ?function_signatures.glVertexAttribI1i = null;
var glVertexAttribI2i: ?function_signatures.glVertexAttribI2i = null;
var glVertexAttribI3i: ?function_signatures.glVertexAttribI3i = null;
var glVertexAttribI4i: ?function_signatures.glVertexAttribI4i = null;
var glVertexAttribI1ui: ?function_signatures.glVertexAttribI1ui = null;
var glVertexAttribI2ui: ?function_signatures.glVertexAttribI2ui = null;
var glVertexAttribI3ui: ?function_signatures.glVertexAttribI3ui = null;
var glVertexAttribI4ui: ?function_signatures.glVertexAttribI4ui = null;
var glVertexAttribI1iv: ?function_signatures.glVertexAttribI1iv = null;
var glVertexAttribI2iv: ?function_signatures.glVertexAttribI2iv = null;
var glVertexAttribI3iv: ?function_signatures.glVertexAttribI3iv = null;
var glVertexAttribI4iv: ?function_signatures.glVertexAttribI4iv = null;
var glVertexAttribI1uiv: ?function_signatures.glVertexAttribI1uiv = null;
var glVertexAttribI2uiv: ?function_signatures.glVertexAttribI2uiv = null;
var glVertexAttribI3uiv: ?function_signatures.glVertexAttribI3uiv = null;
var glVertexAttribI4uiv: ?function_signatures.glVertexAttribI4uiv = null;
var glVertexAttribI4bv: ?function_signatures.glVertexAttribI4bv = null;
var glVertexAttribI4sv: ?function_signatures.glVertexAttribI4sv = null;
var glVertexAttribI4ubv: ?function_signatures.glVertexAttribI4ubv = null;
var glVertexAttribI4usv: ?function_signatures.glVertexAttribI4usv = null;
var glGetUniformuiv: ?function_signatures.glGetUniformuiv = null;
var glBindFragDataLocation: ?function_signatures.glBindFragDataLocation = null;
var glGetFragDataLocation: ?function_signatures.glGetFragDataLocation = null;
var glUniform1ui: ?function_signatures.glUniform1ui = null;
var glUniform2ui: ?function_signatures.glUniform2ui = null;
var glUniform3ui: ?function_signatures.glUniform3ui = null;
var glUniform4ui: ?function_signatures.glUniform4ui = null;
var glUniform1uiv: ?function_signatures.glUniform1uiv = null;
var glUniform2uiv: ?function_signatures.glUniform2uiv = null;
var glUniform3uiv: ?function_signatures.glUniform3uiv = null;
var glUniform4uiv: ?function_signatures.glUniform4uiv = null;
var glTexParameterIiv: ?function_signatures.glTexParameterIiv = null;
var glTexParameterIuiv: ?function_signatures.glTexParameterIuiv = null;
var glGetTexParameterIiv: ?function_signatures.glGetTexParameterIiv = null;
var glGetTexParameterIuiv: ?function_signatures.glGetTexParameterIuiv = null;
var glClearBufferiv: ?function_signatures.glClearBufferiv = null;
var glClearBufferuiv: ?function_signatures.glClearBufferuiv = null;
var glClearBufferfv: ?function_signatures.glClearBufferfv = null;
var glClearBufferfi: ?function_signatures.glClearBufferfi = null;
var glGetStringi: ?function_signatures.glGetStringi = null;
var glIsRenderbuffer: ?function_signatures.glIsRenderbuffer = null;
var glBindRenderbuffer: ?function_signatures.glBindRenderbuffer = null;
var glDeleteRenderbuffers: ?function_signatures.glDeleteRenderbuffers = null;
var glGenRenderbuffers: ?function_signatures.glGenRenderbuffers = null;
var glRenderbufferStorage: ?function_signatures.glRenderbufferStorage = null;
var glGetRenderbufferParameteriv: ?function_signatures.glGetRenderbufferParameteriv = null;
var glIsFramebuffer: ?function_signatures.glIsFramebuffer = null;
var glBindFramebuffer: ?function_signatures.glBindFramebuffer = null;
var glDeleteFramebuffers: ?function_signatures.glDeleteFramebuffers = null;
var glGenFramebuffers: ?function_signatures.glGenFramebuffers = null;
var glCheckFramebufferStatus: ?function_signatures.glCheckFramebufferStatus = null;
var glFramebufferTexture1D: ?function_signatures.glFramebufferTexture1D = null;
var glFramebufferTexture2D: ?function_signatures.glFramebufferTexture2D = null;
var glFramebufferTexture3D: ?function_signatures.glFramebufferTexture3D = null;
var glFramebufferRenderbuffer: ?function_signatures.glFramebufferRenderbuffer = null;
var glGetFramebufferAttachmentParameteriv: ?function_signatures.glGetFramebufferAttachmentParameteriv = null;
var glGenerateMipmap: ?function_signatures.glGenerateMipmap = null;
var glBlitFramebuffer: ?function_signatures.glBlitFramebuffer = null;
var glRenderbufferStorageMultisample: ?function_signatures.glRenderbufferStorageMultisample = null;
var glFramebufferTextureLayer: ?function_signatures.glFramebufferTextureLayer = null;
var glMapBufferRange: ?function_signatures.glMapBufferRange = null;
var glFlushMappedBufferRange: ?function_signatures.glFlushMappedBufferRange = null;
var glBindVertexArray: ?function_signatures.glBindVertexArray = null;
var glDeleteVertexArrays: ?function_signatures.glDeleteVertexArrays = null;
var glGenVertexArrays: ?function_signatures.glGenVertexArrays = null;
var glIsVertexArray: ?function_signatures.glIsVertexArray = null;
var glDrawArraysInstanced: ?function_signatures.glDrawArraysInstanced = null;
var glDrawElementsInstanced: ?function_signatures.glDrawElementsInstanced = null;
var glTexBuffer: ?function_signatures.glTexBuffer = null;
var glPrimitiveRestartIndex: ?function_signatures.glPrimitiveRestartIndex = null;
var glCopyBufferSubData: ?function_signatures.glCopyBufferSubData = null;
var glGetUniformIndices: ?function_signatures.glGetUniformIndices = null;
var glGetActiveUniformsiv: ?function_signatures.glGetActiveUniformsiv = null;
var glGetActiveUniformName: ?function_signatures.glGetActiveUniformName = null;
var glGetUniformBlockIndex: ?function_signatures.glGetUniformBlockIndex = null;
var glGetActiveUniformBlockiv: ?function_signatures.glGetActiveUniformBlockiv = null;
var glGetActiveUniformBlockName: ?function_signatures.glGetActiveUniformBlockName = null;
var glUniformBlockBinding: ?function_signatures.glUniformBlockBinding = null;
var glTexStorage3DMultisample: ?function_signatures.glTexStorage3DMultisample = null;
var glTextureView: ?function_signatures.glTextureView = null;
var glBindVertexBuffer: ?function_signatures.glBindVertexBuffer = null;
var glVertexAttribFormat: ?function_signatures.glVertexAttribFormat = null;
var glVertexAttribIFormat: ?function_signatures.glVertexAttribIFormat = null;
var glVertexAttribLFormat: ?function_signatures.glVertexAttribLFormat = null;
var glVertexAttribBinding: ?function_signatures.glVertexAttribBinding = null;
var glVertexBindingDivisor: ?function_signatures.glVertexBindingDivisor = null;
var glDebugMessageControl: ?function_signatures.glDebugMessageControl = null;
var glDebugMessageInsert: ?function_signatures.glDebugMessageInsert = null;
var glDebugMessageCallback: ?function_signatures.glDebugMessageCallback = null;
var glGetDebugMessageLog: ?function_signatures.glGetDebugMessageLog = null;
var glPushDebugGroup: ?function_signatures.glPushDebugGroup = null;
var glPopDebugGroup: ?function_signatures.glPopDebugGroup = null;
var glObjectLabel: ?function_signatures.glObjectLabel = null;
var glGetObjectLabel: ?function_signatures.glGetObjectLabel = null;
var glObjectPtrLabel: ?function_signatures.glObjectPtrLabel = null;
var glGetObjectPtrLabel: ?function_signatures.glGetObjectPtrLabel = null;
var glGetPointerv: ?function_signatures.glGetPointerv = null;
var glBufferStorage: ?function_signatures.glBufferStorage = null;
var glClearTexImage: ?function_signatures.glClearTexImage = null;
var glClearTexSubImage: ?function_signatures.glClearTexSubImage = null;
var glBindBuffersBase: ?function_signatures.glBindBuffersBase = null;
var glBindBuffersRange: ?function_signatures.glBindBuffersRange = null;
var glBindTextures: ?function_signatures.glBindTextures = null;
var glBindSamplers: ?function_signatures.glBindSamplers = null;
var glBindImageTextures: ?function_signatures.glBindImageTextures = null;
var glBindVertexBuffers: ?function_signatures.glBindVertexBuffers = null;
};
test "" {
_ = load;
@setEvalBranchQuota(100_000); // Yes, this is necessary. OpenGL gets quite large!
std.testing.refAllDecls(@This());
} | modules/graphics/vendored/zig-opengl-exports/gl_4v4.zig |
const std = @import("std");
const swizzles = @import("swizzle.zig");
/// Returns a zero-size namespace struct defining vector operations for
/// given size `N` (min: 1) and component type `C` (any integer or float).
/// The actual vector type used for these operations is the built-in
/// `std.meta.Vector` aka SIMD-optimized vectors. The ops defined here
/// merely act as a more unified and comprehensive API.
/// Depending on chosen component type `C`, some ops might not be
/// available (i.e. float vectors offer much more functionality than
/// their integer-based counterparts)
pub fn Vec(comptime N: u32, comptime C: type) type {
const INFO = @typeInfo(C);
if (!(INFO == .Int or INFO == .Float)) {
@compileError("unsupported component type: " ++ C);
}
if (N < 1) {
@compileError("zero-length vectors not supported");
}
const V = @Vector(N, C);
const B = @Vector(N, bool);
return struct {
/// The resulting vector type: `@Vector(N, C)`
pub const T = V;
/// The user provided vector component type: C
pub const C = C;
/// The user provided vector size: N
pub const N = N;
/// Vector w/ all components as 0
pub const ZERO = of(0);
/// Vector w/ all components as 1
pub const ONE = of(1);
pub usingnamespace swizzles.Vec2Swizzles(N, C);
pub usingnamespace swizzles.Vec3Swizzles(N, C);
pub usingnamespace swizzles.Vec4Swizzles(N, C);
pub usingnamespace VecSizeSpecific(N, C);
pub usingnamespace VecTypeSpecific(N, C);
pub inline fn x(a: V) C {
return a[0];
}
pub inline fn addN(a: V, n: C) V {
return a + of(n);
}
/// Returns index of the smallest component
pub fn argmin(a: V) u32 {
var res: u32 = 0;
var acc: C = a[0];
comptime var i = 1;
inline while (i < N) : (i += 1) {
if (a[i] < acc) {
acc = a[i];
res = i;
}
}
return res;
}
/// Returns index of the largest component
pub fn argmax(a: V) u32 {
var res: u32 = 0;
var acc: C = a[0];
comptime var i = 1;
inline while (i < N) : (i += 1) {
if (a[i] > acc) {
acc = a[i];
res = i;
}
}
return res;
}
pub fn centroid(a: []const V) V {
var i: u32 = 0;
var res: V = ZERO;
while (i < a.len) : (i += 1) {
res += a[i];
}
return divN(res, @intToFloat(C, a.len));
}
pub fn clamp(a: V, b: V, c: V) V {
return min(max(a, b), c);
}
pub inline fn distSq(a: V, b: V) C {
return magSq(a - b);
}
pub inline fn divN(a: V, n: C) V {
return if (INFO == .Int) @divTrunc(a, of(n)) else a / of(n);
}
pub inline fn dot(a: V, b: V) C {
return _dot(C, a, b);
}
pub inline fn equal(a: V, b: V) bool {
return BVec(N).all(a == b);
}
pub fn fill(buf: []V, val: V) void {
for (buf) |_, i| {
buf[i] = val;
}
}
pub inline fn fromBVec(a: B) V {
return select(a, ONE, ZERO);
}
pub inline fn isZero(a: V) bool {
return BVec(N).all(a == ZERO);
}
/// computes a * b + c, where `a` and `c` are vectors and `b` is a scalar
pub inline fn maddN(a: V, n: C, b: V) V {
return a * of(n) + b;
}
pub inline fn magSq(a: V) C {
return _dot(C, a, a);
}
pub inline fn min(a: V, b: V) V {
return select(a < b, a, b);
}
pub inline fn minComp(a: V) C {
return @reduce(.Min, a);
}
pub inline fn max(a: V, b: V) V {
return select(a > b, a, b);
}
pub inline fn maxComp(a: V) C {
return @reduce(.Max, a);
}
pub inline fn mulN(a: V, n: C) V {
return a * of(n);
}
pub inline fn of(n: C) V {
return @splat(N, n);
}
pub inline fn product(a: V) C {
return @reduce(.Mul, a);
}
pub inline fn select(mask: B, a: V, b: V) V {
return @select(C, mask, a, b);
}
pub inline fn step(e0: V, a: V) V {
return select(a < e0, ZERO, ONE);
}
pub inline fn subN(a: V, n: C) V {
return a - of(n);
}
pub inline fn sum(a: V) C {
return @reduce(.Add, a);
}
};
}
fn VecTypeSpecific(comptime N: u32, comptime T: type) type {
const V = @Vector(N, T);
const INFO = @typeInfo(T);
const eqd = struct {
pub fn allEqDelta(a: V, b: V, eps: T) bool {
return BVec(N).all(eqDelta(a, b, eps));
}
pub fn eqDelta(a: V, b: V, eps: T) @Vector(N, bool) {
const delta = a - b;
const invDelta = -delta;
return @select(T, delta > invDelta, delta, invDelta) <= @splat(N, eps);
}
};
if (INFO == .Int) {
const base = struct {
pub inline fn fromVec(comptime S: type, a: @Vector(N, S)) V {
comptime var i = 0;
var res: [N]T = undefined;
inline while (i < N) : (i += 1) {
res[i] = @floatToInt(T, a[i]);
}
return res;
}
pub inline fn fromIVec(comptime S: type, a: @Vector(N, S)) V {
comptime var i = 0;
var res: [N]T = undefined;
inline while (i < N) : (i += 1) {
res[i] = @intCast(T, a[i]);
}
return res;
}
pub inline fn _not(a: V) V {
return ~a;
}
pub inline fn _and(a: V, b: V) V {
return a & b;
}
pub inline fn _or(a: V, b: V) V {
return a | b;
}
pub inline fn _xor(a: V, b: V) V {
return a ^ b;
}
pub inline fn pow(a: V, n: T) V {
return _map(N, T, a, _powi, .{n});
}
};
return if (isSignedInt(T)) struct {
pub usingnamespace base;
pub usingnamespace eqd;
/// Vector w/ all components as -1
pub const MINUS_ONE = @splat(N, -1);
pub inline fn abs(a: V) V {
return @select(T, a >= @splat(N, 0), a, -a);
}
} else base;
} else {
return struct {
pub usingnamespace eqd;
pub const INF = @splat(N, std.math.inf(T));
pub const NEG_INF = @splat(N, -std.math.inf(T));
/// Vector w/ all components as -1
pub const MINUS_ONE = @splat(N, -1);
pub inline fn fromIVec(comptime S: type, a: @Vector(N, S)) V {
comptime var i = 0;
var res: [N]T = undefined;
inline while (i < N) : (i += 1) {
res[i] = @intToFloat(T, a[i]);
}
return res;
}
pub inline fn abs(a: V) V {
return @fabs(a);
}
pub inline fn acos(a: V) V {
return _map(N, T, a, std.math.acos, .{});
}
pub inline fn angleBetween(a: V, b: V) T {
return std.math.acos(_dot(T, a, b));
}
pub inline fn asin(a: V) V {
return _map(N, T, a, std.math.asin, .{});
}
pub inline fn atan(a: V) V {
return _map(N, T, a, std.math.atan, .{});
}
pub inline fn atan2(a: V, b: V) V {
return _map2(N, T, a, b, _atan2, .{});
}
pub inline fn ceil(a: V) V {
return @ceil(a);
}
pub inline fn center(a: V) V {
return a - @splat(N, mean(a));
}
pub inline fn clamp01(a: V) V {
const zero = _splat(N, T, 0);
const one = _splat(N, T, 1);
const res = @select(T, a > zero, a, zero);
return @select(T, res < one, res, one);
}
pub inline fn cos(a: V) V {
return @cos(a);
}
pub inline fn direction(a: V, b: V) T {
return normalize(b - a);
}
pub inline fn dist(a: V, b: V) T {
return mag(a - b);
}
pub inline fn exp(a: V) V {
return @exp(a);
}
pub inline fn exp2(a: V) V {
return @exp2(a);
}
pub inline fn fit(a: V, b: V, c: V, d: V, e: V) V {
return mix(d, e, (a - b) / (c - b));
}
pub inline fn fitClamped(a: V, b: V, c: V, d: V, e: V) V {
return mix(d, e, clamp01((a - b) / (c - b)));
}
pub inline fn fit01(a: V, b: V, c: V) V {
return mix(b, c, a);
}
pub inline fn floor(a: V) V {
return @floor(a);
}
pub inline fn invSqrt(a: V) V {
return _splat(N, T, 1) / @sqrt(a);
}
pub inline fn log(a: V) V {
return @log(a);
}
pub inline fn log2(a: V) V {
return @log2(a);
}
pub inline fn log10(a: V) V {
return @log10(a);
}
pub inline fn mag(a: V) T {
return @sqrt(_dot(T, a, a));
}
pub inline fn mean(a: V) T {
return @reduce(.Add, a) / @as(T, N);
}
pub inline fn mix(a: V, b: V, t: V) V {
return a + (b - a) * t;
}
pub inline fn mixN(a: V, b: V, n: T) V {
return mix(a, b, @splat(N, n));
}
pub inline fn mod(a: V, b: V) V {
return _map2(N, T, a, b, _mod, .{});
}
pub inline fn normalize(a: V) V {
return normalizeTo(a, 1.0);
}
pub inline fn normalizeTo(a: V, n: T) V {
const m = mag(a);
return if (m > 1e-6) a * @splat(N, n / m) else a;
}
pub inline fn pow(a: V, b: V) V {
return _map2(N, T, a, b, _pow, .{});
}
pub inline fn powN(a: V, n: T) V {
return _map(N, T, a, _pow, .{n});
}
pub inline fn reflect(a: V, n: V) V {
return n * @splat(N, -2 * _dot(T, a, n)) + a;
}
pub inline fn refract(a: V, n: V, eta: T) V {
const d = _dot(T, a, n);
const k = 1.0 - eta * eta * (1.0 - d * d);
return if (k < 0)
_splat(N, T, 0)
else
n * @splat(N, -(eta * d + @sqrt(k))) + a * @splat(N, eta);
}
pub inline fn round(a: V) V {
return @round(a);
}
pub inline fn sd(a: V) T {
return @sqrt(_dot(T, a, a) / @as(T, N - 1));
}
pub inline fn sdError(a: V) T {
return sd(a) / @sqrt(@as(T, N));
}
pub inline fn sin(a: V) V {
return @sin(a);
}
pub inline fn smoothStep(e0: V, e1: V, a: V) V {
const x = clamp01((a - e0) / (e1 - e0));
return (_splat(N, T, 3) - _splat(N, T, 2) * x) * x * x;
}
pub inline fn sqrt(a: V) V {
return @sqrt(a);
}
pub inline fn standardize(a: V) V {
const c = center(a);
const d = sd(c);
return if (d > 0) c / @splat(N, d) else c;
}
pub inline fn tan(a: V) V {
return _map(N, T, a, std.math.tan, .{});
}
pub inline fn trunc(a: V) V {
return @trunc(a);
}
pub inline fn variance(a: V) T {
return _dot(T, a, a) / @as(T, N);
}
};
}
}
pub fn BVec(comptime N: u32) type {
const V = @Vector(N, bool);
return struct {
pub const T = V;
pub const C = bool;
pub const N = N;
pub const FALSE = @This().of(false);
pub const TRUE = @This().of(true);
pub inline fn all(v: V) bool {
return @reduce(.And, v);
}
pub inline fn _not(a: V) V {
return _map(N, bool, a, _bnot, .{});
}
pub inline fn _and(a: V, b: V) V {
return _map2(N, bool, a, b, _band, .{});
}
pub inline fn _or(a: V, b: V) V {
return _map2(N, bool, a, b, _bor, .{});
}
pub inline fn any(v: V) bool {
return @reduce(.Or, v);
}
pub inline fn of(n: bool) V {
return @splat(N, n);
}
pub inline fn select(mask: V, a: V, b: V) V {
return @select(bool, mask, a, b);
}
};
}
fn VecSizeSpecific(comptime N: u32, comptime T: type) type {
const V = @Vector(N, T);
const INFO = @typeInfo(T);
const isFloat = INFO == .Float;
if (N == 2) {
const base = if (isFloat or isSignedInt(T)) struct {
pub fn perpendicularCCW(a: V) V {
return [_]T{ -a[1], a[0] };
}
pub fn perpendicularCW(a: V) V {
return [_]T{ a[1], -a[0] };
}
} else struct {};
return if (isFloat) struct {
pub usingnamespace base;
pub inline fn cross(a: V, b: V) T {
return a[0] * b[1] - a[1] * b[0];
}
pub inline fn heading(a: V) T {
return _atanAbs(_atan2(a[1], a[0]));
}
} else base;
} else if (N == 3) {
return if (isFloat) struct {
pub fn orthoNormal(a: V, b: V, c: V) V {
return _normalize(T, cross(b - a, c - a), 1.0);
}
pub fn cross(a: V, b: V) V {
const a1: V = [_]T{ a[1], a[2], a[0] };
const a2: V = [_]T{ a[2], a[0], a[1] };
const b1: V = [_]T{ b[2], b[0], b[1] };
const b2: V = [_]T{ b[1], b[2], b[0] };
return a1 * b1 - a2 * b2;
}
} else struct {
pub fn fromVec2(a: @Vector(2, T), z: T) V {
return [_]T{ a[0], a[1], z };
}
};
} else if (N == 4) {
return struct {
pub fn fromVec2(a: @Vector(2, T), b: @Vector(2, T)) V {
return [_]T{ a[0], a[1], b[0], b[1] };
}
pub fn fromVec2N(a: @Vector(2, T), z: T, w: T) V {
return [_]T{ a[0], a[1], z, w };
}
pub fn fromVec3(a: @Vector(3, T), w: T) V {
return [_]T{ a[0], a[1], a[2], w };
}
};
}
return struct {};
}
fn isSignedInt(comptime a: type) bool {
const info = @typeInfo(a);
return info == .Int and info.Int.signedness == std.builtin.Signedness.signed;
}
fn _map(comptime N: u32, comptime T: type, a: @Vector(N, T), comptime f: anytype, args: anytype) @TypeOf(a) {
comptime var opts: std.builtin.CallOptions = .{};
comptime var i = 0;
var res: [N]T = undefined;
inline while (i < N) : (i += 1) {
res[i] = @call(opts, f, .{a[i]} ++ args);
}
return res;
}
fn _map2(comptime N: u32, comptime T: type, a: @Vector(N, T), b: @Vector(N, T), comptime f: anytype, args: anytype) @TypeOf(a) {
comptime var opts: std.builtin.CallOptions = .{};
comptime var i = 0;
var res: [N]T = undefined;
inline while (i < N) : (i += 1) {
res[i] = @call(opts, f, .{ a[i], b[i] } ++ args);
}
return res;
}
inline fn _splat(comptime N: u32, comptime T: type, n: T) @Vector(N, T) {
return @splat(N, n);
}
inline fn _dot(comptime T: type, a: anytype, b: anytype) T {
return @reduce(.Add, a * b);
}
fn _atan2(a: anytype, b: anytype) @TypeOf(a) {
return std.math.atan2(@TypeOf(a), a, b);
}
fn _mod(a: anytype, b: anytype) @TypeOf(a) {
return a - b * @floor(a / b);
}
fn _normalize(comptime T: type, a: anytype, n: anytype) @TypeOf(a) {
const m = @sqrt(_dot(T, a, a));
return if (m > 1e-6) a * @splat(@typeInfo(@TypeOf(a)).Vector.len, n / m) else a;
}
fn _pow(a: anytype, b: anytype) @TypeOf(a) {
return std.math.pow(@TypeOf(a), a, b);
}
fn _powi(a: anytype, b: anytype) @TypeOf(a) {
return std.math.powi(@TypeOf(a), a, b);
}
fn _atanAbs(a: anytype) @TypeOf(a) {
const theta = std.math.mod(@TypeOf(a), a, std.math.tau);
return if (theta < 0) std.math.tau + theta else theta;
}
inline fn _band(a: bool, b: bool) bool {
return a and b;
}
inline fn _bor(a: bool, b: bool) bool {
return a or b;
}
inline fn _bnot(a: bool) bool {
return !a;
}
pub const Vec2 = Vec(2, f32);
pub const Vec3 = Vec(3, f32);
pub const Vec4 = Vec(4, f32);
pub const IVec2 = Vec(2, i32);
pub const IVec3 = Vec(3, i32);
pub const IVec4 = Vec(4, i32);
pub const UVec2 = Vec(2, u32);
pub const UVec3 = Vec(3, u32);
pub const UVec4 = Vec(4, u32);
pub const BVec2 = BVec(2);
pub const BVec3 = BVec(3);
pub const BVec4 = BVec(4);
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test "Vec.argmin" {
try expectEqual(@as(u32, 0), Vec4.argmin([_]f32{ -4, 3, 2, 1 }));
try expectEqual(@as(u32, 1), Vec4.argmin([_]f32{ 4, -3, 2, 1 }));
try expectEqual(@as(u32, 2), Vec4.argmin([_]f32{ 4, 3, -2, 1 }));
try expectEqual(@as(u32, 3), Vec4.argmin([_]f32{ 4, 3, 2, -1 }));
}
test "Vec.argmax" {
try expectEqual(@as(u32, 0), Vec4.argmax([_]f32{ 4, -3, -2, -1 }));
try expectEqual(@as(u32, 1), Vec4.argmax([_]f32{ -4, 3, -2, -1 }));
try expectEqual(@as(u32, 2), Vec4.argmax([_]f32{ -4, -3, 2, -1 }));
try expectEqual(@as(u32, 3), Vec4.argmax([_]f32{ -4, -3, -2, 1 }));
}
test "Vec.centroid" {
try expect(Vec3.equal(Vec3.centroid(&[_]Vec3.T{
[_]f32{ 10, 100, 1000 },
[_]f32{ 20, -200, -500 },
[_]f32{ -60, 400, -800 },
}), [_]f32{ -10, 100, -100 }));
}
test "Vec.clamp" {
try expect(Vec3.equal(Vec3.clamp([_]f32{ -3, 2, 0.5 }, [_]f32{ -1, -1, -1 }, Vec3.ONE), [_]f32{ -1, 1, 0.5 }));
}
test "Vec.distSq" {
try expectEqual(@as(i32, 75), IVec3.distSq([_]i32{ -4, 3, -2 }, [_]i32{ 1, -2, 3 }));
}
test "Vec.dot" {
try expectEqual(@as(i32, -10 - 40 - 90), IVec3.dot([_]i32{ -1, 2, -3 }, [_]i32{ 10, -20, 30 }));
}
test "Vec.equal" {
try expect(Vec2.equal([_]f32{ -1, 2 }, [_]f32{ -1, 2 }));
try expect(!Vec2.equal([_]f32{ -1, 2 }, [_]f32{ -1.01, 2.01 }));
}
test "Vec.eqDelta" {
try expect(Vec2.allEqDelta([_]f32{ -1, 2 }, [_]f32{ -1.09, 2.09 }, 0.1));
try expect(!Vec2.allEqDelta([_]f32{ -1, 2 }, [_]f32{ -1.09, 2.09 }, 0.01));
try expect(Vec(6, f32).allEqDelta([_]f32{ -1, 2, -3, 4, -5, 6 }, [_]f32{ -1.01, 2.01, -3.01, 4.01, -5.01, 6.01 }, 0.011));
// unsupported for unsigned
try expect(!@hasDecl(UVec2, "eqDelta"));
try expect(!@hasDecl(UVec2, "allEqDelta"));
}
test "Vec2.perpendicular" {
try expect(Vec2.allEqDelta(Vec2.perpendicularCCW([_]f32{ 1, 2 }), [_]f32{ -2, 1 }, 0));
try expect(Vec2.allEqDelta(Vec2.perpendicularCW([_]f32{ 1, 2 }), [_]f32{ 2, -1 }, 0));
try expect(IVec2.allEqDelta(IVec2.perpendicularCCW([_]i32{ 1, 2 }), [_]i32{ -2, 1 }, 0));
try expect(IVec2.allEqDelta(IVec2.perpendicularCW([_]i32{ 1, 2 }), [_]i32{ 2, -1 }, 0));
// unsupported/unimplemented for unsigned
try expect(!@hasDecl(UVec2, "perpendicularCCW"));
try expect(!@hasDecl(UVec2, "perpendicularCW"));
} | src/vec-simd.zig |
const std = @import("std");
const assert = std.debug.assert;
// TODO
// Cannot use testing allocator because I was too lazy to write the deinit()
// method for Node (our graph).
//
// const allocator = std.testing.allocator;
const allocator = std.heap.page_allocator;
pub const Map = struct {
pub const Pos = struct {
const OFFSET: usize = 10000;
x: usize,
y: usize,
pub fn init(x: usize, y: usize) Pos {
return Pos{
.x = x,
.y = y,
};
}
fn cmp(l: Pos, r: Pos) std.math.Order {
if (l.x < r.x) return std.math.Order.lt;
if (l.x > r.x) return std.math.Order.gt;
if (l.y < r.y) return std.math.Order.lt;
if (l.y > r.y) return std.math.Order.gt;
return std.math.Order.eq;
}
};
pub const Node = struct {
p: Pos,
m: usize,
n: std.AutoHashMap(u64, void),
pub fn init(p: Pos, m: usize) Node {
return Node{
.p = p,
.m = m,
.n = std.AutoHashMap(u64, void).init(allocator),
};
}
pub fn deinit(self: *Node) void {
self.n.deinit();
}
pub fn encode(self: Node) u64 {
return (self.m * 1000 + self.p.x) * 1000 + self.p.y;
}
pub fn get_mask(label: u64) usize {
return label / 1000000;
}
fn cmp(l: Node, r: Node) std.math.Order {
if (l.m < r.m) return std.math.Order.lt;
if (l.m > r.m) return std.math.Order.gt;
return Pos.cmp(l.p, r.p);
}
};
pub const NodeInfo = struct {
label: u64,
dist: usize,
pub fn init(label: u64, dist: usize) NodeInfo {
return NodeInfo{
.label = label,
.dist = dist,
};
}
fn cmp(l: NodeInfo, r: NodeInfo) std.math.Order {
if (l.dist < r.dist) return std.math.Order.lt;
if (l.dist > r.dist) return std.math.Order.gt;
if (l.label < r.label) return std.math.Order.lt;
if (l.label > r.label) return std.math.Order.gt;
return std.math.Order.eq;
}
};
cells: std.AutoHashMap(Pos, Tile),
keys: std.AutoHashMap(Pos, u8),
doors: std.AutoHashMap(Pos, u8),
nodes: std.AutoHashMap(u64, Node),
py: usize,
pcur: Pos,
pmin: Pos,
pmax: Pos,
pub const Dir = enum(u8) {
N = 1,
S = 2,
W = 3,
E = 4,
pub fn move(p: Pos, d: Dir) Pos {
var q = p;
switch (d) {
Dir.N => q.y -= 1,
Dir.S => q.y += 1,
Dir.W => q.x -= 1,
Dir.E => q.x += 1,
}
return q;
}
};
pub const Tile = enum(u8) {
Empty = 0,
Wall = 1,
Door = 2,
Key = 3,
};
pub fn init() Map {
var self = Map{
.py = 0,
.cells = std.AutoHashMap(Pos, Tile).init(allocator),
.keys = std.AutoHashMap(Pos, u8).init(allocator),
.doors = std.AutoHashMap(Pos, u8).init(allocator),
.nodes = std.AutoHashMap(u64, Node).init(allocator),
.pcur = Pos.init(Pos.OFFSET / 2, Pos.OFFSET / 2),
.pmin = Pos.init(std.math.maxInt(usize), std.math.maxInt(usize)),
.pmax = Pos.init(0, 0),
};
return self;
}
pub fn deinit(self: *Map) void {
self.nodes.deinit();
self.doors.deinit();
self.keys.deinit();
self.cells.deinit();
}
pub fn parse(self: *Map, line: []const u8) void {
var x: usize = 0;
while (x < line.len) : (x += 1) {
const p = Pos.init(x, self.py);
var t: Map.Tile = Map.Tile.Empty;
if (line[x] == '#') t = Map.Tile.Wall;
if (line[x] == '@') {
self.pcur = p;
}
if (line[x] >= 'A' and line[x] <= 'Z') {
// std.debug.warn("DOOR {c}\n", line[x]);
t = Map.Tile.Door;
_ = self.doors.put(p, line[x]) catch unreachable;
}
if (line[x] >= 'a' and line[x] <= 'z') {
// std.debug.warn("KEY {c}\n", line[x]);
t = Map.Tile.Key;
_ = self.keys.put(p, line[x]) catch unreachable;
}
self.set_pos(p, t);
}
self.py += 1;
}
pub fn set_pos(self: *Map, pos: Pos, mark: Tile) void {
_ = self.cells.put(pos, mark) catch unreachable;
if (self.pmin.x > pos.x) self.pmin.x = pos.x;
if (self.pmin.y > pos.y) self.pmin.y = pos.y;
if (self.pmax.x < pos.x) self.pmax.x = pos.x;
if (self.pmax.y < pos.y) self.pmax.y = pos.y;
}
pub fn walk_map(self: *Map) void {
_ = self.get_all_keys();
self.nodes.clearRetainingCapacity();
const PQ = std.PriorityQueue(Node, Node.cmp);
var Pend = PQ.init(allocator);
defer Pend.deinit();
// We start from the oxygen system position, which has already been filled with oxygen
const first = Node.init(self.pcur, 0);
_ = Pend.add(first) catch unreachable;
while (Pend.count() != 0) {
var curr = Pend.remove();
if (self.nodes.contains(curr.encode())) continue;
if (curr.m == self.get_all_keys()) continue;
var j: u8 = 1;
while (j <= 4) : (j += 1) {
const d = @intToEnum(Dir, j);
var v = Dir.move(curr.p, d);
if (!self.cells.contains(v)) continue;
const tile = self.cells.get(v).?;
var next: ?Node = null;
switch (tile) {
Tile.Wall => {},
Tile.Empty => {
next = Node.init(v, curr.m);
},
Tile.Key => {
const shift: u5 = @intCast(u5, self.keys.get(v).? - 'a');
const needed: usize = @shlExact(@intCast(usize, 1), shift);
next = Node.init(v, curr.m | needed);
},
Tile.Door => {
if (!self.doors.contains(v)) {
next = Node.init(v, curr.m);
} else {
const shift: u5 = @intCast(u5, self.doors.get(v).? - 'A');
const needed: usize = @shlExact(@intCast(usize, 1), shift);
if (curr.m & needed != 0) {
next = Node.init(v, curr.m);
}
}
},
}
if (next == null) continue;
const n = next.?;
const e = n.encode();
_ = curr.n.put(e, {}) catch unreachable;
if (self.nodes.contains(e)) continue;
_ = Pend.add(n) catch unreachable;
}
_ = self.nodes.put(curr.encode(), curr) catch unreachable;
}
// std.debug.warn("Graph has {} nodes\n", self.nodes.count());
}
pub fn walk_graph(self: *Map) usize {
var seen = std.AutoHashMap(u64, void).init(allocator);
defer seen.deinit();
const PQ = std.PriorityQueue(NodeInfo, NodeInfo.cmp);
var Pend = PQ.init(allocator);
defer Pend.deinit();
const all_keys = self.get_all_keys();
var dmax: usize = 0;
const home = Node.init(self.pcur, 0);
const first = NodeInfo.init(home.encode(), 0);
_ = Pend.add(first) catch unreachable;
while (Pend.count() != 0) {
const data = Pend.remove();
_ = Node.get_mask(data.label);
if (dmax < data.dist) dmax = data.dist;
if (Node.get_mask(data.label) == all_keys) break;
const node = self.nodes.get(data.label).?;
const dist = data.dist + 1;
var it = node.n.iterator();
while (it.next()) |kv| {
const l = kv.key_ptr.*;
if (seen.contains(l)) continue;
_ = seen.put(l, {}) catch unreachable;
_ = Pend.add(NodeInfo.init(l, dist)) catch unreachable;
}
}
return dmax;
}
fn get_all_keys(self: *Map) usize {
var all_keys: usize = 0;
var it = self.keys.iterator();
while (it.next()) |key| {
const shift: u5 = @intCast(u5, key.value_ptr.* - 'a');
const mask: usize = @shlExact(@intCast(usize, 1), shift);
all_keys |= mask;
}
return all_keys;
}
pub fn show(self: Map) void {
const sx = self.pmax.x - self.pmin.x + 1;
const sy = self.pmax.y - self.pmin.y + 1;
std.debug.warn("MAP: {} x {} - {} {} - {} {}\n", sx, sy, self.pmin.x, self.pmin.y, self.pmax.x, self.pmax.y);
var y: usize = self.pmin.y;
while (y <= self.pmax.y) : (y += 1) {
std.debug.warn("{:4} | ", y);
var x: usize = self.pmin.x;
while (x <= self.pmax.x) : (x += 1) {
const p = Pos.init(x, y);
const g = self.cells.get(p);
var t: u8 = ' ';
if (g != null) {
switch (g.?.value) {
Tile.Empty => t = '.',
Tile.Wall => t = '#',
Tile.Door => t = self.doors.get(p).?.value,
Tile.Key => t = self.keys.get(p).?.value,
}
}
if (x == self.pcur.x and y == self.pcur.y) t = '@';
std.debug.warn("{c}", t);
}
std.debug.warn("\n");
}
}
};
test "small map" {
var map = Map.init();
defer map.deinit();
const data =
\\#########
\\#[email protected]#
\\#########
;
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
map.parse(line);
}
// map.show();
map.walk_map();
const dist = map.walk_graph();
assert(dist == 8);
}
test "medium map 1" {
var map = Map.init();
defer map.deinit();
const data =
\\########################
\\#[email protected].#
\\######################.#
\\#d.....................#
\\########################
;
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
map.parse(line);
}
// map.show();
map.walk_map();
const dist = map.walk_graph();
assert(dist == 86);
}
test "medium map 2" {
var map = Map.init();
defer map.deinit();
const data =
\\########################
\\#...............b.C.D.f#
\\#.######################
\\#[email protected]#
\\########################
;
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
map.parse(line);
}
// map.show();
map.walk_map();
const dist = map.walk_graph();
assert(dist == 132);
}
test "medium map 3" {
var map = Map.init();
defer map.deinit();
const data =
\\#################
\\#i.G..c...e..H.p#
\\########.########
\\#j.A..b...f..D.o#
\\########@########
\\#k.E..a...g..B.n#
\\########.########
\\#l.F..d...h..C.m#
\\#################
;
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
map.parse(line);
}
// map.show();
map.walk_map();
const dist = map.walk_graph();
assert(dist == 136);
}
test "medium map 4" {
var map = Map.init();
defer map.deinit();
const data =
\\########################
\\#@..............ac.GI.b#
\\###d#e#f################
\\###A#B#C################
\\###g#h#i################
\\########################
;
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
map.parse(line);
}
// map.show();
map.walk_map();
const dist = map.walk_graph();
assert(dist == 81);
} | 2019/p18/map.zig |
const std = @import("std");
const panic = std.debug.panic;
usingnamespace @import("zalgebra");
usingnamespace @import("../transform.zig");
usingnamespace @import("../chunk/chunk.zig");
const c = @import("../c.zig");
const opengl = @import("../opengl_renderer.zig");
const glfw = @import("../glfw_platform.zig");
usingnamespace @import("../test_box.zig");
//TODO 3D chunk
pub const ChunkPos = Vec2(i32);
const ChunkInfo = struct {
const Self = @This();
coord: ChunkPos,
data: ChunkData32,
mesh: opengl.Mesh,
matrix: mat4,
pub fn deinit(self: *Self) void {
self.mesh.deinit();
}
};
pub const World = struct {
const Self = @This();
allocator: *std.mem.Allocator,
chunk_map: std.AutoHashMap(ChunkPos, ChunkInfo),
pub fn init(allocator: *std.mem.Allocator) Self {
var chunk_map = std.AutoHashMap(ChunkPos, ChunkInfo).init(allocator);
const CHUNK_SIZE = 1;
var index = ChunkPos.zero();
while (index.x < CHUNK_SIZE) : (index.x += 1) {
index.y = 0;
while (index.y < CHUNK_SIZE) : (index.y += 1) {
var new_chunk_data = ChunkData32.init();
generateChunk(&new_chunk_data);
var new_chunk = ChunkInfo {
.coord = index,
.data = new_chunk_data,
.mesh = CreateChunkMesh(ChunkData32, allocator, &new_chunk_data),
.matrix = mat4.from_translate(vec3.new(@intToFloat(f32, @intCast(u64, index.x) * ChunkData32.size_x), 0.0, @intToFloat(f32, @intCast(u64, index.y) * ChunkData32.size_z))),
};
new_chunk.data.dirty = false;
chunk_map.put(new_chunk.coord, new_chunk) catch panic("Failed to put", .{});
}
}
return Self {
.allocator = allocator,
.chunk_map = chunk_map,
};
}
pub fn deinit(self: *Self) void {
var iterator = self.chunk_map.iterator();
while (iterator.next()) |entry| {
entry.value.deinit();
}
self.chunk_map.deinit();
}
pub fn update(self: *Self, camera_pos: *vec3) void {
const stdout = std.io.getStdOut().writer();
var iterator = self.chunk_map.iterator();
while (iterator.next()) |entry| {
if (entry.value.data.isDirty()) {
stdout.print("Rebuilding Chunk!\n", .{}) catch {};
entry.value.mesh.deinit();
entry.value.mesh = CreateChunkMesh(ChunkData32, self.allocator, &entry.value.data);
entry.value.data.dirty = false;
}
}
}
pub fn render(self: *Self, matrix_uniform_index: c.GLint) void {
var iterator = self.chunk_map.iterator();
while (iterator.next()) |entry| {
//Model Matrix
c.glUniformMatrix4fv(matrix_uniform_index, 1, c.GL_FALSE, entry.value.matrix.get_data());
entry.value.mesh.draw();
}
}
// pub fn calcCollision(self: *Self, player: *TestBox) void {
// var iterator = self.chunk_map.iterator();
// while (iterator.next()) |entry| {
// }
// }
};
fn generateChunk(chunk: *ChunkData32) void {
var index: vec3i = vec3i.zero();
while (index.x < ChunkData32.size_x) : (index.x += 1) {
index.y = 0;
while (index.y < ChunkData32.size_y) : (index.y += 1) {
index.z = 0;
while (index.z < ChunkData32.size_x) : (index.z += 1) {
if (index.y == 24) {
chunk.setBlock(&index, 3);
}
else if (index.y < 24 and index.y > 18) {
chunk.setBlock(&index, 2);
}
else if (index.y <= 18) {
chunk.setBlock(&index, 1);
}
}
}
}
}
// fn testCollision(chunk: *ChunkData32) vec3 {
// var offset = vec3.zero();
// var aabb = Aabb.init(vec3.zero(), vec3.one())
// var index: vec3i = vec3i.zero();
// while (index.x < ChunkData32.size_x) : (index.x += 1) {
// index.y = 0;
// while (index.y < ChunkData32.size_y) : (index.y += 1) {
// index.z = 0;
// while (index.z < ChunkData32.size_x) : (index.z += 1) {
// if (chunk.getBlock(index) != 0) {
// }
// }
// }
// }
// return offset;
// } | src/world/world.zig |
const std = @import("std");
pub const NodeKind = enum {
string,
number,
boolean,
null_,
array,
object,
};
pub const Node = union(NodeKind) {
string: []const u8,
number: f64,
boolean: bool,
null_: void,
array: []const Node,
object: std.StringHashMap(Node),
pub fn deinit(self: *Node, allocator: *std.mem.Allocator) void {
switch (self.*) {
.string => |str| allocator.free(str),
.array => |nodes| {
var i: usize = 0;
while (i < nodes.len) {
var n = nodes[i];
n.deinit(allocator);
i += 1;
}
allocator.free(nodes);
},
.object => |*map| {
var iter = map.iterator();
while (iter.next()) |kv| {
allocator.free(kv.key_ptr.*);
kv.value_ptr.deinit(allocator);
}
map.deinit();
},
else => {},
}
}
pub fn eql(self: Node, other: Node) bool {
return switch (self) {
.string => |a| switch (other) {
.string => |b| std.mem.eql(u8, a, b),
else => false,
},
.array => |a| switch (other) {
.array => |b| {
if (a.len != b.len) {
return false;
}
var i: usize = 0;
while (i < a.len) {
if (!a[i].eql(b[i])) {
return false;
}
i += 1;
}
return true;
},
else => false,
},
.object => |a| {
var iter = a.iterator();
return switch (other) {
.object => |b| {
while (iter.next()) |kv| {
const found = b.get(kv.key_ptr.*);
if (found == null or !kv.value_ptr.eql(found.?)) {
return false;
}
}
return true;
},
else => false,
};
},
.boolean => |a| switch (other) {
.boolean => |b| a == b,
else => false,
},
.null_ => |a| switch (other) {
.null_ => true,
else => false,
},
.number => |a| switch (other) {
.number => |b| a == b,
else => return false,
},
};
}
}; | zig/node.zig |
const std = @import("std");
const Array = std.ArrayList;
fn add_indent(out_buffer : anytype, indent: usize) !void {
var i : usize = 0;
while (i < indent) : (i+=1) {
try out_buffer.append(' ');
}
}
const BfOpEnum = enum {
push,
pop,
inc,
dec,
print,
input,
open_while,
close_while,
noop
};
const BfOp = union(BfOpEnum) {
push : usize,
pop : usize,
inc : usize,
dec : usize,
print : usize,
input,
open_while,
close_while,
noop,
};
const Tokenizer = struct {
buffer : []const u8,
index : usize,
pub fn init(buffer : []const u8) Tokenizer {
return .{.buffer = buffer, .index = 0 };
}
fn count_same(self: *Tokenizer, char : u8) usize {
var count : usize = 0;
while (self.index < self.buffer.len) : (self.index += 1) {
const current_char = self.buffer[self.index];
if(current_char == char) {
count += 1;
}
else {
switch(current_char) {
'>', '<', '+', '-', '.', ',', '[', ']' => break,
else => continue
}
}
}
return count;
}
pub fn next(self: *Tokenizer) ?BfOp {
if(self.index >= self.buffer.len) {
return null;
}
const current_char = self.buffer[self.index];
switch(current_char) {
'>' => return BfOp{.push = self.count_same(current_char)},
'<' => return BfOp{.pop = self.count_same(current_char)},
'+' => return BfOp{.inc = self.count_same(current_char)},
'-' => return BfOp{.dec = self.count_same(current_char)},
'.' => return BfOp{.print = self.count_same(current_char)},
',' => {
self.index += 1;
return BfOp{.input = {}};
},
'[' => {
self.index += 1;
return BfOp{.open_while = {}};
},
']' => {
self.index += 1;
return BfOp{.close_while = {}};
},
else => {
self.index += 1;
return BfOp{.noop = {}};
}
}
}
};
const testing = std.testing;
const expectEqual = testing.expectEqual;
const expect = testing.expect;
const hello_world = @embedFile("helloworld.bf");
test "test tokenizer" {
var tokenizer = Tokenizer.init(hello_world[0..]);
try expectEqual(BfOp{.inc = 8}, tokenizer.next().?);
try expectEqual(BfOp.open_while , tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 4}, tokenizer.next().?);
try expectEqual(BfOp.open_while , tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 2}, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 3}, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 3}, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 1}, tokenizer.next().?);
try expectEqual(BfOp{.pop = 4}, tokenizer.next().?);
try expectEqual(BfOp{.dec = 1}, tokenizer.next().?);
try expectEqual(BfOp.close_while, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 1}, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 1}, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.dec = 1}, tokenizer.next().?);
try expectEqual(BfOp{.push = 2}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 1}, tokenizer.next().?);
try expectEqual(BfOp.open_while , tokenizer.next().?);
try expectEqual(BfOp{.pop = 1}, tokenizer.next().?);
try expectEqual(BfOp.close_while, tokenizer.next().?);
try expectEqual(BfOp{.pop = 1}, tokenizer.next().?);
try expectEqual(BfOp{.dec = 1}, tokenizer.next().?);
try expectEqual(BfOp.close_while, tokenizer.next().?);
try expectEqual(BfOp{.push = 2}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.dec = 3}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.inc = 7}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.inc = 3}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.push = 2}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.pop = 1}, tokenizer.next().?);
try expectEqual(BfOp{.dec = 1}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.pop = 1}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.inc = 3}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.dec = 6}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.dec = 8}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.push = 2}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 1}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expectEqual(BfOp{.push = 1}, tokenizer.next().?);
try expectEqual(BfOp{.inc = 2}, tokenizer.next().?);
try expectEqual(BfOp.print, tokenizer.next().?);
try expect(tokenizer.next() == null);
try expect(tokenizer.next() == null);
}
pub fn generate(buffer : []u8, out_buffer : *Array(u8)) !void {
const base = @embedFile("base.zig");
const linebreak : u8 = '\n';
try out_buffer.appendSlice(base);
try out_buffer.append(linebreak);
try out_buffer.appendSlice("pub fn main() !void {");
try out_buffer.append(linebreak);
try out_buffer.appendSlice(" var data : [std.math.maxInt(u16)]u8 = [1]u8{0} ** std.math.maxInt(u16);");
try out_buffer.append(linebreak);
try out_buffer.appendSlice(" var state = BrainfuckState.init(&data);");
try out_buffer.append(linebreak);
try out_buffer.append(linebreak);
try out_buffer.appendSlice("// program starts.");
try out_buffer.append(linebreak);
try out_buffer.append(linebreak);
var indent : usize = 4;
var tokenizer = Tokenizer.init(buffer);
var printer = [_]u8{0} ** 100;
while(tokenizer.next()) |result| {
if(result != BfOp.noop) {
try add_indent(out_buffer, indent);
}
switch (result) {
.push => |count| try out_buffer.appendSlice(try std.fmt.bufPrint(&printer, "state.push_data_pointer({});", .{count})),
.pop => |count| try out_buffer.appendSlice(try std.fmt.bufPrint(&printer, "state.pop_data_pointer({});", .{count})),
.inc => |count| try out_buffer.appendSlice(try std.fmt.bufPrint(&printer, "state.increment_current_data({});", .{count})),
.dec => |count| try out_buffer.appendSlice(try std.fmt.bufPrint(&printer, "state.decrement_current_data({});", .{count})),
.print => |count| try out_buffer.appendSlice(try std.fmt.bufPrint(&printer, "try state.print_current_data({});", .{count})),
.input => try out_buffer.appendSlice("try state.input_char();"),
.open_while => {
try out_buffer.append(linebreak);
try add_indent(out_buffer, indent);
try out_buffer.appendSlice("while(state.is_current_value_pointed_not_0()) {");
indent += 4;
},
.close_while => {
indent -= 4;
var i : usize = 0;
while (i < 4) : (i+=1) {
_ = out_buffer.pop();
}
try out_buffer.appendSlice("}");
try out_buffer.append(linebreak);
},
else => continue
}
try out_buffer.append(linebreak);
}
try out_buffer.append(linebreak);
try out_buffer.appendSlice("// program ends");
try out_buffer.append(linebreak);
try out_buffer.append(linebreak);
try out_buffer.append('}');
try out_buffer.append(linebreak);
} | generator.zig |
const std = @import("std");
const TaskList = std.ArrayList(Task);
const c = @cImport({
@cInclude("stdlib.h");
@cInclude("errno.h");
@cInclude("notcurses/direct.h");
});
const logger = std.log.scoped(.maid);
var logfile_optional: ?std.fs.File = null;
// based on the default std.log impl
pub fn log(
comptime message_level: std.log.Level,
comptime scope: @Type(.EnumLiteral),
comptime format: []const u8,
args: anytype,
) void {
const level_txt = comptime message_level.asText();
const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
// if no logfile, prefer stderr
//
// TODO buffered writer!
const stream = if (logfile_optional) |logfile| logfile.writer() else std.io.getStdErr().writer();
const held = std.debug.getStderrMutex().acquire();
defer held.release();
nosuspend stream.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return;
}
const ParentTaskInfo = struct {
parent_task: *Task,
child_index: usize,
parent_child_len: usize,
};
const TaskTuiState = struct {
plane: ?*c.ncplane = null,
selected: bool = false,
full_text_cstring: [256:0]u8 = undefined,
// important for scrolling up or down w/ arrow keys
previous_task: ?*Task = null,
next_task: ?*Task = null,
parent_info: ?ParentTaskInfo = null,
const Self = @This();
pub fn format(self: Self, comptime f: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = options;
if (f.len != 0) {
@compileError("Unknown format character: '" ++ f ++ "'");
}
return std.fmt.format(
writer,
"TaskTuiState{{ .full_text_cstring = {s} }}",
.{self.full_text_cstring},
);
}
};
const Task = struct {
// TODO id: u64,
text: []const u8,
completed: bool,
children: TaskList,
tui_state: TaskTuiState = .{},
const Self = @This();
pub fn unselect(self: *Self) !void {
if (!self.tui_state.selected) return error.InvalidTaskTransition;
c.ncplane_set_fg_default(self.tui_state.plane.?);
c.ncplane_set_bg_default(self.tui_state.plane.?);
if (c.ncplane_putstr_yx(self.tui_state.plane.?, 0, 0, &self.tui_state.full_text_cstring) < 0)
return error.FailedToDrawSelectedTaskText;
self.tui_state.selected = false;
}
pub fn select(self: *Self) !void {
const color_return_fg = c.ncplane_set_fg_rgb8(self.tui_state.plane.?, 0, 0, 0);
if (color_return_fg != 0) return error.FailedToSetColor;
const color_return_bg = c.ncplane_set_bg_rgb8(self.tui_state.plane.?, 255, 255, 255);
if (color_return_bg != 0) return error.FailedToSetColor;
if (c.ncplane_putstr_yx(self.tui_state.plane.?, 0, 0, &self.tui_state.full_text_cstring) < 0)
return error.FailedToDrawSelectedTaskText;
self.tui_state.selected = true;
}
pub fn addChildAtIndex(self: *Self, index: usize, new_child_task: Task) !*Task {
try self.children.insert(index, new_child_task);
return &self.children.items[index];
}
// TODO computed_priority: ?u32 = null,
};
const DrawState = struct {
x_offset: usize = 0,
y_offset: usize = 0,
maybe_current_task_child_index: ?usize = null,
maybe_current_task_parent_len: ?usize = null,
};
const SharedDrawState = struct {
maybe_previous_task: ?*Task = null,
maybe_parent_task: ?*Task = null,
};
fn draw_task_element(
parent_plane: *c.ncplane,
task: *Task,
draw_state: *DrawState,
shared_draw_state: *SharedDrawState,
parent_info: ?ParentTaskInfo,
) anyerror!usize {
var node_text_buffer: [256]u8 = undefined;
const maybe_is_end_task: ?bool = if (draw_state.maybe_current_task_child_index) |index| blk: {
break :blk index >= (draw_state.maybe_current_task_parent_len.? - 1);
} else null;
const tree_prefix = if (maybe_is_end_task) |is_end_task| blk: {
break :blk if (is_end_task) "└─" else "├─";
} else "";
const completed_text = if (task.completed) "C" else " ";
const node_text_full = try std.fmt.bufPrint(&node_text_buffer, "{s}{s}{s}", .{ tree_prefix, completed_text, task.text });
node_text_buffer[node_text_full.len] = 0;
const node_text_full_cstr: [:0]const u8 = node_text_buffer[0..node_text_full.len :0];
std.mem.copy(u8, &task.tui_state.full_text_cstring, node_text_full_cstr);
logger.debug("{s} state={}", .{ node_text_full, draw_state });
// now that we know what we're going to draw, we can create the ncplane
var nopts = std.mem.zeroes(c.ncplane_options);
nopts.y = @intCast(c_int, draw_state.y_offset);
nopts.x = @intCast(c_int, draw_state.x_offset);
nopts.rows = 1;
nopts.cols = @intCast(c_int, node_text_full_cstr.len);
var maybe_plane = c.ncplane_create(parent_plane, &nopts);
errdefer {
_ = c.ncplane_destroy(maybe_plane);
}
if (maybe_plane) |plane| {
_ = c.ncplane_set_userptr(plane, task);
task.tui_state.plane = plane;
task.tui_state.parent_info = parent_info;
if (c.ncplane_putstr_yx(plane, 0, 0, node_text_full_cstr) < 0) {
return error.FailedToPutString;
}
var old_draw_state = draw_state.*;
if (shared_draw_state.maybe_previous_task) |previous_task| {
task.tui_state.previous_task = previous_task;
previous_task.tui_state.next_task = task;
}
shared_draw_state.maybe_previous_task = task;
logger.debug("task {s} PREV {s} NEXT {s}", .{
task.text,
@as(?[]const u8, if (task.tui_state.previous_task) |previous_task| previous_task.text else null),
@as(?[]const u8, if (task.tui_state.next_task) |next_task| next_task.text else null),
});
draw_state.x_offset = 1;
draw_state.y_offset = 1;
for (task.children.items) |*child, idx| {
draw_state.maybe_current_task_child_index = idx;
draw_state.maybe_current_task_parent_len = task.children.items.len;
const is_final_task = idx >= (task.children.items.len - 1);
const old_y = draw_state.y_offset;
const child_children = try draw_task_element(plane, child, draw_state, shared_draw_state, ParentTaskInfo{
.parent_task = task,
.child_index = idx,
.parent_child_len = task.children.items.len,
});
draw_state.y_offset += child_children + 1;
const new_y = draw_state.y_offset;
const line_size = new_y - old_y;
const should_print_vertical_line = !is_final_task;
if (line_size > 1 and should_print_vertical_line) {
// always draw vertical lines as separate planes from the task plane
// so that we don't need to do really bad hacks!
var vertical_plane_options = std.mem.zeroes(c.ncplane_options);
vertical_plane_options.y = @intCast(c_int, old_y) + 1;
vertical_plane_options.x = 1;
vertical_plane_options.rows = @intCast(c_int, line_size) - 1;
vertical_plane_options.cols = 1;
var maybe_vertical_plane = c.ncplane_create(plane, &vertical_plane_options);
errdefer {
_ = c.ncplane_destroy(maybe_vertical_plane);
}
if (maybe_vertical_plane) |vertical_plane| {
var i: usize = 0;
while (i < line_size) : (i += 1) {
if (c.ncplane_putstr_yx(
vertical_plane,
@intCast(c_int, i),
@intCast(c_int, 0),
"│",
) < 0) {
return error.FailedToDrawConnectingLine;
}
}
}
}
// draw line between children
old_draw_state.y_offset += child_children;
}
draw_state.maybe_current_task_child_index = null;
draw_state.maybe_current_task_parent_len = null;
draw_state.* = old_draw_state;
}
return task.children.items.len;
}
fn destroy_task_tree(task: *Task) error{FailedToDestroyPlane}!void {
if (c.ncplane_destroy(task.tui_state.plane) < 0) return error.FailedToDestroyPlane;
task.tui_state.plane = null;
for (task.children.items) |*child| try destroy_task_tree(child);
}
fn draw_task(parent_plane: *c.ncplane, task: *Task) !*c.ncplane {
var nopts = std.mem.zeroes(c.ncplane_options);
nopts.y = 5;
nopts.x = 5;
nopts.rows = 1;
nopts.cols = 1;
var maybe_plane = c.ncplane_create(parent_plane, &nopts);
errdefer {
_ = c.ncplane_destroy(maybe_plane);
}
if (maybe_plane) |plane| {
_ = c.ncplane_set_userptr(plane, task);
const color_return = c.ncplane_set_fg_rgb8(plane, 255, 255, 255);
if (color_return != 0) return error.FailedToSetColor;
var state = DrawState{};
var shared_draw_state = SharedDrawState{};
_ = try draw_task_element(plane, task, &state, &shared_draw_state, null);
return plane;
} else {
return error.FailedToCreatePlane;
}
}
const CursorState = struct {
selected_task: ?*Task = null,
};
const Pipe = struct {
reader: std.fs.File,
writer: std.fs.File,
};
const NOTCURSES_U32_ERROR = 4294967295;
var zig_segfault_handler: fn (i32, *const std.os.siginfo_t, ?*const c_void) callconv(.C) void = undefined;
var maybe_self_pipe: ?Pipe = null;
const SignalData = extern struct {
signal: c_int,
info: std.os.siginfo_t,
uctx: ?*const c_void,
};
const SignalList = std.ArrayList(SignalData);
fn signal_handler(
signal: c_int,
info: *const std.os.siginfo_t,
uctx: ?*const c_void,
) callconv(.C) void {
if (maybe_self_pipe) |self_pipe| {
const signal_data = SignalData{
.signal = signal,
.info = info.*,
.uctx = uctx,
};
self_pipe.writer.writer().writeStruct(signal_data) catch return;
}
}
inline fn taskFromPlane(plane: *c.ncplane) ?*Task {
return @ptrCast(?*Task, @alignCast(@alignOf(Task), c.ncplane_userptr(plane)));
}
fn findClickedPlane(plane: *c.ncplane, mouse_x: i32, mouse_y: i32) ?*c.ncplane {
const abs_x = c.ncplane_abs_x(plane);
const abs_y = c.ncplane_abs_y(plane);
var rows: c_int = undefined;
var cols: c_int = undefined;
c.ncplane_dim_yx(plane, &rows, &cols);
//logger.debug(
// "\tc1 (x={d}) >= (ax={d}) = {}",
// .{ mouse_x, abs_x, mouse_x >= abs_x },
//);
//logger.debug(
// "\tc2 {d} <= {d} = {}",
// .{ mouse_x, abs_x + cols, mouse_x <= (abs_x + cols) },
//);
//logger.debug(
// "\tc1 y={d} >= ay={d} = {}",
// .{ mouse_y, abs_y, mouse_y >= abs_y },
//);
//logger.debug(
// "\tc1 {d} <= {d} = {}",
// .{ mouse_y, abs_y + rows - 1, mouse_y <= (abs_y + rows - 1) },
//);
const is_inside_plane = (mouse_x >= abs_x and mouse_x <= (abs_x + cols) and mouse_y >= abs_y and mouse_y <= (abs_y + (rows - 1)));
//logger.debug(
// "mx={d} my={d} ax={d} ay={d} cols={d} rows={d} is_inside_plane={}",
// .{ mouse_x, mouse_y, abs_x, abs_y, cols, rows, is_inside_plane },
//);
var task = taskFromPlane(plane);
//logger.debug(
// " in task={s}",
// .{task.?.text},
//);
if (is_inside_plane) {
return plane;
}
for (task.?.children.items) |child| {
var child_plane = child.tui_state.plane.?;
const possible_matched_plane = findClickedPlane(child_plane, mouse_x, mouse_y);
if (possible_matched_plane != null) return possible_matched_plane;
}
return null;
}
fn findRootTask(task: *Task) *Task {
var root_task: ?*Task = null;
var current_task: *Task = task;
while (true) {
if (current_task.tui_state.parent_info == null) {
root_task = current_task;
break;
}
current_task = current_task.tui_state.parent_info.?.parent_task;
}
return root_task.?; // must not be null
}
const MainContext = struct {
allocator: *std.mem.Allocator,
nc: *c.notcurses,
cursor_state: CursorState = .{},
root_task_plane: *c.ncplane,
standard_plane: *c.ncplane,
const Self = @This();
fn processNewSignals(self: *Self, plane: *c.ncplane) !void {
_ = self;
while (true) {
const signal_data = maybe_self_pipe.?.reader.reader().readStruct(SignalData) catch |err| switch (err) {
error.EndOfStream => break,
else => return err,
};
if (signal_data.signal == std.os.SIG.SEGV) {
zig_segfault_handler(signal_data.signal, &signal_data.info, signal_data.uctx);
} else if (signal_data.signal == std.os.SIG.URG or signal_data.signal == std.os.SIG.IO) {
// we have data on stdin!
try self.processTerminalEvents(plane);
} else {
logger.info("exiting! with signal {d}", .{signal_data.signal});
// TODO shutdown db, when we have one
std.os.exit(1);
}
}
}
fn recreateTreePlane(self: *Self, root_task: *Task) !void {
// TODO task tree should be aware of vertical lines
// for a fully working destroy
try destroy_task_tree(root_task);
if (c.notcurses_render(self.nc) < 0) return error.FailedToRender;
var new_root_plane = try draw_task(self.standard_plane, root_task);
self.root_task_plane = new_root_plane;
}
fn processTerminalEvents(self: *Self, plane: *c.ncplane) !void {
while (true) {
var inp: c.ncinput = undefined;
const character = c.notcurses_getc_nblock(self.nc, &inp);
if (character == 0) break;
logger.debug("input {}", .{inp});
if (character == NOTCURSES_U32_ERROR) {
logger.err("Error: {s}", .{c.strerror(std.c._errno().*)});
return error.FailedToGetInput;
}
//NCKEY_UP;
if (inp.id == c.NCKEY_RESIZE) {
_ = c.notcurses_refresh(self.nc, null, null);
_ = c.notcurses_render(self.nc);
} else if (inp.id == c.NCKEY_ESC) {
// if task is selected, unselect it, if not, exit program
if (self.cursor_state.selected_task) |current_selected_task| {
logger.debug("unselecting task", .{});
try current_selected_task.unselect();
self.cursor_state.selected_task = null;
_ = c.notcurses_render(self.nc);
} else {
// TODO safely exit here
}
} else if (inp.id == c.NCKEY_UP) {
logger.debug("go up", .{});
if (self.cursor_state.selected_task) |current_selected_task| {
try current_selected_task.unselect();
self.cursor_state.selected_task = null;
const maybe_previous_task = current_selected_task.tui_state.previous_task;
if (maybe_previous_task) |previous_task| {
logger.debug("going up {}", .{previous_task});
try previous_task.select();
self.cursor_state.selected_task = previous_task;
} else {
// i'm at the root task, and so, we can't do much without multiple tree support
logger.debug("top level tree, where to go?", .{});
}
_ = c.notcurses_render(self.nc);
}
} else if (inp.id == c.NCKEY_DOWN) {
logger.debug("go down", .{});
if (self.cursor_state.selected_task) |current_selected_task| {
try current_selected_task.unselect();
self.cursor_state.selected_task = null;
const maybe_next_task = current_selected_task.tui_state.next_task;
if (maybe_next_task) |next_task| {
logger.debug("going down {}", .{next_task});
try next_task.select();
self.cursor_state.selected_task = next_task;
} else {
// i'm at the last task, and so, we can't do much without multiple tree support
logger.debug("end of tree, where to go?", .{});
}
_ = c.notcurses_render(self.nc);
}
} else if (inp.id == 'L' and inp.ctrl) {
logger.info("hard redraw", .{});
_ = c.notcurses_refresh(self.nc, null, null);
_ = c.notcurses_render(self.nc);
} else if (inp.id == c.NCKEY_ENTER) {
if (self.cursor_state.selected_task) |selected_task| {
try selected_task.unselect();
self.cursor_state.selected_task = null;
const maybe_parent_info = selected_task.tui_state.parent_info;
if (maybe_parent_info) |parent_info| {
logger.info("got parent!", .{});
var new_task_list = TaskList.init(self.allocator);
var new_task_full = Task{
.text = "",
.completed = false,
.children = new_task_list,
};
// add task right after current selected's index
var new_task_ptr = try parent_info.parent_task.addChildAtIndex(
parent_info.child_index + 1,
new_task_full,
);
var root_task = findRootTask(selected_task);
try self.recreateTreePlane(root_task);
try new_task_ptr.select();
self.cursor_state.selected_task = new_task_ptr;
} else {
// TODO we are the root of the tree, create a task at the end of it
}
_ = c.notcurses_render(self.nc);
}
} else if (inp.id == '\t') {
if (self.cursor_state.selected_task) |selected_task| {
try selected_task.unselect();
self.cursor_state.selected_task = null;
var new_task_list = TaskList.init(self.allocator);
var new_task = Task{
.text = "",
.completed = false,
.children = new_task_list,
};
var new_task_ptr = try selected_task.addChildAtIndex(selected_task.children.items.len, new_task);
var root_task = findRootTask(selected_task);
try self.recreateTreePlane(root_task);
try new_task_ptr.select();
self.cursor_state.selected_task = new_task_ptr;
_ = c.notcurses_render(self.nc);
}
} else if (inp.evtype == c.NCTYPE_PRESS and inp.id == c.NCKEY_BUTTON1) {
// we got a press, we don't know if this is drag and drop (moving tasks around)
// TODO implement drag and drop!
//
// for now, assume its just selecting the task!
// TODO this is going to break when we have multiple tasks
if (self.cursor_state.selected_task) |current_selected_task| {
try current_selected_task.unselect();
self.cursor_state.selected_task = null;
}
var maybe_clicked_plane = findClickedPlane(plane, inp.x, inp.y);
if (maybe_clicked_plane) |clicked_plane| {
var clicked_task = taskFromPlane(clicked_plane).?;
try clicked_task.select();
self.cursor_state.selected_task = clicked_task;
}
_ = c.notcurses_render(self.nc);
} else if (inp.evtype == c.NCTYPE_RELEASE) {
//self.cursor_state.plane_drag = false;
} //else if (inp.evtype == c.NCTYPE_PRESS and self.cursor_state.plane_drag == true) {
// _ = c.ncplane_move_yx(plane, inp.y, inp.x);
// _ = c.notcurses_render(self.nc);
//}
}
}
};
pub fn main() anyerror!void {
// configure requirements for signal handling
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer {
_ = gpa.deinit();
}
const allocator = &gpa.allocator;
const self_pipe_fds = try std.os.pipe();
maybe_self_pipe = .{
.reader = .{ .handle = self_pipe_fds[0] },
.writer = .{ .handle = self_pipe_fds[1] },
};
defer {
maybe_self_pipe.?.reader.close();
maybe_self_pipe.?.writer.close();
}
// initialize the logfile, if given in LOGFILE env var
const maybe_logfile_path = std.os.getenv("LOGFILE");
if (maybe_logfile_path) |logfile_path| {
logfile_optional = try std.fs.cwd().createFile(
logfile_path,
.{ .truncate = true, .read = false },
);
}
defer {
if (logfile_optional) |logfile| logfile.close();
}
// configure signal handler
// Zig attaches a handler to SIGSEGV to provide pretty output on segfaults,
// but we also want to attach our own shutdown code to other signals
// like SIGINT, SIGTERM, etc.
//
// there can only be one signal handler declared in the system, so we
// need to extract the zig signal handler, and call it on our own
//
// notcurses will do the same behavior but for the signal handler we
// provide, so everything has a way to shutdown safely.
//
// NOTE: do not trust your engineering skills on safely shutting down
// on a SIGSEGV. even on maid's signal handler, only signals we actually
// want cause a safe DB shutdown.
//
// Engineer to always be safe, even on a hard power off.
//
// Our signal handler uses the self-pipe trick to provide DB shutdown
// on a CTRL-C while also mainaining overall non-blocking I/O structure
// in code.
var mask = std.os.empty_sigset;
// only linux and darwin implement sigaddset() on zig stdlib. huh.
std.os.linux.sigaddset(&mask, std.os.SIG.TERM);
std.os.linux.sigaddset(&mask, std.os.SIG.INT);
std.os.linux.sigaddset(&mask, std.os.SIG.URG);
std.os.linux.sigaddset(&mask, std.os.SIG.IO);
var sa = std.os.Sigaction{
.handler = .{ .sigaction = signal_handler },
.mask = mask,
.flags = 0,
};
// declare handler for SIGSEGV, catching the "old" one
// (zig sets its own BEFORE calling main(), see lib/std/start.zig)
var old_sa: std.os.Sigaction = undefined;
std.os.sigaction(std.os.SIG.SEGV, &sa, &old_sa);
zig_segfault_handler = old_sa.handler.sigaction.?;
std.os.sigaction(std.os.SIG.TERM, &sa, null);
std.os.sigaction(std.os.SIG.INT, &sa, null);
std.os.sigaction(std.os.SIG.URG, &sa, null);
std.os.sigaction(std.os.SIG.IO, &sa, null);
std.log.info("boot!", .{});
var nopts = std.mem.zeroes(c.notcurses_options);
nopts.flags = c.NCOPTION_NO_ALTERNATE_SCREEN;
nopts.flags |= c.NCOPTION_SUPPRESS_BANNERS;
var nc_opt = c.notcurses_init(&nopts, c.stdout);
if (nc_opt == null) return error.NoNotcursesContextProvided;
var nc = nc_opt.?;
defer {
_ = c.notcurses_stop(nc);
}
const mouse_enabled_return = c.notcurses_mouse_enable(nc);
if (mouse_enabled_return != 0) return error.FailedToEnableMouse;
var dimy: i32 = undefined;
var dimx: i32 = undefined;
var stdplane = c.notcurses_stddim_yx(nc, &dimy, &dimx).?;
var empty_children = TaskList.init(allocator);
defer empty_children.deinit();
const third_children_items = [_]Task{
.{
.text = "doubly nested subtask 1",
.completed = false,
.children = empty_children,
},
.{
.text = "doubly nested subtask 2",
.completed = true,
.children = empty_children,
},
.{
.text = "doubly nested subtask 3",
.completed = false,
.children = empty_children,
},
};
var third_children = TaskList.init(allocator);
defer third_children.deinit();
try third_children.appendSlice(&third_children_items);
var third_children_2 = TaskList.init(allocator);
defer third_children_2.deinit();
try third_children_2.appendSlice(&third_children_items);
var third_children_3 = TaskList.init(allocator);
defer third_children_3.deinit();
try third_children_3.appendSlice(&third_children_items);
const fourth_children_items = [_]Task{
.{
.text = "",
.completed = false,
.children = empty_children,
},
.{
.text = "",
.completed = true,
.children = empty_children,
},
.{
.text = "",
.completed = false,
.children = third_children_2,
},
};
var fourth_children = TaskList.init(allocator);
defer fourth_children.deinit();
try fourth_children.appendSlice(&fourth_children_items);
var second_children = TaskList.init(allocator);
defer second_children.deinit();
try second_children.appendSlice(&[_]Task{
.{
.text = "nested subtask 1",
.completed = false,
.children = empty_children,
},
.{
.text = "nested subtask 2",
.completed = false,
.children = third_children,
},
.{
.text = "nested subtask 3",
.completed = false,
.children = fourth_children,
},
.{
.text = "nested subtask 4",
.completed = false,
.children = empty_children,
},
});
var first_children = TaskList.init(allocator);
defer first_children.deinit();
try first_children.appendSlice(&[_]Task{
.{
.text = "subtask 1",
.completed = false,
.children = third_children_3,
},
.{
.text = "subtask 2",
.completed = true,
.children = second_children,
},
.{
.text = "subtask 3",
.completed = false,
.children = empty_children,
},
});
var root_task = Task{
.text = "test task!",
.completed = false,
.children = first_children,
};
var plane = try draw_task(stdplane, &root_task);
_ = c.notcurses_render(nc);
// our main loop is basically polling for stdin and the signal selfpipe.
//
// if stdin has data, let notcurses consume it, keep it in a loop so
// all possible events are consumed, instead of a single one (which would
// cause drift)
//
// if signal selfpipe has data, consume it from the signal queue.
// if we get a SIGSEGV, call zig_segfault_handler
const PollFdList = std.ArrayList(std.os.pollfd);
var sockets = PollFdList.init(allocator);
defer sockets.deinit();
const stdin_fd = std.io.getStdIn().handle;
//try sockets.append(std.os.pollfd{
// .fd = stdin_fd,
// .events = std.os.POLL.IN,
// .revents = 0,
//});
_ = try std.os.fcntl(stdin_fd, std.os.F.SETFL, std.os.O.ASYNC);
_ = try std.os.fcntl(stdin_fd, std.os.F.SETOWN, @intCast(usize, std.os.linux.getpid()));
try sockets.append(std.os.pollfd{
.fd = maybe_self_pipe.?.reader.handle,
.events = std.os.POLL.IN,
.revents = 0,
});
var ctx = MainContext{
.nc = nc,
.allocator = allocator,
.root_task_plane = plane,
.standard_plane = stdplane,
};
// TODO logging main() errors back to logger handler
while (true) {
logger.info("poll!", .{});
const available = try std.os.poll(sockets.items, -1);
try std.testing.expect(available > 0);
for (sockets.items) |pollfd| {
logger.info("fd {d} has revents {d}", .{ pollfd.fd, pollfd.revents });
if (pollfd.revents == 0) continue;
// signals have higher priority, as if we got a SIGTERM,
// notcurses WILL have destroyed its context and resetted the
// terminal to a good state, which means we must not render shit.
if (pollfd.fd == maybe_self_pipe.?.reader.handle) {
try ctx.processNewSignals(plane);
}
//if (pollfd.fd == stdin_fd) {
// try ctx.processTerminalEvents(plane);
//}
}
}
} | src/main.zig |
const Elf = @This();
const std = @import("std");
const bits = @import("bits.zig");
const assert = std.debug.assert;
const elf = std.elf;
const fmt = std.fmt;
const fs = std.fs;
const log = std.log.scoped(.zelf);
const mem = std.mem;
const Allocator = mem.Allocator;
allocator: *Allocator,
file: fs.File,
header: elf.Header = undefined,
shdrs: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .{},
phdrs: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .{},
shstrtab: std.ArrayListUnmanaged(u8) = .{},
symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},
strtab: std.ArrayListUnmanaged(u8) = .{},
dynsymtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},
dynstrtab: std.ArrayListUnmanaged(u8) = .{},
symtab_index: ?u16 = null,
strtab_index: ?u16 = null,
dynsymtab_index: ?u16 = null,
dynstrtab_index: ?u16 = null,
pub fn init(allocator: *Allocator, file: fs.File) Elf {
return .{
.allocator = allocator,
.file = file,
};
}
pub fn deinit(self: *Elf) void {
self.shdrs.deinit(self.allocator);
self.phdrs.deinit(self.allocator);
self.shstrtab.deinit(self.allocator);
self.symtab.deinit(self.allocator);
self.strtab.deinit(self.allocator);
self.dynsymtab.deinit(self.allocator);
self.dynstrtab.deinit(self.allocator);
}
pub fn parseMetadata(self: *Elf) !void {
self.header = try elf.Header.read(self.file);
// Parse section headers
{
try self.shdrs.ensureTotalCapacity(self.allocator, self.header.shnum);
var it = self.header.section_header_iterator(self.file);
var ndx: u16 = 0;
while (try it.next()) |shdr| {
switch (shdr.sh_type) {
elf.SHT_SYMTAB => {
if (self.symtab_index != null) {
// According to the UNIX System V release 4, there can only be one symtab per ELF file.
log.err("Two symtabs detected in one file", .{});
return error.MultipleSymtabs;
}
self.symtab_index = ndx;
},
elf.SHT_DYNSYM => {
if (self.dynsymtab_index != null) {
// According to the UNIX System V release 4, there can only be one dynsym per ELF file.
log.err("Two dynsyms detected in one file", .{});
return error.MultipleDynsyms;
}
self.dynsymtab_index = ndx;
},
else => {},
}
self.shdrs.appendAssumeCapacity(shdr);
ndx += 1;
}
}
// Parse program headers
{
try self.phdrs.ensureTotalCapacity(self.allocator, self.header.phnum);
var it = self.header.program_header_iterator(self.file);
while (try it.next()) |phdr| {
self.phdrs.appendAssumeCapacity(phdr);
}
}
// Parse shstrtab
{
var buffer = try self.readShdrContents(self.header.shstrndx);
defer self.allocator.free(buffer);
try self.shstrtab.appendSlice(self.allocator, buffer);
}
// Parse symtab and matching strtab
if (self.symtab_index) |ndx| {
const shdr = self.shdrs.items[ndx];
var raw_symtab = try self.readShdrContents(ndx);
defer self.allocator.free(raw_symtab);
// TODO non-native endianness
if (self.header.is_64) {
const syms = @alignCast(@alignOf(elf.Elf64_Sym), mem.bytesAsSlice(elf.Elf64_Sym, raw_symtab));
try self.symtab.appendSlice(self.allocator, syms);
} else {
const nsyms = @divExact(shdr.sh_size, shdr.sh_entsize);
try self.symtab.ensureUnusedCapacity(self.allocator, nsyms);
const syms = @alignCast(@alignOf(elf.Elf32_Sym), mem.bytesAsSlice(elf.Elf32_Sym, raw_symtab));
for (syms) |sym| {
self.symtab.appendAssumeCapacity(.{
.st_name = sym.st_name,
.st_info = sym.st_info,
.st_other = sym.st_other,
.st_shndx = sym.st_shndx,
.st_value = sym.st_value,
.st_size = sym.st_size,
});
}
}
self.strtab_index = @intCast(u16, shdr.sh_link);
var raw_strtab = try self.readShdrContents(shdr.sh_link);
defer self.allocator.free(raw_strtab);
try self.strtab.appendSlice(self.allocator, raw_strtab);
}
// Parse dynsymtab and matching dynstrtab
if (self.dynsymtab_index) |ndx| {
const shdr = self.shdrs.items[ndx];
var raw_dynsym = try self.readShdrContents(ndx);
defer self.allocator.free(raw_dynsym);
// TODO non-native endianness
if (self.header.is_64) {
const syms = @alignCast(@alignOf(elf.Elf64_Sym), mem.bytesAsSlice(elf.Elf64_Sym, raw_dynsym));
try self.dynsymtab.appendSlice(self.allocator, syms);
} else {
const nsyms = @divExact(shdr.sh_size, shdr.sh_entsize);
try self.dynsymtab.ensureUnusedCapacity(self.allocator, nsyms);
const syms = @alignCast(@alignOf(elf.Elf32_Sym), mem.bytesAsSlice(elf.Elf32_Sym, raw_dynsym));
for (syms) |sym| {
self.dynsymtab.appendAssumeCapacity(.{
.st_name = sym.st_name,
.st_info = sym.st_info,
.st_other = sym.st_other,
.st_shndx = sym.st_shndx,
.st_value = sym.st_value,
.st_size = sym.st_size,
});
}
}
self.dynstrtab_index = @intCast(u16, shdr.sh_link);
var raw_strtab = try self.readShdrContents(shdr.sh_link);
defer self.allocator.free(raw_strtab);
try self.dynstrtab.appendSlice(self.allocator, raw_strtab);
}
}
pub fn printHeader(self: Elf, writer: anytype) !void {
try writer.print("ELF Header:\n", .{});
try writer.print(" Endianness: {s}\n", .{self.header.endian});
try writer.print(" Machine: {s}\n", .{(&switch (self.header.machine) {
._NONE => "none",
._M32 => "AT&T WE 32100",
._AARCH64 => "ARM Aarch64",
._X86_64 => "AMD x86-64 architecture",
else => "unknown",
}).*});
try writer.print(" Class: {s}\n", .{(&if (self.header.is_64) "ELF64" else "ELF32").*});
try writer.print(" Entry point address: 0x{x}\n", .{self.header.entry});
try writer.print(" Start of program headers: {d} (bytes into file)\n", .{self.header.phoff});
try writer.print(" Start of section headers: {d} (bytes into file)\n", .{self.header.shoff});
try writer.print(" Size of program headers: {d} (bytes)\n", .{self.header.phentsize});
try writer.print(" Number of program headers: {d}\n", .{self.header.phnum});
try writer.print(" Size of section headers: {d} (bytes)\n", .{self.header.shentsize});
try writer.print(" Number of section headers: {d}\n", .{self.header.shnum});
try writer.print(" Section header string table index: {d}\n", .{self.header.shstrndx});
}
pub fn printShdrs(self: Elf, writer: anytype) !void {
try writer.print("There are {d} section headers, starting at offset 0x{x}:\n\n", .{
self.header.shnum,
self.header.shoff,
});
try writer.print("Section Headers:\n", .{});
try writer.print(" [Nr] Name{s: <14}Type{s: <14}Address{s: <11}Offset\n", .{ "", "", "" });
try writer.print(" Size{s: <14}EntSize{s: <11}Flags Link Info Align\n", .{ "", "" });
var arena = std.heap.ArenaAllocator.init(self.allocator);
defer arena.deinit();
const alloc = &arena.allocator;
for (self.shdrs.items) |shdr, i| {
const sh_name = self.getShString(shdr.sh_name);
const sh_type = (&switch (shdr.sh_type) {
elf.SHT_NULL => "NULL",
elf.SHT_PROGBITS => "PROGBITS",
elf.SHT_SYMTAB => "SYMTAB",
elf.SHT_STRTAB => "STRTAB",
elf.SHT_RELA => "RELA",
elf.SHT_HASH => "HASH",
elf.SHT_DYNAMIC => "DYNAMIC",
elf.SHT_NOTE => "NOTE",
elf.SHT_NOBITS => "NOBITS",
elf.SHT_REL => "REL",
elf.SHT_SHLIB => "SHLIB",
elf.SHT_DYNSYM => "DYNSYM",
elf.SHT_INIT_ARRAY => "INIT_ARRAY",
elf.SHT_FINI_ARRAY => "FINI_ARRAY",
elf.SHT_PREINIT_ARRAY => "PREINIT_ARRAY",
elf.SHT_GROUP => "GROUP",
elf.SHT_SYMTAB_SHNDX => "SYMTAB_SHNDX",
else => |sht| blk: {
if (elf.SHT_LOOS <= sht and sht < elf.SHT_HIOS) {
break :blk try fmt.allocPrint(alloc, "LOOS+0x{x}", .{sht - elf.SHT_LOOS});
}
if (elf.SHT_LOPROC <= sht and sht < elf.SHT_HIPROC) {
break :blk try fmt.allocPrint(alloc, "LOPROC+0x{x}", .{sht - elf.SHT_LOPROC});
}
if (elf.SHT_LOUSER <= sht and sht < elf.SHT_HIUSER) {
break :blk try fmt.allocPrint(alloc, "LOUSER+0x{x}", .{sht - elf.SHT_LOUSER});
}
break :blk "UNKNOWN";
},
}).*;
const flags = blk: {
var flags = std.ArrayList(u8).init(alloc);
if (elf.SHF_WRITE & shdr.sh_flags != 0) {
try flags.append('W');
}
if (elf.SHF_ALLOC & shdr.sh_flags != 0) {
try flags.append('A');
}
if (elf.SHF_EXECINSTR & shdr.sh_flags != 0) {
try flags.append('X');
}
if (elf.SHF_MERGE & shdr.sh_flags != 0) {
try flags.append('M');
}
if (elf.SHF_STRINGS & shdr.sh_flags != 0) {
try flags.append('S');
}
if (elf.SHF_INFO_LINK & shdr.sh_flags != 0) {
try flags.append('I');
}
if (elf.SHF_LINK_ORDER & shdr.sh_flags != 0) {
try flags.append('L');
}
if (elf.SHF_EXCLUDE & shdr.sh_flags != 0) {
try flags.append('E');
}
// TODO parse more flags
break :blk flags.toOwnedSlice();
};
try writer.print(" [{d: >2}] {s: <16} {s: <16} {x:0>16} {x:0>16}\n", .{
i,
sh_name,
sh_type,
shdr.sh_addr,
shdr.sh_offset,
});
try writer.print(" {x:0>16} {x:0>16} {s: <5} {d: >4} {d: >4} {d: >4}\n", .{
shdr.sh_size,
shdr.sh_entsize,
flags,
shdr.sh_link,
shdr.sh_info,
shdr.sh_addralign,
});
}
}
pub fn printPhdrs(self: Elf, writer: anytype) !void {
if (self.phdrs.items.len == 0) {
try writer.print("There are no program headers in this file.\n", .{});
return;
}
try writer.print("Entry point 0x{x}\n", .{self.header.entry});
try writer.print("There are {d} program headers, starting at offset {d}\n\n", .{
self.phdrs.items.len,
self.header.phoff,
});
try writer.print("Program Headers:\n", .{});
try writer.print(" Type{s: <12} Offset{s: <10} VirtAddr{s: <8} PhysAddr{s: <8}\n", .{ "", "", "", "" });
try writer.print(" {s: <16} FileSiz{s: <9} MemSiz{s: <10} Flags Align\n", .{ "", "", "" });
var arena = std.heap.ArenaAllocator.init(self.allocator);
defer arena.deinit();
const alloc = &arena.allocator;
var section_to_segment = try alloc.alloc(std.ArrayList(usize), self.phdrs.items.len);
for (self.phdrs.items) |_, i| {
section_to_segment[i] = std.ArrayList(usize).init(alloc);
}
for (self.phdrs.items) |phdr, i| {
const p_type = (&switch (phdr.p_type) {
elf.PT_NULL => "NULL",
elf.PT_LOAD => "LOAD",
elf.PT_DYNAMIC => "DYNAMIC",
elf.PT_INTERP => "INTERP",
elf.PT_NOTE => "NOTE",
elf.PT_SHLIB => "SHLIB",
elf.PT_PHDR => "PHDR",
elf.PT_TLS => "TLS",
elf.PT_NUM => "NUM",
elf.PT_GNU_EH_FRAME => "GNU_EH_FRAME",
elf.PT_GNU_STACK => "GNU_STACK",
elf.PT_GNU_RELRO => "GNU_RELRO",
else => |pt| blk: {
if (elf.PT_LOOS <= pt and pt < elf.PT_HIOS) {
break :blk try fmt.allocPrint(alloc, "LOOS+0x{x}", .{pt - elf.PT_LOOS});
}
if (elf.PT_LOPROC <= pt and pt < elf.PT_HIPROC) {
break :blk try fmt.allocPrint(alloc, "LOPROC+0x{x}", .{pt - elf.PT_LOPROC});
}
break :blk "UNKNOWN";
},
}).*;
const p_flags = blk: {
var p_flags = std.ArrayList(u8).init(alloc);
if (phdr.p_flags & elf.PF_R != 0) {
try p_flags.append('R');
}
if (phdr.p_flags & elf.PF_W != 0) {
try p_flags.append('W');
}
if (phdr.p_flags & elf.PF_X != 0) {
try p_flags.append('E');
}
if (phdr.p_flags & elf.PF_MASKOS != 0) {
try p_flags.appendSlice("OS");
}
if (phdr.p_flags & elf.PF_MASKPROC != 0) {
try p_flags.appendSlice("PROC");
}
break :blk p_flags.toOwnedSlice();
};
try writer.print(" {s: <16} {x:0>16} {x:0>16} {x:0>16}\n", .{
p_type,
phdr.p_offset,
phdr.p_vaddr,
phdr.p_paddr,
});
try writer.print(" {s: >16} {x:0>16} {x:0>16} {s: <6} {x:0>6}\n", .{
"",
phdr.p_filesz,
phdr.p_memsz,
p_flags,
phdr.p_align,
});
const start_addr = phdr.p_vaddr;
const end_addr = start_addr + phdr.p_memsz;
for (self.shdrs.items) |shdr, j| {
if (start_addr <= shdr.sh_addr and shdr.sh_addr < end_addr) {
try section_to_segment[i].append(j);
}
}
}
try writer.writeAll("\n");
try writer.print(" Section to Segment mapping:\n", .{});
try writer.print(" Segment Sections...\n", .{});
for (section_to_segment) |ss, i| {
try writer.print(" {d:0>2} ", .{i});
for (ss.items) |shdr_ndx, x| {
const shdr = self.shdrs.items[shdr_ndx];
const shdr_name = self.getShString(shdr.sh_name);
try writer.print("{s}", .{shdr_name});
if (x < ss.items.len - 1) {
try writer.writeAll(" ");
}
}
try writer.writeAll("\n");
}
}
pub fn printRelocs(self: Elf, writer: anytype) !void {
var has_relocs = false;
for (self.shdrs.items) |shdr, i| {
switch (shdr.sh_type) {
elf.SHT_REL, elf.SHT_RELA => {},
else => continue,
}
has_relocs = true;
var buffer = try self.readShdrContents(@intCast(u16, i));
defer self.allocator.free(buffer);
const nrelocs = @divExact(shdr.sh_size, shdr.sh_entsize);
var relocs = try self.allocator.alloc(elf.Elf64_Rela, nrelocs);
defer self.allocator.free(relocs);
if (self.header.is_64) {
// TODO non-native endianness
if (shdr.sh_type == elf.SHT_REL) {
var code = try self.readShdrContents(shdr.sh_info);
defer self.allocator.free(code);
const slice = @alignCast(
@alignOf(elf.Elf64_Rel),
mem.bytesAsSlice(elf.Elf64_Rel, buffer),
);
// Parse relocs addend from inst and convert into Elf64_Rela
for (slice) |rel, rel_i| {
var out_rel = elf.Elf64_Rela{
.r_offset = rel.r_offset,
.r_info = rel.r_info,
.r_addend = 0,
};
const r_addend: i64 = addend: {
switch (out_rel.r_type()) {
elf.R_X86_64_64 => {
const in_inst = code[out_rel.r_offset..][0..8];
break :addend mem.readIntSliceLittle(i64, in_inst);
},
elf.R_X86_64_32 => {
const in_inst = code[out_rel.r_offset..][0..4];
break :addend mem.readIntSliceLittle(i32, in_inst);
},
else => break :addend 0, // TODO
}
};
out_rel.r_addend = r_addend;
relocs[rel_i] = out_rel;
}
} else {
const slice = @alignCast(
@alignOf(elf.Elf64_Rela),
mem.bytesAsSlice(elf.Elf64_Rela, buffer),
);
mem.copy(elf.Elf64_Rela, relocs, slice);
}
} else {
// TODO non-native endianness
if (shdr.sh_type == elf.SHT_REL) {
_ = @alignCast(
@alignOf(elf.Elf32_Rel),
mem.bytesAsSlice(elf.Elf32_Rel, buffer),
);
} else {
_ = @alignCast(
@alignOf(elf.Elf32_Rela),
mem.bytesAsSlice(elf.Elf32_Rela, buffer),
);
}
}
try writer.print("Relocation section '{s}' at offset 0x{x} contains {d} entries:\n", .{
self.getShString(shdr.sh_name),
shdr.sh_offset,
nrelocs,
});
try writer.print(
" Offset{s: <8}Info{s: <12}Type{s: <20}Sym. Value{s: <2}Sym. Name + Addend\n",
.{ "", "", "", "" },
);
for (relocs) |reloc| {
const r_sym = reloc.r_info >> 32;
var sym: elf.Elf64_Sym = undefined;
var sym_name: []const u8 = undefined;
if (self.symtab_index != null and shdr.sh_link == self.symtab_index.?) {
sym = self.symtab.items[r_sym];
sym_name = getString(self.strtab.items, sym.st_name);
} else if (self.dynsymtab_index != null and shdr.sh_link == self.dynsymtab_index.?) {
sym = self.dynsymtab.items[r_sym];
sym_name = getString(self.dynstrtab.items, sym.st_name);
} else unreachable;
const r_type = @truncate(u32, reloc.r_info);
const rel_type = &switch (r_type) {
bits.R_X86_64_NONE => "R_X86_64_NONE",
bits.R_X86_64_64 => "R_X86_64_64",
bits.R_X86_64_PC32 => "R_X86_64_PC32",
bits.R_X86_64_GOT32 => "R_X86_64_GOT32",
bits.R_X86_64_PLT32 => "R_X86_64_PLT32",
bits.R_X86_64_COPY => "R_X86_64_COPY",
bits.R_X86_64_GLOB_DAT => "R_X86_64_GLOB_DAT",
bits.R_X86_64_JUMP_SLOT => "R_X86_64_JUMP_SLOT",
bits.R_X86_64_RELATIVE => "R_X86_64_RELATIVE",
bits.R_X86_64_GOTPCREL => "R_X86_64_GOTPCREL",
bits.R_X86_64_32 => "R_X86_64_32",
bits.R_X86_64_32S => "R_X86_64_32S",
bits.R_X86_64_16 => "R_X86_64_16",
bits.R_X86_64_PC16 => "R_X86_64_PC16",
bits.R_X86_64_8 => "R_X86_64_8",
bits.R_X86_64_PC8 => "R_X86_64_PC8",
bits.R_X86_64_DTPMOD64 => "R_X86_64_DTPMOD64",
bits.R_X86_64_DTPOFF64 => "R_X86_64_DTPOFF64",
bits.R_X86_64_TPOFF64 => "R_X86_64_TPOFF64",
bits.R_X86_64_TLSGD => "R_X86_64_TLSGD",
bits.R_X86_64_TLSLD => "R_X86_64_TLSLD",
bits.R_X86_64_DTPOFF32 => "R_X86_64_DTPOFF32",
bits.R_X86_64_GOTTPOFF => "R_X86_64_GOTTPOFF",
bits.R_X86_64_TPOFF32 => "R_X86_64_TPOFF32",
bits.R_X86_64_PC64 => "R_X86_64_PC64",
bits.R_X86_64_GOTOFF64 => "R_X86_64_GOTOFF64",
bits.R_X86_64_GOTPC32 => "R_X86_64_GOTPC32",
bits.R_X86_64_GOT64 => "R_X86_64_GOT64",
bits.R_X86_64_GOTPCREL64 => "R_X86_64_GOTPCREL64",
bits.R_X86_64_GOTPC64 => "R_X86_64_GOTPC64",
bits.R_X86_64_GOTPLT64 => "R_X86_64_GOTPLT64",
bits.R_X86_64_PLTOFF64 => "R_X86_64_PLTOFF64",
bits.R_X86_64_SIZE32 => "R_X86_64_SIZE32",
bits.R_X86_64_SIZE64 => "R_X86_64_SIZE64",
bits.R_X86_64_GOTPC32_TLSDESC => "R_X86_64_GOTPC32_TLSDESC",
bits.R_X86_64_TLSDESC_CALL => "R_X86_64_TLSDESC_CALL",
bits.R_X86_64_TLSDESC => "R_X86_64_TLSDESC",
bits.R_X86_64_IRELATIVE => "R_X86_64_IRELATIVE",
bits.R_X86_64_RELATIVE64 => "R_X86_64_RELATIVE64",
bits.R_X86_64_GOTPCRELX => "R_X86_64_GOTPCRELX",
bits.R_X86_64_REX_GOTPCRELX => "R_X86_64_REX_GOTPCRELX",
bits.R_X86_64_NUM => "R_X86_64_NUM",
else => "UNKNOWN",
};
try writer.print("{x:0>12} {x:0>12} {s: <24} {x:0>16} {s} {d}\n", .{
reloc.r_offset,
reloc.r_info,
rel_type.*,
sym.st_value,
sym_name,
reloc.r_addend,
});
}
try writer.print("\n", .{});
}
if (!has_relocs) {
try writer.print("There is no relocation info in this file.\n", .{});
}
}
pub fn printSymtabs(self: Elf, writer: anytype) !void {
if (self.symtab_index == null and self.dynsymtab_index == null) {
try writer.print("There is no symbol table in this file.", .{});
return;
}
if (self.symtab_index) |ndx| {
try self.printSymtab(ndx, self.symtab.items, self.strtab.items, writer);
try writer.print("\n", .{});
}
if (self.dynsymtab_index) |ndx| {
try self.printSymtab(ndx, self.dynsymtab.items, self.dynstrtab.items, writer);
try writer.print("\n", .{});
}
}
fn printSymtab(self: Elf, shdr_ndx: u16, symtab: []const elf.Elf64_Sym, strtab: []const u8, writer: anytype) !void {
const shdr = self.shdrs.items[shdr_ndx];
try writer.print("Symbol table '{s}' contains {d} entries:\n", .{
self.getShString(shdr.sh_name),
symtab.len,
});
try writer.print(
" Num:{s: <12}Value{s: <2}Size Type{s: <3} Bind{s: <2} Vis{s: <5} Ndx{s: <2} Name\n",
.{ "", "", "", "", "", "" },
);
var arena = std.heap.ArenaAllocator.init(self.allocator);
defer arena.deinit();
const alloc = &arena.allocator;
for (symtab) |sym, i| {
const sym_name = getString(strtab, sym.st_name);
const sym_type = (&switch (sym.st_info & 0xf) {
elf.STT_NOTYPE => "NOTYPE",
elf.STT_OBJECT => "OBJECT",
elf.STT_FUNC => "FUNC",
elf.STT_SECTION => "SECTION",
elf.STT_FILE => "FILE",
elf.STT_COMMON => "COMMON",
elf.STT_TLS => "TLS",
elf.STT_NUM => "NUM",
else => |tt| blk: {
if (elf.STT_LOPROC <= tt and tt < elf.STT_HIPROC) {
break :blk try fmt.allocPrint(alloc, "LOPROC+{d}", .{tt - elf.STT_LOPROC});
}
if (elf.STT_LOOS <= tt and tt < elf.STT_HIOS) {
break :blk try fmt.allocPrint(alloc, "LOOS+{d}", .{tt - elf.STT_LOOS});
}
break :blk "UNK";
},
}).*;
const sym_bind = (&switch (sym.st_info >> 4) {
elf.STB_LOCAL => "LOCAL",
elf.STB_GLOBAL => "GLOBAL",
elf.STB_WEAK => "WEAK",
elf.STB_NUM => "NUM",
else => |bind| blk: {
if (elf.STB_LOPROC <= bind and bind < elf.STB_HIPROC) {
break :blk try fmt.allocPrint(alloc, "LOPROC+{d}", .{bind - elf.STB_LOPROC});
}
if (elf.STB_LOOS <= bind and bind < elf.STB_HIOS) {
break :blk try fmt.allocPrint(alloc, "LOOS+{d}", .{bind - elf.STB_LOOS});
}
break :blk "UNKNOWN";
},
}).*;
const sym_vis = (&if (sym.st_other == 0) "DEFAULT" else "UNKNOWN").*;
const sym_ndx = blk: {
if (bits.SHN_LORESERVE <= sym.st_shndx and sym.st_shndx < bits.SHN_HIRESERVE) {
if (bits.SHN_LOPROC <= sym.st_shndx and sym.st_shndx < bits.SHN_HIPROC) {
break :blk try fmt.allocPrint(alloc, "LO+{d}", .{sym.st_shndx - bits.SHN_LOPROC});
}
const sym_ndx = &switch (sym.st_shndx) {
bits.SHN_ABS => "ABS",
bits.SHN_COMMON => "COM",
bits.SHN_LIVEPATCH => "LIV",
else => "UNK",
};
break :blk sym_ndx.*;
} else if (sym.st_shndx == bits.SHN_UNDEF) {
break :blk "UND";
}
break :blk try fmt.allocPrint(alloc, "{d}", .{sym.st_shndx});
};
try writer.print(
" {d: >3}: {x:0<16} {d: >5} {s: <7} {s: <6} {s: <8} {s: <5} {s}\n",
.{ i, sym.st_value, sym.st_size, sym_type, sym_bind, sym_vis, sym_ndx, sym_name },
);
}
}
fn getShString(self: Elf, off: u32) []const u8 {
assert(off < self.shstrtab.items.len);
return mem.spanZ(@ptrCast([*:0]const u8, self.shstrtab.items.ptr + off));
}
fn getString(strtab: []const u8, off: u32) []const u8 {
assert(off < strtab.len);
return mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + off));
}
fn readShdrContents(self: Elf, shdr_index: u32) ![]u8 {
const shdr = self.shdrs.items[shdr_index];
var buffer = try self.allocator.alloc(u8, shdr.sh_size);
const amt = try self.file.preadAll(buffer, shdr.sh_offset);
assert(amt == buffer.len);
return buffer;
} | src/Elf.zig |
const std = @import("std");
const pkmn = @import("pkmn");
// https://en.wikipedia.org/wiki/ANSI_escape_code
pub const ANSI = struct {
pub const RED = "\x1b[31m";
pub const RESET = "\x1b[0m";
};
const Tool = enum {
bide,
confusion,
chance,
crit,
damage,
disable,
distribution,
metronome,
rampage,
seed,
sleep,
thrash,
};
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
if (args.len < 2) usageAndExit(args[0]);
const err = std.io.getStdErr().writer();
const out = std.io.getStdOut();
var buf = std.io.bufferedWriter(out.writer());
var w = buf.writer();
const tool: Tool = std.meta.stringToEnum(Tool, args[1]) orelse usageAndExit(args[0]);
var param: u64 = undefined;
switch (tool) {
.chance => {
if (args.len != 3) {
err.print("Usage: {s} chance <N>\n", .{args[0]}) catch {};
std.process.exit(1);
}
param = std.fmt.parseUnsigned(u8, args[2], 10) catch {
err.print("Usage: {s} chance <N>\n", .{args[0]}) catch {};
std.process.exit(1);
};
},
.crit => {
if (args.len != 3) {
err.print("Usage: {s} crit <Species>\n", .{args[0]}) catch {};
std.process.exit(1);
}
const crit = std.meta.stringToEnum(pkmn.gen1.Species, args[2]) orelse {
err.print("Usage: {s} crit <Species>\n", .{args[0]}) catch {};
std.process.exit(1);
};
param = pkmn.gen1.Species.chance(crit);
},
.metronome => {
if (args.len != 3) {
err.print("Usage: {s} metronome <Move>\n", .{args[0]}) catch {};
std.process.exit(1);
}
const metronome = std.meta.stringToEnum(pkmn.gen1.Move, args[2]) orelse {
err.print("Usage: {s} metronome <Move>\n", .{args[0]}) catch {};
std.process.exit(1);
};
param = @enumToInt(metronome);
const invalid = param >= @enumToInt(pkmn.gen1.Move.Struggle);
if (invalid or metronome == .None or metronome == .Metronome) {
err.print("Usage: {s} metronome <Move>\n", .{args[0]}) catch {};
std.process.exit(1);
}
},
.seed => {
if (args.len != 3) {
err.print("Usage: {s} seed <N>\n", .{args[0]}) catch {};
std.process.exit(1);
}
param = std.fmt.parseUnsigned(u8, args[2], 10) catch {
err.print("Usage: {s} seed <N>\n", .{args[0]}) catch {};
std.process.exit(1);
};
var i: usize = 0;
while (i < 256) : (i += 1) {
const a: u8 = 5 *% @truncate(u8, i) +% 1;
const b: u8 = 5 *% a +% 1;
const c: u8 = 5 *% b +% 1;
if (c != param) continue;
const d: u8 = 5 *% c +% 1;
const e: u8 = 5 *% d +% 1;
try w.print(
"{d} {d} {s}{d}{s} {d} {d}\n",
.{ a, b, ANSI.RED, c, ANSI.RESET, d, e },
);
}
try buf.flush();
std.process.exit(0);
},
else => if (args.len != 2) usageAndExit(args[0]),
}
try w.print("\nPokémon Red\n===========\n\n", .{});
var i: usize = 0;
while (i < 256) : (i += 1) {
if (tool == .chance or tool == .metronome) {
try w.print("{d}", .{param});
break;
}
const next = @truncate(u8, i);
const value = switch (tool) {
.bide, .rampage => (next & 1) + 2,
.damage => std.math.rotr(u8, next, 1),
.confusion, .distribution, .thrash => (next & 3) + 2,
.crit => @boolToInt(std.math.rotl(u8, @truncate(u8, next), 3) < param),
.disable => (next & 7) + 1,
.sleep => next & 7,
else => unreachable,
};
if (i != 0) _ = try w.write(if (i % 16 == 0) "\n" else " ");
if (tool == .crit) {
if (value == 0) {
try w.print(" {s}F{s} ", .{ ANSI.RED, ANSI.RESET });
} else {
try w.print(" T ", .{});
}
} else if (tool == .damage) {
if (value < 217) {
try w.print("{s}{d: >3}{s}", .{ ANSI.RED, value, ANSI.RESET });
} else {
try w.print("{d: >3}", .{value});
}
} else {
try w.print("{d: >3}", .{value});
}
}
_ = try w.write("\n");
try w.print("\nPokémon Showdown\n================\n\n", .{});
i = 0;
if (tool == .chance or tool == .crit) {
try w.print("0x{X:0>8}", .{param * 0x1000000});
} else if (tool == .metronome) {
const range: u64 = @enumToInt(pkmn.gen1.Move.Struggle) - 2;
const mod = @as(u2, (if (param < @enumToInt(pkmn.gen1.Move.Metronome) - 1) 1 else 2));
try w.print("0x{X:0>8}", .{(param - mod) * (0x100000000 / range)});
} else if (tool == .distribution) {
const range: u64 = 8;
try w.print("0x{X:0>8} 0x{X:0>8} 0x{X:0>8} 0x{X:0>8}", .{
0 * (0x100000000 / range),
3 * (0x100000000 / range),
6 * (0x100000000 / range),
7 * (0x100000000 / range),
});
} else {
var range: u64 = switch (tool) {
.bide, .thrash => 5 - 3,
.damage => 256 - 217,
.rampage => 4 - 2,
.confusion => 6 - 2,
.sleep => 8 - 1,
else => unreachable,
};
while (i < range) : (i += 1) {
try w.print("0x{X:0>8}", .{i * (0x100000000 / range)});
if (range > 9 and i % 3 == 2) {
_ = try w.write("\n");
} else if (i != range - 1) {
_ = try w.write(" ");
}
}
}
_ = try w.write("\n\n");
try buf.flush();
}
fn usageAndExit(cmd: []const u8) noreturn {
const err = std.io.getStdErr().writer();
err.print("Usage: {s} <TOOL> (<arg>...)?\n", .{cmd}) catch {};
std.process.exit(1);
} | src/tools/rng.zig |
const std = @import("std");
const config = @import("config.zig");
const gradient = @import("gradient.zig");
const Gradient = gradient.Gradient;
const version = @import("version.zig").version;
const VTE = @import("vte");
const c = VTE.c;
const gtk = VTE.gtk;
const allocator = std.heap.page_allocator;
const fmt = std.fmt;
const mem = std.mem;
const meta = std.meta;
const stderr = std.io.getStdErr().writer();
const stdout = std.io.getStdOut().writer();
var widgets: PrefWidgets = undefined;
var conf = config.Config.default();
pub const ColorButtons = struct {
text_color: gtk.ColorButton,
background_color: gtk.ColorButton,
black_color: gtk.ColorButton,
red_color: gtk.ColorButton,
green_color: gtk.ColorButton,
brown_color: gtk.ColorButton,
blue_color: gtk.ColorButton,
magenta_color: gtk.ColorButton,
cyan_color: gtk.ColorButton,
light_grey_color: gtk.ColorButton,
dark_grey_color: gtk.ColorButton,
light_red_color: gtk.ColorButton,
light_green_color: gtk.ColorButton,
yellow_color: gtk.ColorButton,
light_blue_color: gtk.ColorButton,
light_magenta_color: gtk.ColorButton,
light_cyan_color: gtk.ColorButton,
white_color: gtk.ColorButton,
const Self = @This();
fn init(builder: gtk.Builder) ?Self {
//var buttons: ColorButtons = undefined;
//inline for (meta.fields(ColorButtons)) |color| {
// const color_name = fmt.allocPrintZ(allocator, "{s}", .{color.name}) catch return null;
// defer allocator.free(color_name);
// if (builder.get_widget(color_name)) |widget| {
// if (widget.to_color_button()) |b| {
// @field(buttons, color.name) = b;
// } else return null;
// } else return null;
//}
//return buttons;
return Self{
.text_color = builder.get_widget("text_color").?.to_color_button().?,
.background_color = builder.get_widget("background_color").?.to_color_button().?,
.black_color = builder.get_widget("black_color").?.to_color_button().?,
.red_color = builder.get_widget("red_color").?.to_color_button().?,
.green_color = builder.get_widget("green_color").?.to_color_button().?,
.brown_color = builder.get_widget("brown_color").?.to_color_button().?,
.blue_color = builder.get_widget("blue_color").?.to_color_button().?,
.magenta_color = builder.get_widget("magenta_color").?.to_color_button().?,
.cyan_color = builder.get_widget("cyan_color").?.to_color_button().?,
.light_grey_color = builder.get_widget("light_grey_color").?.to_color_button().?,
.dark_grey_color = builder.get_widget("dark_grey_color").?.to_color_button().?,
.light_red_color = builder.get_widget("light_red_color").?.to_color_button().?,
.light_green_color = builder.get_widget("light_green_color").?.to_color_button().?,
.yellow_color = builder.get_widget("yellow_color").?.to_color_button().?,
.light_blue_color = builder.get_widget("light_blue_color").?.to_color_button().?,
.light_magenta_color = builder.get_widget("light_magenta_color").?.to_color_button().?,
.light_cyan_color = builder.get_widget("light_cyan_color").?.to_color_button().?,
.white_color = builder.get_widget("white_color").?.to_color_button().?,
};
}
fn getColors(self: Self) config.Colors {
var colors = config.Colors.default();
inline for (meta.fields(config.Colors)) |color| {
const button = @field(self, color.name);
const value = config.RGB.fromButton(button);
@field(colors, color.name) = value;
}
return colors;
}
fn setColors(self: Self) void {
const colors = conf.colors;
inline for (meta.fields(config.Colors)) |color| {
const button = @field(self, color.name);
const rgb = @field(colors, color.name);
const gdk_rgba = rgb.toGdk();
button.as_color_chooser().set_rgba(gdk_rgba);
}
}
};
pub const PrefWidgets = struct {
window: gtk.Window,
initial_title_entry: gtk.Entry,
dynamic_title_combobox: gtk.ComboBox,
custom_command_checkbutton: gtk.CheckButton,
custom_command_label: gtk.Widget,
custom_command_entry: gtk.Entry,
cursor_style_combobox: gtk.ComboBox,
cursor_blinks_checkbutton: gtk.CheckButton,
infinite_scrollback_checkbutton: gtk.CheckButton,
scrollback_lines_label: gtk.Widget,
scrollback_lines_spinbox: gtk.SpinButton,
system_font_checkbutton: gtk.CheckButton,
font_chooser_button: *c.GtkWidget,
background_style_combobox: gtk.ComboBox,
background_style_stack: gtk.Stack,
background_color_box: gtk.Widget,
background_image_grid: gtk.Widget,
background_image_file_button: *c.GtkWidget,
background_image_style_combobox: gtk.ComboBox,
background_style_opacity_box: gtk.Widget,
background_style_opacity_scale: gtk.Scale,
close_button: gtk.Button,
color_buttons: ColorButtons,
gradient_editor: gradient.GradientEditor,
const Self = @This();
fn init(builder: gtk.Builder) Self {
return Self{
.window = builder.get_widget("window").?.to_window().?,
.initial_title_entry = builder
.get_widget("initial_title_entry").?.to_entry().?,
.dynamic_title_combobox = builder
.get_widget("dynamic_title_combobox").?.to_combo_box().?,
.custom_command_checkbutton = builder
.get_widget("custom_command_checkbutton").?.to_check_button().?,
.custom_command_label = builder.get_widget("custom_command_label").?,
.custom_command_entry = builder
.get_widget("custom_command_entry").?.to_entry().?,
.cursor_style_combobox = builder
.get_widget("cursor_style_combobox").?.to_combo_box().?,
.cursor_blinks_checkbutton = builder
.get_widget("cursor_blinks_checkbutton").?.to_check_button().?,
.infinite_scrollback_checkbutton = builder
.get_widget("infinite_scrollback_checkbutton").?.to_check_button().?,
.scrollback_lines_label = builder
.get_widget("scrollback_lines_label").?,
.scrollback_lines_spinbox = builder
.get_widget("scrollback_lines_spinbox").?.to_spin_button().?,
.system_font_checkbutton = builder
.get_widget("system_font_checkbutton").?.to_check_button().?,
.font_chooser_button = builder.get_widget("font_chooser_button").?.ptr,
.background_style_combobox = builder
.get_widget("background_style_combobox").?.to_combo_box().?,
.background_style_stack = builder
.get_widget("background_style_stack").?.to_stack().?,
.background_color_box = builder
.get_widget("background_color_box").?,
.background_image_grid = builder.get_widget("background_image_grid").?,
.background_image_file_button = builder
.get_widget("background_image_file_button").?.ptr,
.background_image_style_combobox = builder
.get_widget("background_image_style_combobox").?.to_combo_box().?,
.background_style_opacity_box = builder
.get_widget("background_style_opacity_box").?,
.background_style_opacity_scale = builder
.get_widget("background_style_opacity_scale").?.to_scale().?,
.close_button = builder.get_widget("close_button").?.to_button().?,
.color_buttons = ColorButtons.init(builder).?,
.gradient_editor = gradient.GradientEditor.init(builder, conf).?,
};
}
fn setWindowTitle(self: Self) void {
self.window.set_title("Zterm-" ++ version ++ " ~ Preferences");
}
fn setInitialTitle(self: Self) void {
const buf = self.initial_title_entry.get_buffer();
const title = fmt.allocPrintZ(allocator, "{s}", .{conf.initial_title}) catch return;
defer allocator.free(title);
buf.set_text(title, -1);
}
fn getTitleStyle(self: Self) config.DynamicTitleStyle {
return if (self.dynamic_title_combobox.get_active_id(allocator)) |id| blk: {
break :blk if (config.parseEnum(config.DynamicTitleStyle, id)) |s|
s else config.DynamicTitleStyle.default();
} else config.DynamicTitleStyle.default();
}
fn setTitleStyle(self: Self) void {
switch (conf.dynamic_title_style) {
.replaces_title => _ = self.dynamic_title_combobox.set_active_id("replaces_title"),
.before_title => _ = self.dynamic_title_combobox.set_active_id("before_title"),
.after_title => _ = self.dynamic_title_combobox.set_active_id("after_title"),
.not_displayed => _ = self.dynamic_title_combobox.set_active_id("not_displayed"),
}
}
fn getCustomCommand(self: Self) config.CustomCommand {
const is_custom = self.custom_command_checkbutton.as_toggle_button().get_active();
if (is_custom) {
const val = self.custom_command_entry.get_text(allocator);
return if (val) |v| config.CustomCommand{ .command = v } else .none;
} else {
return .none;
}
}
fn setCustomCommand(self: Self) void {
const command = conf.custom_command;
const buf = self.custom_command_entry.get_buffer();
switch (command) {
.command => |val| {
self.custom_command_checkbutton.as_toggle_button().set_active(true);
self.custom_command_entry.as_widget().set_sensitive(true);
self.custom_command_label.set_sensitive(true);
const cmd = fmt.allocPrintZ(allocator, "{s}", .{val}) catch |e| {
stderr.print("{s}\n", .{e}) catch {};
return;
};
defer allocator.free(cmd);
buf.set_text(cmd, -1);
},
.none => {
self.custom_command_checkbutton.as_toggle_button().set_active(false);
self.custom_command_entry.as_widget().set_sensitive(false);
self.custom_command_label.set_sensitive(false);
},
}
}
fn getScrollback(self: Self) config.Scrollback {
const toggle = self.infinite_scrollback_checkbutton.as_toggle_button();
if (toggle.get_active()) {
return config.Scrollback.infinite;
} else {
const val = self.scrollback_lines_spinbox.get_value();
return config.Scrollback{ .finite = val };
}
}
fn setScrollback(self: Self) void {
const scrollback = conf.scrollback;
const toggle = self.infinite_scrollback_checkbutton.as_toggle_button();
switch (scrollback) {
.infinite => {
toggle.set_active(true);
self.scrollback_lines_spinbox.as_widget().set_sensitive(false);
},
.finite => |value| {
toggle.set_active(false);
self.scrollback_lines_spinbox.as_widget().set_sensitive(true);
self.scrollback_lines_spinbox.set_value(value);
},
}
}
fn getFont(self: Self) config.Font {
const toggle = self.system_font_checkbutton.as_toggle_button();
const chooser = @ptrCast(*c.GtkFontChooser, self.font_chooser_button);
if (toggle.get_active()) {
return .system;
} else {
const val = c.gtk_font_chooser_get_font(chooser);
const font = fmt.allocPrintZ(allocator, "{s}", .{val}) catch |e| {
stderr.print("{s}\n", .{e}) catch {};
return .system;
};
return config.Font{ .custom = font };
}
}
fn setFont(self: Self) void {
const toggle = self.system_font_checkbutton.as_toggle_button();
const chooser = @ptrCast(*c.GtkFontChooser, self.font_chooser_button);
const font = conf.font;
switch (font) {
.system => {
toggle.set_active(true);
c.gtk_widget_set_sensitive(self.font_chooser_button, 0);
},
.custom => |val| {
const fontname = fmt.allocPrintZ(allocator, "{s}", .{val}) catch |e| {
stderr.print("{s}\n", .{e}) catch {};
toggle.set_active(true);
c.gtk_widget_set_sensitive(self.font_chooser_button, 0);
return;
};
defer allocator.free(fontname);
toggle.set_active(false);
c.gtk_widget_set_sensitive(self.font_chooser_button, 1);
c.gtk_font_chooser_set_font(chooser, fontname);
},
}
}
fn getBackgroundStyle(self: Self) config.BackgroundStyle {
return if (self.background_style_combobox.get_active_id(allocator)) |id| blk: {
defer allocator.free(id);
break :blk if (config.parseEnum(config.BackgroundStyle, id)) |s|
s else config.BackgroundStyle.default();
} else config.BackgroundStyle.default();
}
fn getImageStyle(self: PrefWidgets) config.ImageStyle {
return if (self.background_image_style_combobox.get_active_id(allocator)) |id| blk: {
defer allocator.free(id);
break :blk if (config.parseEnum(config.ImageStyle, id)) |s|
s else config.ImageStyle.default();
} else config.ImageStyle.default();
}
fn setImageStyle(self: Self, image: config.BackgroundImage) void {
const style = image.style;
switch (style) {
.tiled => _ = self.background_image_style_combobox.set_active_id("tiled"),
.centered => _ = self.background_image_style_combobox.set_active_id("centered"),
.scaled => _ = self.background_image_style_combobox.set_active_id("scaled"),
.stretched => _ = self.background_image_style_combobox.set_active_id("stretched"),
}
}
fn getBackgroundGradient(self: Self) ?Gradient {
return if (self.gradient_editor.getGradient()) |g| g else null;
}
fn getBackgroundImage(self: Self) ?config.BackgroundImage {
const button = @ptrCast(*c.GtkFileChooser, self.background_image_file_button);
const val = c.gtk_file_chooser_get_filename(button);
if (val == null) {
return null;
}
const len = mem.len(val);
const style = self.getImageStyle();
return config.BackgroundImage{
.file = val[0..len],
.style = style,
};
}
fn setBackgroundImage(self: Self, image: config.BackgroundImage) void {
// stub
const button = @ptrCast(*c.GtkFileChooser, self.background_image_file_button);
const file = fmt.allocPrintZ(allocator, "{s}", .{image.file}) catch |e| {
stderr.print("{s}\n", .{e}) catch {};
return;
};
defer allocator.free(file);
_ = c.gtk_file_chooser_set_filename(button, file);
self.setImageStyle(image);
}
fn getBackground(self: Self) config.Background {
const style = self.getBackgroundStyle();
switch (style) {
.solid_color => {
return config.Background.solid_color;
},
.image => {
if (self.getBackgroundImage()) |img| {
return config.Background{ .image = img };
} else {
return config.Background.default();
}
},
.transparent => {
const val = self.background_style_opacity_scale.as_range().get_value();
return config.Background{ .transparent = val };
},
.gradient => {
return config.Background{
.gradient = if (self.getBackgroundGradient()) |g| g
else Gradient.default(),
};
},
}
}
fn setTransparency(self: Self, percent: f64) void {
self.background_style_opacity_scale.as_range().set_value(percent);
}
fn setBackground(self: Self) void {
const bg = conf.background;
switch (bg) {
.solid_color => {
self.background_style_combobox.set_active_id("solid_color");
self.background_style_stack.set_visible_child(self.background_color_box);
},
.image => |img| {
self.background_style_combobox.set_active_id("image");
self.background_style_stack.set_visible_child(self.background_image_grid);
self.setBackgroundImage(img);
},
.transparent => |percent| {
self.background_style_combobox.set_active_id("transparent");
self.background_style_stack.set_visible_child(self.background_style_opacity_box);
self.setTransparency(percent);
},
.gradient => {
self.background_style_combobox.set_active_id("gradient");
self.background_style_stack.set_visible_child(self.gradient_editor.editor);
self.gradient_editor.setBg();
},
}
}
fn getCursorStyle(self: Self) config.CursorStyle {
if (self.cursor_style_combobox.get_active_id(allocator)) |id| {
return if (config.parseEnum(config.CursorStyle, id)) |s|
s else config.CursorStyle.default();
} else return config.CursorStyle.default();
}
fn getCursor(self: Self) config.Cursor {
const style = self.getCursorStyle();
const blinks = self.cursor_blinks_checkbutton.as_toggle_button().get_active();
return config.Cursor{
.style = style,
.blinks = blinks,
};
}
fn setCursor(self: Self) void {
if (conf.cursor.blinks) {
self.cursor_blinks_checkbutton.as_toggle_button().set_active(true);
} else {
self.cursor_blinks_checkbutton.as_toggle_button().set_active(false);
}
switch (conf.cursor.style) {
.block => _ = self.cursor_style_combobox.set_active_id("block"),
.ibeam => _ = self.cursor_style_combobox.set_active_id("ibeam"),
.underline => _ = self.cursor_style_combobox.set_active_id("underline"),
}
}
fn getConfig(self: Self) config.Config {
return config.Config{
.initial_title = if (self.initial_title_entry.get_text(allocator)) |t| t else "Zterm",
.dynamic_title_style = self.getTitleStyle(),
.custom_command = self.getCustomCommand(),
.scrollback = self.getScrollback(),
.font = self.getFont(),
.background = self.getBackground(),
.colors = self.color_buttons.getColors(),
.cursor = self.getCursor(),
};
}
fn setValues(self: Self) void {
self.setWindowTitle();
self.setInitialTitle();
self.setTitleStyle();
self.setCustomCommand();
self.setScrollback();
self.setBackground();
self.color_buttons.setColors();
self.setFont();
self.setCursor();
}
fn connectSignals(self: Self) void {
const Callbacks = struct {
fn toggleCustomCommand(custom_command_checkbutton: *c.GtkCheckButton) void {
const state = gtk.toggle_button_get_active(
@ptrCast(*c.GtkToggleButton, custom_command_checkbutton));
widgets.custom_command_entry.as_widget().set_sensitive(state);
widgets.custom_command_label.set_sensitive(state);
}
fn toggleScrollback(infinite_scrollback_checkbutton: *c.GtkCheckButton) void {
const state = gtk.toggle_button_get_active(
@ptrCast(*c.GtkToggleButton, infinite_scrollback_checkbutton));
widgets.scrollback_lines_label.set_sensitive(!state);
widgets.scrollback_lines_spinbox.as_widget().set_sensitive(!state);
}
fn toggleFont(system_font_checkbutton: *c.GtkCheckButton) void {
const state = gtk.toggle_button_get_active(
@ptrCast(*c.GtkToggleButton, system_font_checkbutton));
gtk.widget_set_sensitive(
@ptrCast(*c.GtkWidget, widgets.font_chooser_button), !state);
}
fn toggleBackground(background_combobox: *c.GtkComboBox) void {
const id = c.gtk_combo_box_get_active_id(@ptrCast(*c.GtkComboBox, background_combobox));
const style = config.parseEnum(config.BackgroundStyle, id).?;
switch (style) {
.solid_color => {
widgets.background_style_stack.set_visible_child(widgets.background_color_box);
},
.image => {
widgets.background_style_stack.set_visible_child(widgets.background_image_grid);
},
.transparent => {
widgets.background_style_stack.set_visible_child(widgets.background_style_opacity_box);
},
.gradient => {
widgets.background_style_stack.set_visible_child(widgets.gradient_editor.editor);
widgets.gradient_editor.setBg();
},
}
}
};
self.custom_command_checkbutton.as_toggle_button().connect_toggled(
@ptrCast(c.GCallback, Callbacks.toggleCustomCommand),
null,
);
self.infinite_scrollback_checkbutton.as_toggle_button().connect_toggled(
@ptrCast(c.GCallback, Callbacks.toggleScrollback),
null,
);
self.system_font_checkbutton.as_toggle_button().connect_toggled(
@ptrCast(c.GCallback, Callbacks.toggleFont),
null,
);
self.background_style_combobox.connect_changed(
@ptrCast(c.GCallback, Callbacks.toggleBackground),
null,
);
}
};
pub fn run(data: config.Config) ?config.Config {
const builder = gtk.Builder.new();
conf = data;
builder.add_from_string(@embedFile("prefs.glade")) catch |e| {
stderr.print("{s}\n", .{e}) catch {};
return null;
};
widgets = PrefWidgets.init(builder);
widgets.setValues();
widgets.connectSignals();
widgets.close_button.connect_clicked(@ptrCast(c.GCallback, saveAndClose), null);
const res = c.gtk_dialog_run(@ptrCast(*c.GtkDialog, widgets.window.ptr));
if (res == -1) {
return conf;
} else {
widgets.window.close();
widgets.window.as_widget().destroy();
return null;
}
}
fn saveAndClose() void {
conf = widgets.getConfig();
widgets.window.close();
widgets.window.as_widget().destroy();
} | src/prefs.zig |
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
const expect = testing.expect;
const expectEqual = testing.expectEqual;
test "access the null element of a null terminated array" {
const S = struct {
fn doTheTest() !void {
var array: [4:0]u8 = .{ 'a', 'o', 'e', 'u' };
try expect(array[4] == 0);
var len: usize = 4;
try expect(array[len] == 0);
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "type deduction for array subscript expression" {
const S = struct {
fn doTheTest() !void {
var array = [_]u8{ 0x55, 0xAA };
var v0 = true;
try expect(@as(u8, 0xAA) == array[if (v0) 1 else 0]);
var v1 = false;
try expect(@as(u8, 0x55) == array[if (v1) 1 else 0]);
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "sentinel element count towards the ABI size calculation" {
const S = struct {
fn doTheTest() !void {
const T = packed struct {
fill_pre: u8 = 0x55,
data: [0:0]u8 = undefined,
fill_post: u8 = 0xAA,
};
var x = T{};
var as_slice = mem.asBytes(&x);
try expect(@as(usize, 3) == as_slice.len);
try expect(@as(u8, 0x55) == as_slice[0]);
try expect(@as(u8, 0xAA) == as_slice[2]);
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "zero-sized array with recursive type definition" {
const U = struct {
fn foo(comptime T: type, comptime n: usize) type {
return struct {
s: [n]T,
x: usize = n,
};
}
};
const S = struct {
list: U.foo(@This(), 0),
};
var t: S = .{ .list = .{ .s = undefined } };
try expect(@as(usize, 0) == t.list.x);
}
test "type coercion of anon struct literal to array" {
const S = struct {
const U = union {
a: u32,
b: bool,
c: []const u8,
};
fn doTheTest() !void {
var x1: u8 = 42;
const t1 = .{ x1, 56, 54 };
var arr1: [3]u8 = t1;
try expect(arr1[0] == 42);
try expect(arr1[1] == 56);
try expect(arr1[2] == 54);
var x2: U = .{ .a = 42 };
const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
var arr2: [3]U = t2;
try expect(arr2[0].a == 42);
try expect(arr2[1].b == true);
try expect(mem.eql(u8, arr2[2].c, "hello"));
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "type coercion of pointer to anon struct literal to pointer to array" {
const S = struct {
const U = union {
a: u32,
b: bool,
c: []const u8,
};
fn doTheTest() !void {
var x1: u8 = 42;
const t1 = &.{ x1, 56, 54 };
var arr1: *const [3]u8 = t1;
try expect(arr1[0] == 42);
try expect(arr1[1] == 56);
try expect(arr1[2] == 54);
var x2: U = .{ .a = 42 };
const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
var arr2: *const [3]U = t2;
try expect(arr2[0].a == 42);
try expect(arr2[1].b == true);
try expect(mem.eql(u8, arr2[2].c, "hello"));
}
};
try S.doTheTest();
comptime try S.doTheTest();
} | test/behavior/array_stage1.zig |
const std = @import("std");
const mem = std.mem;
const Tree = std.zig.Ast;
const Node = Tree.Node;
const TokenIndex = Tree.TokenIndex;
const NodeIndex = Tree.Node.Index;
pub const zloppy_comment = "// XXX ZLOPPY";
comptime {
if (zloppy_comment[0] != '/' or zloppy_comment[1] != '/')
@compileError("zloppy_comment must start with '//'");
}
pub const Patches = struct {
const PatchIndex = u32;
pub const Patch = union(enum) {
// function parameters: anchored on block main token (lbrace)
// captures: if block exists, anchored on block main token (lbrace)
// if not, anchored on statement main token
// declarations: anchored on decl main token (`var` or `const`)
unused_var: TokenIndex,
// anchored on block main token (lbrace)
first_unreachable_stmt: TokenIndex,
};
// mapping between anchors and patchsets
map: std.AutoHashMap(TokenIndex, PatchIndex),
patches: std.ArrayList(std.ArrayList(Patch)),
rendered_comments: u32 = 0,
pub fn init(gpa: mem.Allocator) Patches {
return .{
.map = std.AutoHashMap(TokenIndex, PatchIndex).init(gpa),
.patches = std.ArrayList(std.ArrayList(Patch)).init(gpa),
};
}
pub fn deinit(self: *Patches) void {
self.map.deinit();
for (self.patches.items) |patches| {
patches.deinit();
}
self.patches.deinit();
}
fn append(self: *Patches, token: TokenIndex, patch: Patch) !void {
var patch_idx: PatchIndex = undefined;
const result = try self.map.getOrPut(token);
if (result.found_existing) {
patch_idx = result.value_ptr.*;
} else {
patch_idx = @intCast(PatchIndex, self.patches.items.len);
result.value_ptr.* = patch_idx;
try self.patches.append(std.ArrayList(Patch).init(self.patches.allocator));
}
try self.patches.items[patch_idx].append(patch);
}
pub fn get(self: Patches, token: TokenIndex) ?[]const Patch {
if (self.map.get(token)) |patch_idx| {
return self.patches.items[patch_idx].items[0..];
} else {
return null;
}
}
};
const TreeTraversalError = error{
OutOfMemory,
};
fn traverseNodeExtraIndices(
comptime N: comptime_int,
action: anytype,
patches: *Patches,
tree: Tree,
parent: NodeIndex,
node: NodeIndex,
) TreeTraversalError!bool {
inline for ([_]u8{0} ** N) |_, i| {
const extra = tree.extra_data[node + i];
if (extra != 0 and !try traverseNode(action, patches, tree, parent, extra))
return false;
}
return true;
}
fn traverseNode(
action: anytype,
patches: *Patches,
tree: Tree,
parent: NodeIndex,
node: NodeIndex,
) TreeTraversalError!bool {
var cont = try action.before(patches, tree, parent, node);
if (!cont)
return false;
const datas = tree.nodes.items(.data);
const tag = tree.nodes.items(.tag)[node];
blk: {
switch (tag) {
// sub list from lhs to rhs
.block,
.block_semicolon,
.array_init_dot,
.array_init_dot_comma,
.struct_init_dot,
.struct_init_dot_comma,
.builtin_call,
.builtin_call_comma,
.container_decl,
.container_decl_trailing,
=> {
const first = datas[node].lhs;
const last = datas[node].rhs;
for (tree.extra_data[first..last]) |stmt_idx| {
cont = try traverseNode(action, patches, tree, node, stmt_idx);
if (!cont) break :blk;
}
},
// check lhs (if set) and sub range list from rhs
.array_init,
.array_init_comma,
.struct_init,
.struct_init_comma,
.call,
.call_comma,
.async_call,
.async_call_comma,
.@"switch",
.switch_comma,
.container_decl_arg,
.container_decl_arg_trailing,
.tagged_union_enum_tag,
.tagged_union_enum_tag_trailing,
.@"asm",
=> {
if (datas[node].lhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
}
const range = tree.extraData(datas[node].rhs, Node.SubRange);
for (tree.extra_data[range.start..range.end]) |idx| {
cont = try traverseNode(action, patches, tree, node, idx);
if (!cont) break :blk;
}
},
// check sub range list from lhs and rhs (if set)
.switch_case,
.fn_proto_multi,
=> {
const range = tree.extraData(datas[node].lhs, Node.SubRange);
for (tree.extra_data[range.start..range.end]) |idx| {
cont = try traverseNode(action, patches, tree, node, idx);
if (!cont) break :blk;
}
if (datas[node].rhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
}
},
// both lhs and rhs must be checked (if set)
.simple_var_decl,
.@"catch",
.equal_equal,
.bang_equal,
.less_than,
.greater_than,
.less_or_equal,
.greater_or_equal,
.assign_mul,
.assign_div,
.assign_mod,
.assign_add,
.assign_sub,
.assign_shl,
.assign_shl_sat,
.assign_shr,
.assign_bit_and,
.assign_bit_xor,
.assign_bit_or,
.assign_mul_wrap,
.assign_add_wrap,
.assign_sub_wrap,
.assign_mul_sat,
.assign_add_sat,
.assign_sub_sat,
.assign,
.merge_error_sets,
.mul,
.div,
.mod,
.array_mult,
.mul_wrap,
.mul_sat,
.add,
.sub,
.array_cat,
.add_wrap,
.sub_wrap,
.add_sat,
.sub_sat,
.shl,
.shl_sat,
.shr,
.bit_and,
.bit_xor,
.bit_or,
.@"orelse",
.bool_and,
.bool_or,
.array_type,
.ptr_type_aligned,
.ptr_type_sentinel,
.slice_open,
.array_access,
.array_init_one,
.array_init_one_comma,
.array_init_dot_two,
.array_init_dot_two_comma,
.struct_init_one,
.struct_init_one_comma,
.struct_init_dot_two,
.struct_init_dot_two_comma,
.call_one,
.call_one_comma,
.async_call_one,
.async_call_one_comma,
.switch_case_one,
.switch_range,
.while_simple,
.for_simple,
.if_simple,
.fn_proto_simple,
.fn_decl,
.builtin_call_two,
.builtin_call_two_comma,
.container_decl_two,
.container_decl_two_trailing,
.tagged_union_two,
.tagged_union_two_trailing,
.container_field_init,
.container_field_align,
.block_two,
.block_two_semicolon,
.error_union,
=> {
if (datas[node].lhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
}
if (datas[node].rhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
}
},
// only lhs must be checked (if set)
.@"usingnamespace",
.field_access,
.unwrap_optional,
.bool_not,
.negation,
.bit_not,
.negation_wrap,
.address_of,
.@"try",
.@"await",
.optional_type,
.deref,
.@"suspend",
.@"resume",
.@"return",
.grouped_expression,
.@"comptime",
.@"nosuspend",
.asm_simple,
.asm_output,
.asm_input,
=> {
if (datas[node].lhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
}
},
// only rhs must be checked (if set)
.global_var_decl,
.local_var_decl,
.aligned_var_decl,
.test_decl,
.@"errdefer",
.@"defer",
.@"break",
=> {
if (datas[node].rhs != 0) {
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
}
},
// check lhs and 2 indices at rhs
.array_type_sentinel,
.while_cont,
.@"if",
.@"for",
.slice,
.container_field,
=> {
cont = try traverseNode(action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
cont = try traverseNodeExtraIndices(2, action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
},
// check lhs and 3 indices at rhs
.slice_sentinel,
.@"while",
=> {
cont = try traverseNode(action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
cont = try traverseNodeExtraIndices(3, action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
},
// check 3 indices at lhs and rhs
.ptr_type => {
cont = try traverseNodeExtraIndices(3, action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
},
// check 5 indices at lhs and rhs
.fn_proto_one => {
cont = try traverseNodeExtraIndices(5, action, patches, tree, node, datas[node].lhs);
if (!cont) break :blk;
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
},
// special case: fn proto
.fn_proto => {
// fn proto has first a range (2 indices) then 3 indices in extra data
const range = tree.extraData(datas[node].lhs, Node.SubRange);
for (tree.extra_data[range.start..range.end]) |idx| {
cont = try traverseNode(action, patches, tree, node, idx);
if (!cont) break :blk;
}
const extraIndex = datas[node].lhs + 2;
cont = try traverseNodeExtraIndices(3, action, patches, tree, node, extraIndex);
if (!cont) break :blk;
cont = try traverseNode(action, patches, tree, node, datas[node].rhs);
if (!cont) break :blk;
},
else => {},
}
}
try action.after(patches, tree, parent, node);
// do not propagate tree traversal skipping outside of blocks/structs
return switch (tag) {
.block_two,
.block_two_semicolon,
.block,
.block_semicolon,
.container_decl,
.container_decl_trailing,
.container_decl_arg,
.container_decl_arg_trailing,
=> true,
else => cont,
};
}
fn anchorFromNode(tree: Tree, node: NodeIndex) TokenIndex {
const tag = tree.nodes.items(.tag)[node];
switch (tag) {
.fn_proto_simple,
.fn_proto_multi,
.fn_proto_one,
.fn_proto,
=> {
const maybe_lbrace = tree.lastToken(node) + 1;
if (tree.tokens.items(.tag)[maybe_lbrace] == .l_brace) {
return maybe_lbrace;
} else {
return tree.nodes.items(.main_token)[node];
}
},
.fn_decl => {
const rhs = tree.nodes.items(.data)[node].rhs;
const lbrace = tree.firstToken(rhs);
std.debug.assert(tree.tokens.items(.tag)[lbrace] == .l_brace);
return lbrace;
},
else => return tree.nodes.items(.main_token)[node],
}
}
const ZloppyChecks = struct {
const Binding = struct {
token: TokenIndex = 0,
anchor: TokenIndex = 0,
used: bool = false,
scope_marker: bool = false,
};
bindings: std.ArrayList(Binding),
state: union(enum) {
reachable_code,
return_reached,
unreachable_from: TokenIndex,
},
fn init(gpa: mem.Allocator) !ZloppyChecks {
var self = ZloppyChecks{
.bindings = std.ArrayList(Binding).init(gpa),
.state = .reachable_code,
};
try self.pushScope();
return self;
}
fn deinit(self: *ZloppyChecks) void {
// assert only the toplevel scope remains
std.debug.assert(self.bindings.items.len >= 1);
var i: usize = 1;
while (i < self.bindings.items.len) : (i += 1) {
std.debug.assert(!self.bindings.items[i].scope_marker);
}
self.bindings.deinit();
}
fn pushScope(self: *ZloppyChecks) !void {
try self.bindings.append(.{ .scope_marker = true });
}
fn pushScopeWithCapture(self: *ZloppyChecks, tree: Tree, node: NodeIndex) !void {
try self.pushScope();
const maybe_capture = tree.firstToken(node) - 1;
if (tree.tokens.items(.tag)[maybe_capture] == .pipe) {
const capture = maybe_capture - 1;
std.debug.assert(tree.tokens.items(.tag)[capture] == .identifier);
try self.addBinding(tree, node, capture);
}
}
fn popScope(self: *ZloppyChecks) void {
var i: usize = self.bindings.items.len;
while (i > 0 and !self.bindings.items[i - 1].scope_marker) : (i -= 1) {}
self.bindings.items.len = i - 1;
// potentially faulty scope was popped, reset state to reachable
self.state = .reachable_code;
}
fn popScopeGenPatches(self: *ZloppyChecks, patches: *Patches, anchor: TokenIndex) !void {
// unused vars
var i: usize = self.bindings.items.len;
while (i > 0 and !self.bindings.items[i - 1].scope_marker) : (i -= 1) {
const binding = self.bindings.items[i - 1];
if (!binding.used) {
try patches.append(binding.anchor, .{ .unused_var = binding.token });
}
}
self.bindings.items.len = i - 1;
// unreachable code
switch (self.state) {
.unreachable_from => |token| {
try patches.append(anchor, .{ .first_unreachable_stmt = token });
},
else => {},
}
// potentially faulty scope was popped, reset state to reachable
self.state = .reachable_code;
}
fn addBinding(self: *ZloppyChecks, tree: Tree, node: NodeIndex, token: TokenIndex) !void {
// _ variable is ignored by compiler
if (mem.eql(u8, "_", tree.tokenSlice(token)))
return;
const anchor = anchorFromNode(tree, node);
try self.bindings.append(.{ .token = token, .anchor = anchor });
}
fn setUsed(self: *ZloppyChecks, tree: Tree, token: TokenIndex) void {
std.debug.assert(self.state == .reachable_code);
const tag = tree.tokens.items(.tag)[token];
const name = tree.tokenSlice(token);
std.debug.assert(tag == .identifier);
// no need to check bindings[0], it's the first scope marker
var i: usize = self.bindings.items.len - 1;
while (i > 1) : (i -= 1) {
var binding = &self.bindings.items[i];
if (binding.scope_marker)
continue;
const bname = tree.tokenSlice(binding.token);
if (mem.eql(u8, name, bname)) {
binding.used = true;
return;
}
}
}
fn before(
self: *ZloppyChecks,
patches: *Patches,
tree: Tree,
parent: NodeIndex,
node: NodeIndex,
) !bool {
_ = patches;
switch (self.state) {
.reachable_code => {},
.return_reached => {
// reached first unreachable statement, stop tree traversal
self.state = .{ .unreachable_from = tree.nodes.items(.main_token)[node] };
return false;
},
.unreachable_from => unreachable,
}
switch (tree.nodes.items(.tag)[parent]) {
// Check parent to know if we should push a new scope and possibly add
// a capture. In some cases we cannot tell if a new scope should be
// pushed only from the node itself (e.g. for single-statement blocks).
// Captures are not part of the Ast, so they must be added here.
.@"catch",
.@"orelse",
.switch_case_one,
.switch_case,
.while_simple,
.while_cont,
.@"while",
.for_simple,
.@"for",
.if_simple,
.@"if",
=> {
// lhs is the condition, nothing special to do
const lhs = tree.nodes.items(.data)[parent].lhs;
if (node != lhs) {
try self.pushScopeWithCapture(tree, node);
return true;
}
},
// Check parent to know if we are traversing fn parameter declarations
.fn_proto_simple,
.fn_proto_multi,
.fn_proto_one,
.fn_proto,
=> {
// Only declare parameters if fn_proto* is part of a fn_decl
// (i.e. has a lbrace afterward).
// Since fn_proto* sub nodes are types, check for a leading ':'
// to distinguish parameters from return type.
const maybe_colon = tree.firstToken(node) - 1;
const maybe_lbrace = tree.lastToken(parent) + 1;
if (tree.tokens.items(.tag)[maybe_lbrace] == .l_brace and
tree.tokens.items(.tag)[maybe_colon] == .colon)
{
const name = maybe_colon - 1;
std.debug.assert(tree.tokens.items(.tag)[name] == .identifier);
try self.addBinding(tree, parent, name);
}
},
else => {},
}
// normal case: create a new scope for fn decls, blocks and containers
switch (tree.nodes.items(.tag)[node]) {
.fn_decl,
.container_decl,
.container_decl_trailing,
.container_decl_two,
.container_decl_two_trailing,
.container_decl_arg,
.container_decl_arg_trailing,
.block_two,
.block_two_semicolon,
.block,
.block_semicolon,
=> {
try self.pushScope();
},
else => {},
}
// continue tree traversal
return true;
}
fn after(
self: *ZloppyChecks,
patches: *Patches,
tree: Tree,
parent: NodeIndex,
node: NodeIndex,
) !void {
const parent_tag = tree.nodes.items(.tag)[parent];
const node_token = tree.nodes.items(.main_token)[node];
switch (tree.nodes.items(.tag)[node]) {
// check unused variable in current fn_decls, blocks
.fn_decl,
.block_two,
.block_two_semicolon,
.block,
.block_semicolon,
=> {
try self.popScopeGenPatches(patches, anchorFromNode(tree, node));
return;
},
// only pop scope in containers, don't check for unused variables
.container_decl,
.container_decl_trailing,
.container_decl_two,
.container_decl_two_trailing,
.container_decl_arg,
.container_decl_arg_trailing,
=> {
self.popScope();
return;
},
// update current scope for var decls
.global_var_decl, .local_var_decl, .simple_var_decl, .aligned_var_decl => {
const name = node_token + 1;
try self.addBinding(tree, node, name);
},
// set used bit for identifier
.identifier => {
self.setUsed(tree, node_token);
},
// indicate next statements in scope will be unreachable
.@"continue",
.@"break",
.@"return",
=> {
std.debug.assert(self.state == .reachable_code);
self.state = .return_reached;
},
// set used bit for identifier used in asm_output
.asm_output => {
const lhs = tree.nodes.items(.data)[node].lhs;
if (lhs == 0) {
const name = tree.nodes.items(.data)[node].rhs - 1;
std.debug.assert(tree.tokens.items(.tag)[name] == .identifier);
self.setUsed(tree, name);
}
},
else => {},
}
// scope pushed in before() must be popped on same conditions
switch (parent_tag) {
.@"catch",
.@"orelse",
.switch_case_one,
.switch_case,
.while_simple,
.while_cont,
.@"while",
.for_simple,
.@"for",
.if_simple,
.@"if",
=> {
// lhs is the condition, nothing special to do
const lhs = tree.nodes.items(.data)[parent].lhs;
if (node != lhs) {
try self.popScopeGenPatches(patches, anchorFromNode(tree, node));
}
},
else => {},
}
}
};
pub fn genPatches(gpa: mem.Allocator, tree: Tree) !Patches {
var patches = Patches.init(gpa);
var checks = try ZloppyChecks.init(gpa);
defer checks.deinit();
for (tree.rootDecls()) |node| {
if (!try traverseNode(&checks, &patches, tree, 0, node))
break;
}
// return without checking unused variables in top-level scope (not needed)
return patches;
}
fn isAllowedInZloppyComment(char: u8) bool {
return switch (char) {
'"', '/', '\'', ';', ',', '{', '}' => false,
else => true,
};
}
fn cleanLine(
source: []u8,
start: usize,
end: usize,
zloppy_comment_start: usize,
) !void {
const descr = mem.trimLeft(u8, source[zloppy_comment_start + zloppy_comment.len .. end], " ");
if (mem.startsWith(u8, descr, "unused var")) {
// overwrite line '\n' (end + 1) to make sure no extraneous empty line is left over
mem.set(u8, source[start .. end + 1], ' ');
} else if (mem.startsWith(u8, descr, "unreachable code")) {
mem.set(u8, source[zloppy_comment_start..end], ' ');
if (mem.indexOf(u8, source[start..end], "//")) |first_comment| {
mem.set(u8, source[start + first_comment .. start + first_comment + 2], ' ');
} else {
return error.InvalidCommentFound;
}
} else {
return error.InvalidCommentFound;
}
}
pub fn cleanSource(filename: []const u8, source: []u8) !u32 {
var removed: u32 = 0;
var start: usize = 0;
var line_no: usize = 1;
blk: while (mem.indexOfPos(u8, source, start, "\n")) |end| : ({
start = end + 1;
line_no += 1;
}) {
const line = source[start..end];
if (line.len < zloppy_comment.len)
continue :blk;
// Since not all characters are allowed in zloppy comments, we can
// simply look for "// XXX ZLOPPY" from the end of the line without
// having to check for string literals and such.
var i: usize = line.len;
while (i > 1) : (i -= 1) {
const maybe_comment_start = line[i - 2 .. i];
const char = line[i - 1];
if (mem.eql(u8, maybe_comment_start, "//") and
mem.startsWith(u8, line[i - 2 ..], zloppy_comment))
{
cleanLine(source, start, end, start + i - 2) catch |err| {
std.log.warn(
"invalid zloppy comment found in file '{s}' on line {}, " ++
"file left untouched",
.{ filename, line_no },
);
return err;
};
removed += 1;
} else if (!isAllowedInZloppyComment(char)) {
continue :blk;
}
}
}
return removed;
} | src/zloppy.zig |
const std = @import("std");
const Game = struct {
allocator: std.mem.Allocator,
rolls: []u8,
boards: []Board,
fn parse(allocator: std.mem.Allocator, text: []const u8) !Game {
var rolls = std.ArrayList(u8).init(allocator);
defer rolls.deinit();
var boards = std.ArrayList(Board).init(allocator);
defer boards.deinit();
var chunk_it = std.mem.split(u8, text, "\n\n");
const rolls_line = chunk_it.next() orelse return error.NoRollsLine;
var rolls_it = std.mem.tokenize(u8, rolls_line, ",");
while (rolls_it.next()) |roll|
try rolls.append(try std.fmt.parseInt(u8, roll, 10));
while (chunk_it.next()) |chunk|
try boards.append(try Board.parse(chunk));
return Game{
.allocator = allocator,
.rolls = rolls.toOwnedSlice(),
.boards = boards.toOwnedSlice(),
};
}
fn deinit(self: *Game) void {
self.allocator.free(self.rolls);
self.allocator.free(self.boards);
}
};
const Board = struct {
numbers: [5][5]u8,
marks: struct {
rows: [5]u5,
cols: [5]u5,
},
fn parse(text: []const u8) !Board {
var ret: Board = undefined;
var line_it = std.mem.tokenize(u8, text, "\n");
for (ret.numbers) |*row| {
const line = line_it.next() orelse return error.NoLine;
var it = std.mem.tokenize(u8, line, " ");
for (row) |*number| {
const num_str = it.next() orelse return error.NoNumber;
number.* = try std.fmt.parseInt(u8, num_str, 10);
}
}
ret.marks = .{
.rows = std.mem.zeroes([5]u5),
.cols = std.mem.zeroes([5]u5),
};
return ret;
}
fn won(self: Board) bool {
for (self.marks.rows) |row|
if (row == 0x1f)
return true;
for (self.marks.cols) |col|
if (col == 0x1f)
return true;
return false;
}
fn mark(self: *Board, roll: u8) void {
const pos = blk: {
for (self.numbers) |row, i| {
for (row) |num, j| {
if (num == roll) {
break :blk .{ .row = i, .col = j };
}
}
} else return;
};
self.marks.rows[pos.row] |= (@as(u5, 1) << @truncate(u3, pos.col));
self.marks.cols[pos.col] |= (@as(u5, 1) << @truncate(u3, pos.row));
}
fn sumUnmarked(self: Board) u32 {
var ret: u32 = 0;
for (self.marks.rows) |row, i| {
var j: u3 = 0;
while (j < 5) : (j += 1) {
if (0 == row & (@as(u5, 1) << j)) {
ret += self.numbers[i][j];
}
}
}
return ret;
}
};
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = gpa.allocator();
defer _ = gpa.deinit();
const data = try std.io.getStdIn().readToEndAlloc(allocator, std.math.maxInt(usize));
defer allocator.free(data);
var game = try Game.parse(allocator, data);
defer game.deinit();
var losers = std.AutoHashMap(usize, void).init(allocator);
defer losers.deinit();
{
var i: usize = 0;
while (i < game.boards.len) : (i += 1)
try losers.putNoClobber(i, {});
}
std.log.info("rolls: {}, boards: {}", .{ game.rolls.len, game.boards.len });
for (game.rolls) |roll| {
for (game.boards) |*board, i| {
if (!losers.contains(i))
continue;
board.mark(roll);
if (board.won()) {
if (losers.count() > 1) {
_ = losers.remove(i);
continue;
}
const unmarked_sum = board.sumUnmarked();
std.log.info("board {} wins last, last roll was {}, unmarked sum is {}, score is {}", .{
i,
roll,
unmarked_sum,
roll * unmarked_sum,
});
return;
}
}
}
}
test "parse example data" {
const expectEqual = std.testing.expectEqual;
const data =
\\7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1
\\
\\22 13 17 11 0
\\ 8 2 23 4 24
\\21 9 14 16 7
\\ 6 10 3 18 5
\\ 1 12 20 15 19
\\
\\ 3 15 0 2 22
\\ 9 18 13 17 5
\\19 8 7 25 23
\\20 11 10 24 4
\\14 21 16 12 6
\\
\\14 21 17 24 4
\\10 16 15 9 19
\\18 8 23 26 20
\\22 11 13 6 5
\\ 2 0 12 3 7
\\
;
var game = try Game.parse(std.testing.allocator, data);
defer game.deinit();
try expectEqual(@as(usize, 27), game.rolls.len);
try expectEqual(@as(u8, 7), game.rolls[0]);
try expectEqual(@as(usize, 3), game.boards.len);
}
test "unmarked sum" {
const board = Board{
.numbers = [_][5]u8{
[_]u8{ 14, 21, 17, 24, 4 },
[_]u8{ 10, 16, 15, 9, 19 },
[_]u8{ 18, 8, 23, 26, 20 },
[_]u8{ 22, 11, 13, 6, 5 },
[_]u8{ 2, 0, 12, 3, 7 },
},
.marks = .{
// these are mirrored from how things are highlighted in the
// example
.rows = [_]u5{
0b11111,
0b01000,
0b00100,
0b10010,
0b10011,
},
.cols = std.mem.zeroes([5]u5),
},
};
try std.testing.expectEqual(@as(u32, 188), board.sumUnmarked());
} | src/04.zig |
const std = @import("std");
const Postgres = @import("postgres");
const build_options = @import("build_options");
const Pg = Postgres.Pg;
const Result = Postgres.Result;
const Builder = Postgres.Builder;
const FieldInfo = Postgres.FieldInfo;
const Parser = Postgres.Parser;
const testing = std.testing;
const Allocator = std.mem.Allocator;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = &gpa.allocator;
const Test_Users = struct {
id: u16,
name: []const u8,
age: u16,
};
test "database" {
var db = try Pg.connect(allocator, build_options.db_uri);
defer db.deinit();
const schema =
\\CREATE TABLE IF NOT EXISTS test_users (id INT, name TEXT, age INT);
;
_ = try db.exec(schema);
var data = Test_Users{ .id = 2, .name = "Steve", .age = 25 };
var data2 = Test_Users{ .id = 3, .name = "Tom", .age = 25 };
_ = try db.insert(Test_Users{ .id = 1, .name = "Charlie", .age = 20 });
_ = try db.insert(data);
//Insert pointer
_ = try db.insert(&data2);
//Insert array
_ = try db.insert(&[_]Test_Users{
Test_Users{ .id = 4, .name = "Tony", .age = 33 },
Test_Users{ .id = 5, .name = "Sara", .age = 33 },
Test_Users{ .id = 6, .name = "Tony", .age = 33 },
});
var result = try db.execValues("SELECT * FROM test_users WHERE name = {s}", .{"Charlie"});
var result2 = try db.execValues("SELECT * FROM test_users WHERE id = {d}", .{2});
var result3 = try db.execValues("SELECT * FROM test_users WHERE age = {d}", .{25});
var result4 = try db.execValues("SELECT * FROM test_users WHERE age = {d}", .{33});
//When all results are not parsed, the memory must be manually deinited
defer result4.deinit();
var user = result.parse(Test_Users, null).?;
var user2 = result2.parse(Test_Users, null).?;
var user3 = result4.parse(Test_Users, null).?;
while (result3.parse(Test_Users, null)) |res| try testing.expectEqual(res.age, 25);
//Temp memory
var temp_memory = std.heap.ArenaAllocator.init(std.heap.page_allocator);
const temp_allocator = &temp_memory.allocator;
//SQL query builder
var builder = Builder.new(.Update, temp_allocator).table("test_users").where(try Builder.buildQuery("WHERE id = {d};", .{2}, temp_allocator));
defer {
builder.deinit();
temp_memory.deinit();
}
try builder.addColumn("name");
try builder.addValue("Harold");
try builder.end();
_ = try db.exec(builder.command());
var result5 = try db.execValues("SELECT * FROM test_users WHERE id = {d}", .{2});
var user4 = result5.parse(Test_Users, null).?;
try testing.expectEqual(result.rows, 1);
try testing.expectEqual(result2.rows, 1);
try testing.expectEqual(result3.rows, 2);
try testing.expectEqual(result4.rows, 3);
try testing.expectEqual(user.id, 1);
try testing.expectEqual(user.age, 20);
try testing.expectEqual(user2.id, 2);
try testing.expectEqualStrings(user2.name, "Steve");
try testing.expectEqual(user3.id, 4);
try testing.expectEqualStrings(user3.name, "Tony");
try testing.expectEqual(user4.id, 2);
try testing.expectEqualStrings(user4.name, "Harold");
_ = try db.exec("DROP TABLE test_users");
}
const Stats = struct { wins: u16 = 0, losses: u16 = 0 };
const Test_Player = struct {
id: u16,
name: []const u8,
stats: Stats,
cards: ?[][]const u8 = null,
pub fn onSave(_: *Test_Player, comptime field: FieldInfo, builder: *Builder, value: anytype) !void {
switch (field.type) {
?[][]const u8 => try builder.addStringArray(value.?),
Stats => try builder.addJson(value),
else => {},
}
}
pub fn onLoad(self: *Test_Player, comptime field: FieldInfo, value: []const u8, parser: Parser) !void {
switch (field.type) {
?[][]const u8 => self.cards = try parser.parseArray(value, ","),
Stats => self.stats = try parser.parseJson(Stats, value),
else => {},
}
}
};
test "Custom types" {
var db = try Pg.connect(allocator, build_options.db_uri);
defer {
std.debug.assert(!gpa.deinit());
db.deinit();
}
const schema =
\\CREATE TABLE IF NOT EXISTS test_player (id INT, name TEXT, stats JSONB, cards TEXT[]);
;
_ = try db.exec(schema);
var cards = [3][]const u8{
"Ace",
"2",
"Queen",
};
var data = Test_Player{ .id = 2, .name = "Steve", .stats = .{ .wins = 5, .losses = 3 }, .cards = cards[0..] };
_ = try db.insert(&data);
var result = try db.execValues("SELECT * FROM test_player WHERE name = {s}", .{"Steve"});
var data_cache = result.parse(Test_Player, allocator).?;
try testing.expectEqual(data_cache.id, 2);
try testing.expectEqualStrings(data_cache.name, "Steve");
try testing.expectEqual(data_cache.stats.wins, 5);
try testing.expectEqual(data_cache.stats.losses, 3);
//Free cards allocation
defer allocator.free(data_cache.cards.?);
_ = try db.exec("DROP TABLE test_player");
} | tests/database.zig |
const std = @import("std");
const Builder = std.build.Builder;
const generator = @import("generator.zig");
fn concatAndReturnBuffer(allocator: std.mem.Allocator, one: []const u8, two: []const u8) !std.Buffer {
var b = try std.Buffer.init(allocator, one);
try b.append(two);
return b;
}
pub fn build(b: *Builder) !void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
const gpa = general_purpose_allocator.allocator();
const file_path = std.process.getEnvVarOwned(gpa, "BF_FILE_PATH") catch null;
if(file_path) |path| {
const file_name = std.fs.path.basename(path);
var temp_file_name : []u8 = try std.fmt.allocPrint(gpa, "{s}.zig", .{file_name});
var temp_file_full_path : []u8 = try std.fmt.allocPrint(gpa, "generated/{s}", .{temp_file_name});
var file_handle = try std.fs.cwd().openFile(path, .{ .read = true, .write = false });
defer file_handle.close();
var buffer = try file_handle.readToEndAlloc(gpa, std.math.maxInt(u16));
var out_buffer = std.ArrayList(u8).init(gpa);
try generator.generate(buffer, &out_buffer);
var temp_file_handler = try std.fs.cwd().createFile(temp_file_full_path, .{});
temp_file_handler.close();
temp_file_handler = try std.fs.cwd().openFile(temp_file_full_path, .{.read = false, .write = true});
try temp_file_handler.writeAll(out_buffer.items);
temp_file_handler.close();
const exe = b.addExecutable("program", temp_file_full_path);
exe.setTarget(target);
exe.setBuildMode(mode);
exe.install();
const run_cmd = exe.run();
run_cmd.step.dependOn(b.getInstallStep());
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
}
var tests_generator = b.addTest("generator.zig");
const test_step = b.step("test", "run all tests");
test_step.dependOn(&tests_generator.step);
} | build.zig |
const std = @import("std");
const http = @import("apple_pie");
const router = http.router;
pub const transaction_tree = @import("./transaction_tree.zig");
const context = @import("./context.zig");
const Context = @import("./context.zig").Context;
//pub const io_mode = .evented;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
var my_context = Context.init(&gpa.allocator);
const address = try std.net.Address.parseIp("127.0.0.1", 35866);
std.log.info("listening on address {}", .{address});
try http.listenAndServe(
&gpa.allocator,
address,
&my_context,
comptime router.Router(*Context, &.{
router.get("/balance", getBalance),
router.post("/transactions", postTransaction),
router.post("/spend", postSpend),
router.get("/", getIndex),
}),
);
}
fn getIndex(_: *Context, response: *http.Response, _: http.Request) !void {
try response.writer().print("Hello, world!\n", .{});
}
fn getBalance(ctx: *Context, response: *http.Response, _: http.Request) !void {
var balance = try ctx.getBalance(ctx.allocator);
defer balance.deinit();
var iter = balance.iterator();
while (iter.next()) |entry| {
try response.writer().print("{s}: {}\n", .{ entry.key_ptr.*, entry.value_ptr.* });
}
}
fn postTransaction(ctx: *Context, response: *http.Response, request: http.Request) !void {
const Input = struct {
payer: ?[]const u8 = null,
points: ?i128 = null,
timestamp: ?[]const u8 = null,
};
const Output = struct {
message: []const u8,
};
var arena = std.heap.ArenaAllocator.init(ctx.allocator);
defer arena.deinit();
const headers = try request.headers(&arena.allocator);
const mime_type = headers.get("Content-Type") orelse return error.InvalidFormat;
if (!std.mem.eql(u8, "application/json", mime_type)) {
return error.InvalidFormat;
}
const input = try std.json.parse(Input, &std.json.TokenStream.init(request.body()), .{ .allocator = &arena.allocator });
if (input.payer == null or input.points == null or input.timestamp == null) {
var error_message = std.ArrayList(u8).init(&arena.allocator);
const writer = error_message.writer();
try writer.writeAll("Malformed request; the following fields are missing: ");
if (input.payer == null) try writer.writeAll("payer, ");
if (input.points == null) try writer.writeAll("points, ");
if (input.timestamp == null) try writer.writeAll("timestamp, ");
response.status_code = .bad_request;
try response.headers.put("Content-Type", "application/json");
try std.json.stringify(Output{
.message = error_message.items,
}, .{}, response.writer());
return;
}
const payer = input.payer orelse return error.InvalidFormat;
const points = input.points orelse return error.InvalidFormat;
const timestamp_string = input.timestamp orelse return error.InvalidFormat;
const datetime = try context.parseDateTime(timestamp_string);
try ctx.addPoints(datetime, payer, points);
try response.headers.put("Content-Type", "application/json");
try std.json.stringify(Output{
.message = "Points added",
}, .{}, response.writer());
}
fn postSpend(ctx: *Context, response: *http.Response, request: http.Request) !void {
const Input = struct {
points: ?i128 = null,
};
const OutputErr = struct {
message: []const u8,
};
var arena = std.heap.ArenaAllocator.init(ctx.allocator);
defer arena.deinit();
const headers = try request.headers(&arena.allocator);
const mime_type = headers.get("Content-Type") orelse return error.InvalidFormat;
if (!std.mem.eql(u8, "application/json", mime_type)) {
return error.InvalidFormat;
}
const input = try std.json.parse(Input, &std.json.TokenStream.init(request.body()), .{ .allocator = &arena.allocator });
if (input.points == null) {
var error_message = std.ArrayList(u8).init(&arena.allocator);
const writer = error_message.writer();
try writer.writeAll("Malformed request; the following fields are missing: ");
if (input.points == null) try writer.writeAll("points, ");
response.status_code = .bad_request;
try response.headers.put("Content-Type", "application/json");
try std.json.stringify(OutputErr{
.message = error_message.items,
}, .{}, response.writer());
return;
}
const points = input.points orelse return error.InvalidFormat;
const payers_spent_from = try ctx.spendPoints(&arena.allocator, points);
var iter = payers_spent_from.iterator();
while (iter.next()) |entry| {
try response.writer().print("{s}: {}\n", .{ entry.key_ptr.*, entry.value_ptr.* });
}
}
test {
std.testing.refAllDecls(@This());
} | src/main.zig |
const std = @import("std");
const pkgs = struct {
// TinyVG package
const tvg = std.build.Pkg{
.name = "tvg",
.path = .{ .path = "src/lib/tinyvg.zig" },
.dependencies = &.{ptk},
};
const ptk = std.build.Pkg{
.name = "ptk",
.path = .{ .path = "vendor/parser-toolkit/src/main.zig" },
};
const args = std.build.Pkg{
.name = "args",
.path = .{ .path = "vendor/zig-args/args.zig" },
};
};
fn initNativeLibrary(lib: *std.build.LibExeObjStep, mode: std.builtin.Mode, target: std.zig.CrossTarget) void {
lib.addPackage(pkgs.tvg);
lib.addIncludeDir("src/binding/include");
lib.setBuildMode(mode);
lib.setTarget(target);
lib.bundle_compiler_rt = true;
}
pub fn build(b: *std.build.Builder) !void {
const www_folder = std.build.InstallDir{ .custom = "www" };
const is_release = b.option(bool, "release", "Prepares a release build") orelse false;
const enable_polyfill = b.option(bool, "polyfill", "Enables the polyfill build") orelse !is_release;
const enable_poly_example = b.option(bool, "web-example", "Adds example files to the prefix/www folder for easier development") orelse (enable_polyfill and !is_release);
const bundle_libs = b.option(bool, "libs", "Install the libs") orelse true;
const bundle_headers = b.option(bool, "headers", "Install the headers") orelse true;
const bundle_tools = b.option(bool, "tools", "Install the libs") orelse true;
const target = b.standardTargetOptions(.{});
const mode = if (is_release) .ReleaseSafe else b.standardReleaseOptions();
const static_native_lib = b.addStaticLibrary("tinyvg", "src/binding/binding.zig");
initNativeLibrary(static_native_lib, mode, target);
if (bundle_libs) {
static_native_lib.install();
}
const dynamic_native_lib = b.addSharedLibrary("tinyvg.dll", "src/binding/binding.zig", .unversioned);
initNativeLibrary(dynamic_native_lib, mode, target);
if (bundle_libs) {
dynamic_native_lib.install();
}
if (bundle_headers) {
const install_header = b.addInstallFileWithDir(.{ .path = "src/binding/include/tinyvg.h" }, .header, "tinyvg.h");
b.getInstallStep().dependOn(&install_header.step);
}
const render = b.addExecutable("tvg-render", "src/tools/render.zig");
render.setBuildMode(mode);
render.setTarget(target);
render.addPackage(pkgs.tvg);
render.addPackage(pkgs.args);
if (bundle_tools) {
render.install();
}
const text = b.addExecutable("tvg-text", "src/tools/text.zig");
text.setBuildMode(mode);
text.setTarget(target);
text.addPackage(pkgs.tvg);
text.addPackage(pkgs.args);
text.addPackage(pkgs.ptk);
if (bundle_tools) {
text.install();
}
const ground_truth_generator = b.addExecutable("ground-truth-generator", "src/data/ground-truth.zig");
ground_truth_generator.setBuildMode(mode);
ground_truth_generator.addPackage(pkgs.tvg);
const generate_ground_truth = ground_truth_generator.run();
generate_ground_truth.cwd = "examples/tinyvg";
const gen_gt_step = b.step("generate", "Regenerates the ground truth data.");
gen_gt_step.dependOn(&generate_ground_truth.step);
const files = [_][]const u8{
// "app_menu.tvg", "workspace.tvg", "workspace_add.tvg", "feature-showcase.tvg", "arc-variants.tvg", ,
"shield-16.tvg", "shield-8.tvg", "shield-32.tvg",
"everything.tvg", "everything-32.tvg",
};
inline for (files) |file| {
const tvg_conversion = render.run();
tvg_conversion.addArg(file);
tvg_conversion.addArg("--super-sampling");
tvg_conversion.addArg("4"); // 16 times multisampling
tvg_conversion.addArg("--output");
tvg_conversion.addArg(file[0 .. file.len - 3] ++ "tga");
tvg_conversion.cwd = "examples/tinyvg";
const tvgt_conversion = text.run();
tvgt_conversion.addArg(file);
tvgt_conversion.addArg("--output");
tvgt_conversion.addArg(file[0 .. file.len - 3] ++ "tvgt");
tvgt_conversion.cwd = "examples/tinyvg";
const png_conversion = b.addSystemCommand(&[_][]const u8{
"convert",
"-strip",
file[0 .. file.len - 3] ++ "tga",
file[0 .. file.len - 3] ++ "png",
});
png_conversion.cwd = "examples/tinyvg";
png_conversion.step.dependOn(&tvg_conversion.step);
gen_gt_step.dependOn(&tvgt_conversion.step);
gen_gt_step.dependOn(&png_conversion.step);
}
{
const tvg_tests = b.addTestSource(pkgs.tvg.path);
for (pkgs.tvg.dependencies.?) |dep| {
tvg_tests.addPackage(dep);
}
tvg_tests.addPackage(std.build.Pkg{
.name = "ground-truth",
.path = .{ .path = "src/data/ground-truth.zig" },
.dependencies = &[_]std.build.Pkg{
pkgs.tvg,
},
});
const static_binding_test = b.addExecutable("static-native-binding", null);
static_binding_test.setBuildMode(mode);
static_binding_test.linkLibC();
static_binding_test.addIncludeDir("src/binding/include");
static_binding_test.addCSourceFile("examples/native/usage.c", &[_][]const u8{ "-Wall", "-Wextra", "-pedantic", "-std=c99" });
static_binding_test.linkLibrary(static_native_lib);
const dynamic_binding_test = b.addExecutable("static-native-binding", null);
dynamic_binding_test.setBuildMode(mode);
dynamic_binding_test.linkLibC();
dynamic_binding_test.addIncludeDir("src/binding/include");
dynamic_binding_test.addCSourceFile("examples/native/usage.c", &[_][]const u8{ "-Wall", "-Wextra", "-pedantic", "-std=c99" });
dynamic_binding_test.linkLibrary(dynamic_native_lib);
const static_binding_test_run = static_binding_test.run();
static_binding_test_run.cwd = "zig-cache";
const dynamic_binding_test_run = dynamic_binding_test.run();
dynamic_binding_test_run.cwd = "zig-cache";
const test_step = b.step("test", "Runs all tests");
test_step.dependOn(&tvg_tests.step);
test_step.dependOn(&static_binding_test_run.step);
if (!is_release) {
// workaround for https://github.com/ziglang/zig/pull/10347/files
test_step.dependOn(&dynamic_binding_test_run.step);
}
}
{
const merge_covs = b.addSystemCommand(&[_][]const u8{
"kcov",
"--merge",
b.pathFromRoot("kcov-output"),
b.pathFromRoot("kcov-output"),
});
inline for (files) |file| {
merge_covs.addArg(b.pathJoin(&[_][]const u8{ b.pathFromRoot("kcov-output"), file }));
}
const tvg_coverage = b.addTest("src/lib/tvg.zig");
tvg_coverage.addPackage(std.build.Pkg{
.name = "ground-truth",
.path = .{ .path = "src/data/ground-truth.zig" },
.dependencies = &[_]std.build.Pkg{
pkgs.tvg,
},
});
tvg_coverage.setExecCmd(&[_]?[]const u8{
"kcov",
"--exclude-path=~/software/zig-current",
b.pathFromRoot("kcov-output"), // output dir for kcov
null, // to get zig to use the --test-cmd-bin flag
});
const generator_coverage = b.addSystemCommand(&[_][]const u8{
"kcov",
"--exclude-path=~/software/zig-current",
b.pathFromRoot("kcov-output"), // output dir for kcov
});
generator_coverage.addArtifactArg(ground_truth_generator);
inline for (files) |file| {
const tvg_conversion = b.addSystemCommand(&[_][]const u8{
"kcov",
"--exclude-path=~/software/zig-current",
b.pathJoin(&[_][]const u8{ b.pathFromRoot("kcov-output"), file }), // output dir for kcov
});
tvg_conversion.addArtifactArg(render);
tvg_conversion.addArg(file);
tvg_conversion.addArg("--output");
tvg_conversion.addArg(file[0 .. file.len - 3] ++ "tga");
tvg_conversion.cwd = "examples/tinyvg";
merge_covs.step.dependOn(&tvg_conversion.step);
}
merge_covs.step.dependOn(&tvg_coverage.step);
merge_covs.step.dependOn(&generator_coverage.step);
const coverage_step = b.step("coverage", "Generates ground truth and runs all tests with kcov");
coverage_step.dependOn(&merge_covs.step);
}
// web stuff
if (enable_polyfill) {
const polyfill = b.addSharedLibrary("tinyvg", "src/polyfill/tinyvg.zig", .unversioned);
if (is_release) {
polyfill.setBuildMode(.ReleaseSmall);
polyfill.strip = true;
} else {
polyfill.setBuildMode(mode);
}
polyfill.setTarget(.{
.cpu_arch = .wasm32,
.cpu_model = .baseline,
.os_tag = .freestanding,
});
polyfill.addPackage(pkgs.tvg);
polyfill.install();
polyfill.install_step.?.dest_dir = www_folder;
if (enable_polyfill) {
const release_files = [_][]const u8{
"src/polyfill/tinyvg.js",
};
const debug_files = [_][]const u8{
"examples/web/index.htm",
"examples/tinyvg/shield-16.tvg",
"examples/tinyvg/everything-32.tvg",
"src/polyfill/tinyvg.js",
};
const web_example_files = if (enable_poly_example)
&debug_files
else
&release_files;
for (web_example_files) |src_path| {
const copy_stuff = b.addInstallFileWithDir(.{ .path = src_path }, www_folder, std.fs.path.basename(src_path));
if (target.isNative() and enable_poly_example) {
copy_stuff.step.dependOn(gen_gt_step);
}
b.getInstallStep().dependOn(©_stuff.step);
}
}
}
} | build.zig |
const std = @import("std");
const math = std.math;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const Self = @This();
const FLIR = @import("./FLIR.zig");
f: *FLIR,
vardef: []u16,
// Simple and Efficient Construction of Static Single Assignment Form
// <NAME> et al, 2013
pub fn ssa_gvn(flir: *FLIR) !void {
const vardef = try flir.a.alloc(u16, flir.n.items.len * flir.nvar);
defer flir.a.free(vardef);
std.mem.set(u16, vardef, FLIR.NoRef);
const self: Self = .{ .f = flir, .vardef = vardef };
try self.ssa();
}
fn ssa(self: Self) !void {
for (self.f.n.items) |n| {
try self.fill_blk(n.firstblk);
}
// at this point all nodes have been _filled_ but join nodes (npred > 1)
// have not been _sealed_, in the terminology of Braun 2013
// TODO: keep a worklist of unfinished phi nodes, more effective +
// otherwise might need multiple passes until a fix point
for (self.f.n.items) |n| {
try self.resolve_blk(n.firstblk);
}
try self.delete_vars(self.f.n.items[0].firstblk);
}
fn fill_blk(self: Self, first_blk: u16) !void {
var cur_blk: ?u16 = first_blk;
while (cur_blk) |blk| {
var b = &self.f.b.items[blk];
const n = b.node;
for (b.i) |*i| {
if (i.tag == .putvar) {
const ivar = self.f.iref(i.op1) orelse return error.UW0tM8;
self.vdi(n, ivar.op1).* = i.op2;
// TODO: store debug info, or some shit
i.tag = .empty;
} else if (.tag == .phi) {
// TODO: likely we'll never need to consider an existing
// phi node here but verify this!
} else {
const nop = FLIR.n_op(i.tag, false);
if (nop > 0) {
i.op1 = try self.read_ref(n, i.op1);
if (nop > 1) {
i.op2 = try self.read_ref(n, i.op2);
}
}
}
}
cur_blk = b.next();
}
}
fn vdi(self: Self, node: u16, v: u16) *u16 {
return &self.vardef[self.f.nvar * node + v];
}
fn read_ref(self: Self, node: u16, ref: u16) !u16 {
const i = self.f.iref(ref) orelse return FLIR.NoRef;
if (i.tag == .variable) {
return self.read_var(node, i.*);
} else {
// already on SSA-form, nothing to do
return ref;
}
}
const MaybePhi = @typeInfo(@TypeOf(FLIR.prePhi)).Fn.return_type.?;
fn read_var(self: Self, node: u16, v: FLIR.Inst) MaybePhi {
// It matters where you are
const vd = self.vdi(node, v.op1);
if (vd.* != FLIR.NoRef) {
return vd.*;
}
const n = self.f.n.items[node];
const def = thedef: {
if (n.npred == 0) {
unreachable; // TODO: error for undefined var
} else if (n.npred == 1) {
const pred = self.f.refs.items[n.predref];
// assert recursion eventually terminates
assert(self.f.n.items[pred].dfnum < n.dfnum);
break :thedef try self.read_var(pred, v);
} else {
// as an optimization, we could check if all predecessors
// are filled (pred[i].dfnum < n.dfnum), and in that case
// fill the phi node already;
break :thedef try self.f.prePhi(node, v);
}
};
vd.* = def;
return def;
}
fn resolve_blk(self: Self, first_blk: u16) !void {
var cur_blk: ?u16 = first_blk;
while (cur_blk) |blk| {
var b = &self.f.b.items[blk];
for (b.i) |*i, idx| {
if (i.tag == .phi) {
try self.resolve_phi(blk, FLIR.uv(idx));
}
}
cur_blk = b.next();
}
}
fn resolve_phi(self: Self, b: u16, idx: u16) !void {
const blk = &self.f.b.items[b];
const i = &blk.i[idx];
if (i.op2 == 1) return;
const ivar = self.f.iref(i.op1) orelse return error.GLUGG;
var onlyref: ?u16 = null;
for (self.f.preds(blk.node)) |v| {
const ref = try self.read_var(v, ivar.*);
_ = try self.f.binop(v, .putphi, ref, FLIR.toref(b, idx));
onlyref = if (onlyref) |only| if (only == ref) only else FLIR.NoRef else ref;
}
i.op1 = 0;
i.op2 = 1; // flag for "phi already resolved"
}
fn delete_vars(self: Self, first_blk: u16) !void {
var cur_blk: ?u16 = first_blk;
while (cur_blk) |blk| {
var b = &self.f.b.items[blk];
for (b.i) |*i| {
if (i.tag == .variable) {
i.tag = .empty;
}
}
cur_blk = b.next();
}
} | src/SSA_GVN.zig |
const std = @import("std");
const pkgs = @import("deps.zig").pkgs;
const builtin = @import("builtin");
const Mode = std.builtin.Mode;
const CrossTarget = std.zig.CrossTarget;
const Target = std.Target;
const BuildTarget = struct {
name: []const u8,
cross_target: CrossTarget,
mode: Mode,
};
pub fn build(b: *std.build.Builder) void {
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const targets = [_]BuildTarget{
.{
.name = "kernel-installer-i386-windows",
.cross_target = .{
.cpu_arch = Target.Cpu.Arch.i386,
.os_tag = Target.Os.Tag.windows,
},
.mode = Mode.ReleaseFast
},
.{
.name = "kernel-installer-x86_64-windows",
.cross_target = .{
.cpu_arch = Target.Cpu.Arch.x86_64,
.os_tag = Target.Os.Tag.windows,
},
.mode = Mode.ReleaseFast
},
.{
.name = "kernel-installer-i386-linux",
.cross_target = .{
.cpu_arch = Target.Cpu.Arch.i386,
.os_tag = Target.Os.Tag.linux,
},
.mode = Mode.ReleaseFast
},
.{
.name = "kernel-installer-x86_64-linux",
.cross_target = .{
.cpu_arch = Target.Cpu.Arch.x86_64,
.os_tag = Target.Os.Tag.linux,
},
.mode = Mode.ReleaseFast
},
.{
.name = "kernel-installer-x86_64-macos",
.cross_target = .{
.cpu_arch = Target.Cpu.Arch.x86_64,
.os_tag = Target.Os.Tag.macos,
},
.mode = Mode.ReleaseFast
},
};
for (targets) |target| {
const exe = b.addExecutable(target.name, "src/main.zig");
exe.strip = true;
exe.single_threaded = true;
exe.setTarget(target.cross_target);
exe.setBuildMode(target.mode);
exe.linkLibC();
pkgs.addAllTo(exe);
exe.install();
}
} | build-all.zig |
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day12.txt");
const Type = enum {
Start,
End,
Big,
Small,
};
const Cave = struct {
exits : [16]i16,
ty : Type,
pub fn init(name : []const u8) @This() {
var ty = Type.Small;
if (std.mem.eql(u8, name, "start")) {
ty = Type.Start;
} else if (std.mem.eql(u8, name, "end")) {
ty = Type.End;
} else if (name[0] >= 'A' and name[0] <= 'Z') {
ty = Type.Big;
}
return Cave { .exits = [_]i16{-1} ** 16 , .ty = ty };
}
pub fn addExit(this : *@This(), e : u8) void {
for (this.exits) |*exit| {
// Skip any indices that we've already used.
if (exit.* != -1) {
continue;
}
exit.* = e;
return;
}
unreachable;
}
};
pub fn main() !void {
var timer = try std.time.Timer.start();
var caves = std.ArrayList(Cave).init(gpa);
defer { caves.deinit(); }
var cavesToIndices = std.StringHashMap(u8).init(gpa);
defer { cavesToIndices.deinit(); }
{
var lines = std.mem.tokenize(data, "\r\n");
while (lines.next()) |line| {
var entry = std.mem.tokenize(line, "-");
const src = entry.next().?;
const dst = entry.next().?;
// If we haven't encountered the caves before, make new ones!
if (cavesToIndices.get(src) == null) {
const index = caves.items.len;
try caves.append(Cave.init(src));
try cavesToIndices.put(src, @intCast(u8, index));
}
if (cavesToIndices.get(dst) == null) {
const index = caves.items.len;
try caves.append(Cave.init(dst));
try cavesToIndices.put(dst, @intCast(u8, index));
}
const srcIndex = cavesToIndices.get(src).?;
const dstIndex = cavesToIndices.get(dst).?;
// Caves are bi-directional, so we need to add to each.
caves.items[srcIndex].addExit(dstIndex);
caves.items[dstIndex].addExit(srcIndex);
}
}
{
const paths = countPathsPart1(caves);
print("🎁 Unique paths: {}\n", .{paths});
print("Day 12 - part 01 took {:15}ns\n", .{timer.lap()});
timer.reset();
}
{
const paths = countPathsPart2(caves);
print("🎁 Middle score: {}\n", .{paths});
print("Day 12 - part 02 took {:15}ns\n", .{timer.lap()});
print("❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️\n", .{});
}
}
fn countPathsPart1(caves : std.ArrayList(Cave)) usize {
var visited = std.ArrayList(usize).init(gpa);
defer { visited.deinit(); }
for (caves.items) |cave, i| {
// Skip all but the start.
if (cave.ty != Type.Start) {
continue;
}
return countPathsRecursivePart1(i, caves, &visited);
}
unreachable;
}
fn countPathsRecursivePart1(index: usize,
caves : std.ArrayList(Cave),
visited : *std.ArrayList(usize)) usize {
// First check if we've already visited this cave.
for (visited.*.items) |v| {
if (index == v) {
return 0;
}
}
const ty = caves.items[index].ty;
// If we have the end cave, exit!
if (ty == Type.End) {
return 1;
}
// We can visit big caves multiple times, so we do not visit them!
if (ty != Type.Big) {
// Note: we have to use `catch unreachable` here because Zig cannot analyze
// all the potential error states of this not complete recursive function!
visited.*.append(index) catch unreachable;
}
var total : usize = 0;
for (caves.items[index].exits) |exit| {
if (exit == -1) {
break;
}
total += countPathsRecursivePart1(@intCast(usize, exit), caves, visited);
}
if (ty != Type.Big) {
const pop = visited.pop();
}
return total;
}
fn countPathsPart2(caves : std.ArrayList(Cave)) usize {
var firstVisit = std.DynamicBitSet.initEmpty(caves.items.len, gpa)
catch unreachable;
defer { firstVisit.deinit(); }
var secondVisit = std.DynamicBitSet.initEmpty(caves.items.len, gpa)
catch unreachable;
defer { secondVisit.deinit(); }
for (caves.items) |cave, i| {
// Skip all but the start.
if (cave.ty != Type.Start) {
continue;
}
return countPathsRecursivePart2(i, caves, &firstVisit, &secondVisit, 0);
}
unreachable;
}
fn countPathsRecursivePart2(index: usize,
caves : std.ArrayList(Cave),
firstVisit : *std.DynamicBitSet,
secondVisit : *std.DynamicBitSet,
depth : usize) usize {
const ty = caves.items[index].ty;
switch (ty) {
Type.Start => {
// We can only visit the start if we haven't visited anything!
if (depth != 0) {
return 0;
}
},
Type.End => { return 1; },
Type.Big => {},
Type.Small => {
// If we've visited this cave twice, we cannot visit it again!
if (firstVisit.isSet(index)) {
if (secondVisit.count() > 0) {
return 0;
}
secondVisit.set(index);
} else {
firstVisit.set(index);
}
},
}
var total : usize = 0;
for (caves.items[index].exits) |exit| {
if (exit == -1) {
break;
}
total += countPathsRecursivePart2(@intCast(usize, exit),
caves,
firstVisit,
secondVisit,
depth + 1);
}
if (ty == Type.Small) {
if (secondVisit.isSet(index)) {
secondVisit.unset(index);
}
else {
std.debug.assert(firstVisit.isSet(index));
firstVisit.unset(index);
}
}
return total;
} | src/day12.zig |
const Buffer = @import("Buffer.zig");
const Sampler = @import("Sampler.zig");
const TextureView = @import("TextureView.zig");
const BindGroupLayout = @import("BindGroupLayout.zig");
const BindGroup = @This();
/// The type erased pointer to the BindGroup implementation
/// Equal to c.WGPUBindGroup for NativeInstance.
ptr: *anyopaque,
vtable: *const VTable,
pub const VTable = struct {
reference: fn (ptr: *anyopaque) void,
release: fn (ptr: *anyopaque) void,
setLabel: fn (ptr: *anyopaque, label: [:0]const u8) void,
};
pub inline fn reference(group: BindGroup) void {
group.vtable.reference(group.ptr);
}
pub inline fn release(group: BindGroup) void {
group.vtable.release(group.ptr);
}
pub inline fn setLabel(group: BindGroup, label: [:0]const u8) void {
group.vtable.setLabel(group.ptr, label);
}
pub const Entry = struct {
binding: u32,
buffer: ?Buffer = null,
offset: u64 = 0,
size: u64,
sampler: ?Sampler = null,
texture_view: ?TextureView = null,
/// Helper to create a buffer BindGroup.Entry.
pub fn buffer(binding: u32, buf: Buffer, offset: u64, size: u64) Entry {
return .{
.binding = binding,
.buffer = buf,
.offset = offset,
.size = size,
};
}
/// Helper to create a sampler BindGroup.Entry.
pub fn sampler(binding: u32, sam: Sampler) Entry {
return .{
.binding = binding,
.sampler = sam,
.size = 0,
};
}
/// Helper to create a texture view BindGroup.Entry.
pub fn textureView(binding: u32, texview: TextureView) Entry {
return .{
.binding = binding,
.texture_view = texview,
.size = 0,
};
}
};
pub const Descriptor = struct {
label: ?[*:0]const u8 = null,
layout: BindGroupLayout,
entries: []const Entry,
};
test {
_ = VTable;
_ = reference;
_ = release;
_ = setLabel;
_ = Entry;
_ = Descriptor;
} | gpu/src/BindGroup.zig |
const std = @import("std");
const expect = std.testing.expect;
const mem = std.mem;
const maxInt = std.math.maxInt;
test "int to ptr cast" {
const x = @as(usize, 13);
const y = @intToPtr(*u8, x);
const z = @ptrToInt(y);
expect(z == 13);
}
test "integer literal to pointer cast" {
const vga_mem = @intToPtr(*u16, 0xB8000);
expect(@ptrToInt(vga_mem) == 0xB8000);
}
test "pointer reinterpret const float to int" {
const float: f64 = 5.99999999999994648725e-01;
const float_ptr = &float;
const int_ptr = @ptrCast(*const i32, float_ptr);
const int_val = int_ptr.*;
expect(int_val == 858993411);
}
test "implicitly cast indirect pointer to maybe-indirect pointer" {
const S = struct {
const Self = @This();
x: u8,
fn constConst(p: *const *const Self) u8 {
return p.*.x;
}
fn maybeConstConst(p: ?*const *const Self) u8 {
return p.?.*.x;
}
fn constConstConst(p: *const *const *const Self) u8 {
return p.*.*.x;
}
fn maybeConstConstConst(p: ?*const *const *const Self) u8 {
return p.?.*.*.x;
}
};
const s = S{ .x = 42 };
const p = &s;
const q = &p;
const r = &q;
expect(42 == S.constConst(q));
expect(42 == S.maybeConstConst(q));
expect(42 == S.constConstConst(r));
expect(42 == S.maybeConstConstConst(r));
}
test "explicit cast from integer to error type" {
testCastIntToErr(error.ItBroke);
comptime testCastIntToErr(error.ItBroke);
}
fn testCastIntToErr(err: anyerror) void {
const x = @errorToInt(err);
const y = @intToError(x);
expect(error.ItBroke == y);
}
test "peer resolve arrays of different size to const slice" {
expect(mem.eql(u8, boolToStr(true), "true"));
expect(mem.eql(u8, boolToStr(false), "false"));
comptime expect(mem.eql(u8, boolToStr(true), "true"));
comptime expect(mem.eql(u8, boolToStr(false), "false"));
}
fn boolToStr(b: bool) []const u8 {
return if (b) "true" else "false";
}
test "peer resolve array and const slice" {
testPeerResolveArrayConstSlice(true);
comptime testPeerResolveArrayConstSlice(true);
}
fn testPeerResolveArrayConstSlice(b: bool) void {
const value1 = if (b) "aoeu" else @as([]const u8, "zz");
const value2 = if (b) @as([]const u8, "zz") else "aoeu";
expect(mem.eql(u8, value1, "aoeu"));
expect(mem.eql(u8, value2, "zz"));
}
test "implicitly cast from T to anyerror!?T" {
castToOptionalTypeError(1);
comptime castToOptionalTypeError(1);
}
const A = struct {
a: i32,
};
fn castToOptionalTypeError(z: i32) void {
const x = @as(i32, 1);
const y: anyerror!?i32 = x;
expect((try y).? == 1);
const f = z;
const g: anyerror!?i32 = f;
const a = A{ .a = z };
const b: anyerror!?A = a;
expect((b catch unreachable).?.a == 1);
}
test "implicitly cast from int to anyerror!?T" {
implicitIntLitToOptional();
comptime implicitIntLitToOptional();
}
fn implicitIntLitToOptional() void {
const f: ?i32 = 1;
const g: anyerror!?i32 = 1;
}
test "return null from fn() anyerror!?&T" {
const a = returnNullFromOptionalTypeErrorRef();
const b = returnNullLitFromOptionalTypeErrorRef();
expect((try a) == null and (try b) == null);
}
fn returnNullFromOptionalTypeErrorRef() anyerror!?*A {
const a: ?*A = null;
return a;
}
fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
return null;
}
test "peer type resolution: ?T and T" {
expect(peerTypeTAndOptionalT(true, false).? == 0);
expect(peerTypeTAndOptionalT(false, false).? == 3);
comptime {
expect(peerTypeTAndOptionalT(true, false).? == 0);
expect(peerTypeTAndOptionalT(false, false).? == 3);
}
}
fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
if (c) {
return if (b) null else @as(usize, 0);
}
return @as(usize, 3);
}
test "peer type resolution: [0]u8 and []const u8" {
expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
comptime {
expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
}
}
fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
if (a) {
return &[_]u8{};
}
return slice[0..1];
}
test "implicitly cast from [N]T to ?[]const T" {
expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
comptime expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
}
fn castToOptionalSlice() ?[]const u8 {
return "hi";
}
test "implicitly cast from [0]T to anyerror![]T" {
testCastZeroArrayToErrSliceMut();
comptime testCastZeroArrayToErrSliceMut();
}
fn testCastZeroArrayToErrSliceMut() void {
expect((gimmeErrOrSlice() catch unreachable).len == 0);
}
fn gimmeErrOrSlice() anyerror![]u8 {
return &[_]u8{};
}
test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
const S = struct {
fn doTheTest() anyerror!void {
{
var data = "hi".*;
const slice = data[0..];
expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
}
{
var data: [2]u8 = "hi".*;
const slice = data[0..];
expect((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
expect((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
}
}
};
try S.doTheTest();
try comptime S.doTheTest();
}
fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
if (a) {
return &[_]u8{};
}
return slice[0..1];
}
test "resolve undefined with integer" {
testResolveUndefWithInt(true, 1234);
comptime testResolveUndefWithInt(true, 1234);
}
fn testResolveUndefWithInt(b: bool, x: i32) void {
const value = if (b) x else undefined;
if (b) {
expect(value == x);
}
}
test "implicit cast from &const [N]T to []const T" {
testCastConstArrayRefToConstSlice();
comptime testCastConstArrayRefToConstSlice();
}
fn testCastConstArrayRefToConstSlice() void {
{
const blah = "aoeu".*;
const const_array_ref = &blah;
expect(@TypeOf(const_array_ref) == *const [4:0]u8);
const slice: []const u8 = const_array_ref;
expect(mem.eql(u8, slice, "aoeu"));
}
{
const blah: [4]u8 = "aoeu".*;
const const_array_ref = &blah;
expect(@TypeOf(const_array_ref) == *const [4]u8);
const slice: []const u8 = const_array_ref;
expect(mem.eql(u8, slice, "aoeu"));
}
}
test "peer type resolution: error and [N]T" {
// TODO: implicit error!T to error!U where T can implicitly cast to U
//expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
//comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
comptime expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
}
//fn testPeerErrorAndArray(x: u8) error![]const u8 {
// return switch (x) {
// 0x00 => "OK",
// else => error.BadValue,
// };
//}
fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
return switch (x) {
0x00 => "OK",
0x01 => "OKK",
else => error.BadValue,
};
}
test "@floatToInt" {
if (@import("builtin").arch == .riscv64) {
// TODO: https://github.com/ziglang/zig/issues/3338
return error.SkipZigTest;
}
testFloatToInts();
comptime testFloatToInts();
}
fn testFloatToInts() void {
const x = @as(i32, 1e4);
expect(x == 10000);
const y = @floatToInt(i32, @as(f32, 1e4));
expect(y == 10000);
expectFloatToInt(f16, 255.1, u8, 255);
expectFloatToInt(f16, 127.2, i8, 127);
expectFloatToInt(f16, -128.2, i8, -128);
expectFloatToInt(f32, 255.1, u8, 255);
expectFloatToInt(f32, 127.2, i8, 127);
expectFloatToInt(f32, -128.2, i8, -128);
expectFloatToInt(comptime_int, 1234, i16, 1234);
}
fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) void {
expect(@floatToInt(I, f) == i);
}
test "cast u128 to f128 and back" {
comptime testCast128();
testCast128();
}
fn testCast128() void {
expect(cast128Int(cast128Float(0x7fff0000000000000000000000000000)) == 0x7fff0000000000000000000000000000);
}
fn cast128Int(x: f128) u128 {
return @bitCast(u128, x);
}
fn cast128Float(x: u128) f128 {
return @bitCast(f128, x);
}
test "const slice widen cast" {
const bytes align(4) = [_]u8{
0x12,
0x12,
0x12,
0x12,
};
const u32_value = @bytesToSlice(u32, bytes[0..])[0];
expect(u32_value == 0x12121212);
expect(@bitCast(u32, bytes) == 0x12121212);
}
test "single-item pointer of array to slice and to unknown length pointer" {
testCastPtrOfArrayToSliceAndPtr();
comptime testCastPtrOfArrayToSliceAndPtr();
}
fn testCastPtrOfArrayToSliceAndPtr() void {
{
var array = "aoeu".*;
const x: [*]u8 = &array;
x[0] += 1;
expect(mem.eql(u8, array[0..], "boeu"));
const y: []u8 = &array;
y[0] += 1;
expect(mem.eql(u8, array[0..], "coeu"));
}
{
var array: [4]u8 = "aoeu".*;
const x: [*]u8 = &array;
x[0] += 1;
expect(mem.eql(u8, array[0..], "boeu"));
const y: []u8 = &array;
y[0] += 1;
expect(mem.eql(u8, array[0..], "coeu"));
}
}
test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
const window_name = [1][*]const u8{"window name"};
const x: [*]const ?[*]const u8 = &window_name;
expect(mem.eql(u8, std.mem.toSliceConst(u8, @ptrCast([*:0]const u8, x[0].?)), "window name"));
}
test "@intCast comptime_int" {
const result = @intCast(i32, 1234);
expect(@TypeOf(result) == i32);
expect(result == 1234);
}
test "@floatCast comptime_int and comptime_float" {
{
const result = @floatCast(f16, 1234);
expect(@TypeOf(result) == f16);
expect(result == 1234.0);
}
{
const result = @floatCast(f16, 1234.0);
expect(@TypeOf(result) == f16);
expect(result == 1234.0);
}
{
const result = @floatCast(f32, 1234);
expect(@TypeOf(result) == f32);
expect(result == 1234.0);
}
{
const result = @floatCast(f32, 1234.0);
expect(@TypeOf(result) == f32);
expect(result == 1234.0);
}
}
test "comptime_int @intToFloat" {
{
const result = @intToFloat(f16, 1234);
expect(@TypeOf(result) == f16);
expect(result == 1234.0);
}
{
const result = @intToFloat(f32, 1234);
expect(@TypeOf(result) == f32);
expect(result == 1234.0);
}
}
test "@bytesToSlice keeps pointer alignment" {
var bytes = [_]u8{ 0x01, 0x02, 0x03, 0x04 };
const numbers = @bytesToSlice(u32, bytes[0..]);
comptime expect(@TypeOf(numbers) == []align(@alignOf(@TypeOf(bytes))) u32);
}
test "@intCast i32 to u7" {
var x: u128 = maxInt(u128);
var y: i32 = 120;
var z = x >> @intCast(u7, y);
expect(z == 0xff);
}
test "implicit cast undefined to optional" {
expect(MakeType(void).getNull() == null);
expect(MakeType(void).getNonNull() != null);
}
fn MakeType(comptime T: type) type {
return struct {
fn getNull() ?T {
return null;
}
fn getNonNull() ?T {
return @as(T, undefined);
}
};
}
test "implicit cast from *[N]T to ?[*]T" {
var x: ?[*]u16 = null;
var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
x = &y;
expect(std.mem.eql(u16, x.?[0..4], y[0..4]));
x.?[0] = 8;
y[3] = 6;
expect(std.mem.eql(u16, x.?[0..4], y[0..4]));
}
test "implicit cast from *[N]T to [*c]T" {
var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
var y: [*c]u16 = &x;
expect(std.mem.eql(u16, x[0..4], y[0..4]));
x[0] = 8;
y[3] = 6;
expect(std.mem.eql(u16, x[0..4], y[0..4]));
}
test "implicit cast from *T to ?*c_void" {
var a: u8 = 1;
incrementVoidPtrValue(&a);
std.testing.expect(a == 2);
}
fn incrementVoidPtrValue(value: ?*c_void) void {
@ptrCast(*u8, value.?).* += 1;
}
test "implicit cast from [*]T to ?*c_void" {
var a = [_]u8{ 3, 2, 1 };
incrementVoidPtrArray(a[0..].ptr, 3);
expect(std.mem.eql(u8, &a, &[_]u8{ 4, 3, 2 }));
}
fn incrementVoidPtrArray(array: ?*c_void, len: usize) void {
var n: usize = 0;
while (n < len) : (n += 1) {
@ptrCast([*]u8, array.?)[n] += 1;
}
}
test "*usize to *void" {
var i = @as(usize, 0);
var v = @ptrCast(*void, &i);
v.* = {};
}
test "compile time int to ptr of function" {
foobar(FUNCTION_CONSTANT);
}
pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize));
pub const PFN_void = extern fn (*c_void) void;
fn foobar(func: PFN_void) void {
std.testing.expect(@ptrToInt(func) == maxInt(usize));
}
test "implicit ptr to *c_void" {
var a: u32 = 1;
var ptr: *c_void = &a;
var b: *u32 = @ptrCast(*u32, ptr);
expect(b.* == 1);
var ptr2: ?*c_void = &a;
var c: *u32 = @ptrCast(*u32, ptr2.?);
expect(c.* == 1);
}
test "@intCast to comptime_int" {
expect(@intCast(comptime_int, 0) == 0);
}
test "implicit cast comptime numbers to any type when the value fits" {
const a: u64 = 255;
var b: u8 = a;
expect(b == 255);
}
test "@intToEnum passed a comptime_int to an enum with one item" {
const E = enum {
A,
};
const x = @intToEnum(E, 0);
expect(x == E.A);
}
test "@intCast to u0 and use the result" {
const S = struct {
fn doTheTest(zero: u1, one: u1, bigzero: i32) void {
expect((one << @intCast(u0, bigzero)) == 1);
expect((zero << @intCast(u0, bigzero)) == 0);
}
};
S.doTheTest(0, 1, 0);
comptime S.doTheTest(0, 1, 0);
}
test "peer type resolution: unreachable, null, slice" {
const S = struct {
fn doTheTest(num: usize, word: []const u8) void {
const result = switch (num) {
0 => null,
1 => word,
else => unreachable,
};
expect(mem.eql(u8, result.?, "hi"));
}
};
S.doTheTest(1, "hi");
}
test "peer type resolution: unreachable, error set, unreachable" {
const Error = error{
FileDescriptorAlreadyPresentInSet,
OperationCausesCircularLoop,
FileDescriptorNotRegistered,
SystemResources,
UserResourceLimitReached,
FileDescriptorIncompatibleWithEpoll,
Unexpected,
};
var err = Error.SystemResources;
const transformed_err = switch (err) {
error.FileDescriptorAlreadyPresentInSet => unreachable,
error.OperationCausesCircularLoop => unreachable,
error.FileDescriptorNotRegistered => unreachable,
error.SystemResources => error.SystemResources,
error.UserResourceLimitReached => error.UserResourceLimitReached,
error.FileDescriptorIncompatibleWithEpoll => unreachable,
error.Unexpected => unreachable,
};
expect(transformed_err == error.SystemResources);
}
test "implicit cast comptime_int to comptime_float" {
comptime expect(@as(comptime_float, 10) == @as(f32, 10));
expect(2 == 2.0);
}
test "implicit cast *[0]T to E![]const u8" {
var x = @as(anyerror![]const u8, &[0]u8{});
expect((x catch unreachable).len == 0);
}
test "peer cast *[0]T to E![]const T" {
var buffer: [5]u8 = "abcde".*;
var buf: anyerror![]const u8 = buffer[0..];
var b = false;
var y = if (b) &[0]u8{} else buf;
expect(mem.eql(u8, "abcde", y catch unreachable));
}
test "peer cast *[0]T to []const T" {
var buffer: [5]u8 = "abcde".*;
var buf: []const u8 = buffer[0..];
var b = false;
var y = if (b) &[0]u8{} else buf;
expect(mem.eql(u8, "abcde", y));
}
var global_array: [4]u8 = undefined;
test "cast from array reference to fn" {
const f = @ptrCast(extern fn () void, &global_array);
expect(@ptrToInt(f) == @ptrToInt(&global_array));
}
test "*const [N]null u8 to ?[]const u8" {
const S = struct {
fn doTheTest() void {
var a = "Hello";
var b: ?[]const u8 = a;
expect(mem.eql(u8, b.?, "Hello"));
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "peer resolution of string literals" {
const S = struct {
const E = extern enum {
a,
b,
c,
d,
};
fn doTheTest(e: E) void {
const cmd = switch (e) {
.a => "one",
.b => "two",
.c => "three",
.d => "four",
};
expect(mem.eql(u8, cmd, "two"));
}
};
S.doTheTest(.b);
comptime S.doTheTest(.b);
}
test "type coercion related to sentinel-termination" {
const S = struct {
fn doTheTest() void {
// [:x]T to []T
{
var array = [4:0]i32{ 1, 2, 3, 4 };
var slice: [:0]i32 = &array;
var dest: []i32 = slice;
expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
}
// [*:x]T to [*]T
{
var array = [4:99]i32{ 1, 2, 3, 4 };
var dest: [*]i32 = &array;
expect(dest[0] == 1);
expect(dest[1] == 2);
expect(dest[2] == 3);
expect(dest[3] == 4);
expect(dest[4] == 99);
}
// [N:x]T to [N]T
{
var array = [4:0]i32{ 1, 2, 3, 4 };
var dest: [4]i32 = array;
expect(mem.eql(i32, &dest, &[_]i32{ 1, 2, 3, 4 }));
}
// *[N:x]T to *[N]T
{
var array = [4:0]i32{ 1, 2, 3, 4 };
var dest: *[4]i32 = &array;
expect(mem.eql(i32, dest, &[_]i32{ 1, 2, 3, 4 }));
}
// [:x]T to [*:x]T
{
var array = [4:0]i32{ 1, 2, 3, 4 };
var slice: [:0]i32 = &array;
var dest: [*:0]i32 = slice;
expect(dest[0] == 1);
expect(dest[1] == 2);
expect(dest[2] == 3);
expect(dest[3] == 4);
expect(dest[4] == 0);
}
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "cast i8 fn call peers to i32 result" {
const S = struct {
fn doTheTest() void {
var cond = true;
const value: i32 = if (cond) smallBoi() else bigBoi();
expect(value == 123);
}
fn smallBoi() i8 {
return 123;
}
fn bigBoi() i16 {
return 1234;
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "return u8 coercing into ?u32 return type" {
const S = struct {
fn doTheTest() void {
expect(foo(123).? == 123);
}
fn foo(arg: u8) ?u32 {
return arg;
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "peer result null and comptime_int" {
const S = struct {
fn blah(n: i32) ?i32 {
if (n == 0) {
return null;
} else if (n < 0) {
return -1;
} else {
return 1;
}
}
};
expect(S.blah(0) == null);
comptime expect(S.blah(0) == null);
expect(S.blah(10).? == 1);
comptime expect(S.blah(10).? == 1);
expect(S.blah(-10).? == -1);
comptime expect(S.blah(-10).? == -1);
}
test "peer type resolution implicit cast to return type" {
const S = struct {
fn doTheTest() void {
for ("hello") |c| _ = f(c);
}
fn f(c: u8) []const u8 {
return switch (c) {
'h', 'e' => &[_]u8{c}, // should cast to slice
'l', ' ' => &[_]u8{ c, '.' }, // should cast to slice
else => ([_]u8{c})[0..], // is a slice
};
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "peer type resolution implicit cast to variable type" {
const S = struct {
fn doTheTest() void {
var x: []const u8 = undefined;
for ("hello") |c| x = switch (c) {
'h', 'e' => &[_]u8{c}, // should cast to slice
'l', ' ' => &[_]u8{ c, '.' }, // should cast to slice
else => ([_]u8{c})[0..], // is a slice
};
}
};
S.doTheTest();
comptime S.doTheTest();
}
test "variable initialization uses result locations properly with regards to the type" {
var b = true;
const x: i32 = if (b) 1 else 2;
expect(x == 1);
} | test/stage1/behavior/cast.zig |
const std = @import("../std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const Token = std.zig.Token;
pub const TokenIndex = u32;
pub const ByteOffset = u32;
pub const TokenList = std.MultiArrayList(struct {
tag: Token.Tag,
start: ByteOffset,
});
pub const NodeList = std.MultiArrayList(Node);
pub const Tree = struct {
/// Reference to externally-owned data.
source: []const u8,
tokens: TokenList.Slice,
/// The root AST node is assumed to be index 0. Since there can be no
/// references to the root node, this means 0 is available to indicate null.
nodes: NodeList.Slice,
extra_data: []Node.Index,
errors: []const Error,
pub const Location = struct {
line: usize,
column: usize,
line_start: usize,
line_end: usize,
};
pub fn deinit(tree: *Tree, gpa: *mem.Allocator) void {
tree.tokens.deinit(gpa);
tree.nodes.deinit(gpa);
gpa.free(tree.extra_data);
gpa.free(tree.errors);
tree.* = undefined;
}
pub const RenderError = error{
/// Ran out of memory allocating call stack frames to complete rendering, or
/// ran out of memory allocating space in the output buffer.
OutOfMemory,
};
/// `gpa` is used for allocating the resulting formatted source code, as well as
/// for allocating extra stack memory if needed, because this function utilizes recursion.
/// Note: that's not actually true yet, see https://github.com/ziglang/zig/issues/1006.
/// Caller owns the returned slice of bytes, allocated with `gpa`.
pub fn render(tree: Tree, gpa: *mem.Allocator) RenderError![]u8 {
var buffer = std.ArrayList(u8).init(gpa);
defer buffer.deinit();
try tree.renderToArrayList(&buffer);
return buffer.toOwnedSlice();
}
pub fn renderToArrayList(tree: Tree, buffer: *std.ArrayList(u8)) RenderError!void {
return @import("./render.zig").renderTree(buffer, tree);
}
pub fn tokenLocation(self: Tree, start_offset: ByteOffset, token_index: TokenIndex) Location {
var loc = Location{
.line = 0,
.column = 0,
.line_start = start_offset,
.line_end = self.source.len,
};
const token_start = self.tokens.items(.start)[token_index];
for (self.source[start_offset..]) |c, i| {
if (i + start_offset == token_start) {
loc.line_end = i + start_offset;
while (loc.line_end < self.source.len and self.source[loc.line_end] != '\n') {
loc.line_end += 1;
}
return loc;
}
if (c == '\n') {
loc.line += 1;
loc.column = 0;
loc.line_start = i + 1;
} else {
loc.column += 1;
}
}
return loc;
}
pub fn tokenSlice(tree: Tree, token_index: TokenIndex) []const u8 {
const token_starts = tree.tokens.items(.start);
const token_tags = tree.tokens.items(.tag);
const token_tag = token_tags[token_index];
// Many tokens can be determined entirely by their tag.
if (token_tag.lexeme()) |lexeme| {
return lexeme;
}
// For some tokens, re-tokenization is needed to find the end.
var tokenizer: std.zig.Tokenizer = .{
.buffer = tree.source,
.index = token_starts[token_index],
.pending_invalid_token = null,
};
const token = tokenizer.next();
assert(token.tag == token_tag);
return tree.source[token.loc.start..token.loc.end];
}
pub fn extraData(tree: Tree, index: usize, comptime T: type) T {
const fields = std.meta.fields(T);
var result: T = undefined;
inline for (fields) |field, i| {
comptime assert(field.field_type == Node.Index);
@field(result, field.name) = tree.extra_data[index + i];
}
return result;
}
pub fn rootDecls(tree: Tree) []const Node.Index {
// Root is always index 0.
const nodes_data = tree.nodes.items(.data);
return tree.extra_data[nodes_data[0].lhs..nodes_data[0].rhs];
}
pub fn renderError(tree: Tree, parse_error: Error, stream: anytype) !void {
const token_tags = tree.tokens.items(.tag);
switch (parse_error.tag) {
.asterisk_after_ptr_deref => {
return stream.writeAll("'.*' cannot be followed by '*'. Are you missing a space?");
},
.decl_between_fields => {
return stream.writeAll("declarations are not allowed between container fields");
},
.expected_block => {
return stream.print("expected block or field, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_block_or_assignment => {
return stream.print("expected block or assignment, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_block_or_expr => {
return stream.print("expected block or expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_block_or_field => {
return stream.print("expected block or field, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_container_members => {
return stream.print("expected test, comptime, var decl, or container field, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_expr => {
return stream.print("expected expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_expr_or_assignment => {
return stream.print("expected expression or assignment, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_fn => {
return stream.print("expected function, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_inlinable => {
return stream.print("expected 'while' or 'for', found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_labelable => {
return stream.print("expected 'while', 'for', 'inline', 'suspend', or '{{', found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_param_list => {
return stream.print("expected parameter list, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_prefix_expr => {
return stream.print("expected prefix expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_primary_type_expr => {
return stream.print("expected primary type expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_pub_item => {
return stream.writeAll("expected function or variable declaration after pub");
},
.expected_return_type => {
return stream.print("expected return type expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_semi_or_else => {
return stream.print("expected ';' or 'else', found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_semi_or_lbrace => {
return stream.print("expected ';' or '{{', found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_statement => {
return stream.print("expected statement, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_string_literal => {
return stream.print("expected string literal, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_suffix_op => {
return stream.print("expected pointer dereference, optional unwrap, or field access, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_type_expr => {
return stream.print("expected type expression, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_var_decl => {
return stream.print("expected variable declaration, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_var_decl_or_fn => {
return stream.print("expected variable declaration or function, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_loop_payload => {
return stream.print("expected loop payload, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.expected_container => {
return stream.print("expected a struct, enum or union, found '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.extra_align_qualifier => {
return stream.writeAll("extra align qualifier");
},
.extra_allowzero_qualifier => {
return stream.writeAll("extra allowzero qualifier");
},
.extra_const_qualifier => {
return stream.writeAll("extra const qualifier");
},
.extra_volatile_qualifier => {
return stream.writeAll("extra volatile qualifier");
},
.ptr_mod_on_array_child_type => {
return stream.print("pointer modifier '{s}' not allowed on array child type", .{
token_tags[parse_error.token].symbol(),
});
},
.invalid_and => {
return stream.writeAll("`&&` is invalid; note that `and` is boolean AND");
},
.invalid_bit_range => {
return stream.writeAll("bit range not allowed on slices and arrays");
},
.invalid_token => {
return stream.print("invalid token '{s}'", .{
token_tags[parse_error.token].symbol(),
});
},
.same_line_doc_comment => {
return stream.writeAll("same line documentation comment");
},
.unattached_doc_comment => {
return stream.writeAll("unattached documentation comment");
},
.expected_token => {
const found_tag = token_tags[parse_error.token];
const expected_symbol = parse_error.extra.expected_tag.symbol();
switch (found_tag) {
.invalid => return stream.print("expected '{s}', found invalid bytes", .{
expected_symbol,
}),
else => return stream.print("expected '{s}', found '{s}'", .{
expected_symbol, found_tag.symbol(),
}),
}
},
}
}
pub fn firstToken(tree: Tree, node: Node.Index) TokenIndex {
const tags = tree.nodes.items(.tag);
const datas = tree.nodes.items(.data);
const main_tokens = tree.nodes.items(.main_token);
const token_tags = tree.tokens.items(.tag);
var end_offset: TokenIndex = 0;
var n = node;
while (true) switch (tags[n]) {
.root => return 0,
.test_decl,
.@"errdefer",
.@"defer",
.bool_not,
.negation,
.bit_not,
.negation_wrap,
.address_of,
.@"try",
.@"await",
.optional_type,
.@"switch",
.switch_comma,
.if_simple,
.@"if",
.@"suspend",
.@"resume",
.@"continue",
.@"break",
.@"return",
.anyframe_type,
.identifier,
.anyframe_literal,
.char_literal,
.integer_literal,
.float_literal,
.false_literal,
.true_literal,
.null_literal,
.undefined_literal,
.unreachable_literal,
.string_literal,
.multiline_string_literal,
.grouped_expression,
.builtin_call_two,
.builtin_call_two_comma,
.builtin_call,
.builtin_call_comma,
.error_set_decl,
.@"anytype",
.@"comptime",
.@"nosuspend",
.asm_simple,
.@"asm",
.array_type,
.array_type_sentinel,
.error_value,
=> return main_tokens[n] - end_offset,
.array_init_dot,
.array_init_dot_comma,
.array_init_dot_two,
.array_init_dot_two_comma,
.struct_init_dot,
.struct_init_dot_comma,
.struct_init_dot_two,
.struct_init_dot_two_comma,
.enum_literal,
=> return main_tokens[n] - 1 - end_offset,
.@"catch",
.field_access,
.unwrap_optional,
.equal_equal,
.bang_equal,
.less_than,
.greater_than,
.less_or_equal,
.greater_or_equal,
.assign_mul,
.assign_div,
.assign_mod,
.assign_add,
.assign_sub,
.assign_bit_shift_left,
.assign_bit_shift_right,
.assign_bit_and,
.assign_bit_xor,
.assign_bit_or,
.assign_mul_wrap,
.assign_add_wrap,
.assign_sub_wrap,
.assign,
.merge_error_sets,
.mul,
.div,
.mod,
.array_mult,
.mul_wrap,
.add,
.sub,
.array_cat,
.add_wrap,
.sub_wrap,
.bit_shift_left,
.bit_shift_right,
.bit_and,
.bit_xor,
.bit_or,
.@"orelse",
.bool_and,
.bool_or,
.slice_open,
.slice,
.slice_sentinel,
.deref,
.array_access,
.array_init_one,
.array_init_one_comma,
.array_init,
.array_init_comma,
.struct_init_one,
.struct_init_one_comma,
.struct_init,
.struct_init_comma,
.call_one,
.call_one_comma,
.call,
.call_comma,
.switch_range,
.error_union,
=> n = datas[n].lhs,
.fn_decl,
.fn_proto_simple,
.fn_proto_multi,
.fn_proto_one,
.fn_proto,
=> {
var i = main_tokens[n]; // fn token
while (i > 0) {
i -= 1;
switch (token_tags[i]) {
.keyword_extern,
.keyword_export,
.keyword_pub,
.keyword_threadlocal,
.string_literal,
=> continue,
else => return i + 1 - end_offset,
}
}
return i - end_offset;
},
.@"usingnamespace" => {
const main_token = main_tokens[n];
if (main_token > 0 and token_tags[main_token - 1] == .keyword_pub) {
end_offset += 1;
}
return main_token - end_offset;
},
.async_call_one,
.async_call_one_comma,
.async_call,
.async_call_comma,
=> {
end_offset += 1; // async token
n = datas[n].lhs;
},
.container_field_init,
.container_field_align,
.container_field,
=> {
const name_token = main_tokens[n];
if (name_token > 0 and token_tags[name_token - 1] == .keyword_comptime) {
end_offset += 1;
}
return name_token - end_offset;
},
.global_var_decl,
.local_var_decl,
.simple_var_decl,
.aligned_var_decl,
=> {
var i = main_tokens[n]; // mut token
while (i > 0) {
i -= 1;
switch (token_tags[i]) {
.keyword_extern,
.keyword_export,
.keyword_comptime,
.keyword_pub,
.keyword_threadlocal,
.string_literal,
=> continue,
else => return i + 1 - end_offset,
}
}
return i - end_offset;
},
.block,
.block_semicolon,
.block_two,
.block_two_semicolon,
=> {
// Look for a label.
const lbrace = main_tokens[n];
if (token_tags[lbrace - 1] == .colon and
token_tags[lbrace - 2] == .identifier)
{
end_offset += 2;
}
return lbrace - end_offset;
},
.container_decl,
.container_decl_trailing,
.container_decl_two,
.container_decl_two_trailing,
.container_decl_arg,
.container_decl_arg_trailing,
.tagged_union,
.tagged_union_trailing,
.tagged_union_two,
.tagged_union_two_trailing,
.tagged_union_enum_tag,
.tagged_union_enum_tag_trailing,
=> {
const main_token = main_tokens[n];
switch (token_tags[main_token - 1]) {
.keyword_packed, .keyword_extern => end_offset += 1,
else => {},
}
return main_token - end_offset;
},
.ptr_type_aligned,
.ptr_type_sentinel,
.ptr_type,
.ptr_type_bit_range,
=> {
const main_token = main_tokens[n];
return switch (token_tags[main_token]) {
.asterisk,
.asterisk_asterisk,
=> switch (token_tags[main_token - 1]) {
.l_bracket => main_token - 1,
else => main_token,
},
.l_bracket => main_token,
else => unreachable,
} - end_offset;
},
.switch_case_one => {
if (datas[n].lhs == 0) {
return main_tokens[n] - 1 - end_offset; // else token
} else {
n = datas[n].lhs;
}
},
.switch_case => {
const extra = tree.extraData(datas[n].lhs, Node.SubRange);
assert(extra.end - extra.start > 0);
n = tree.extra_data[extra.start];
},
.asm_output, .asm_input => {
assert(token_tags[main_tokens[n] - 1] == .l_bracket);
return main_tokens[n] - 1 - end_offset;
},
.while_simple,
.while_cont,
.@"while",
.for_simple,
.@"for",
=> {
// Look for a label and inline.
const main_token = main_tokens[n];
var result = main_token;
if (token_tags[result - 1] == .keyword_inline) {
result -= 1;
}
if (token_tags[result - 1] == .colon) {
result -= 2;
}
return result - end_offset;
},
};
}
pub fn lastToken(tree: Tree, node: Node.Index) TokenIndex {
const tags = tree.nodes.items(.tag);
const datas = tree.nodes.items(.data);
const main_tokens = tree.nodes.items(.main_token);
const token_starts = tree.tokens.items(.start);
const token_tags = tree.tokens.items(.tag);
var n = node;
var end_offset: TokenIndex = 0;
while (true) switch (tags[n]) {
.root => return @intCast(TokenIndex, tree.tokens.len - 1),
.@"usingnamespace",
.bool_not,
.negation,
.bit_not,
.negation_wrap,
.address_of,
.@"try",
.@"await",
.optional_type,
.@"resume",
.@"nosuspend",
.@"comptime",
=> n = datas[n].lhs,
.test_decl,
.@"errdefer",
.@"defer",
.@"catch",
.equal_equal,
.bang_equal,
.less_than,
.greater_than,
.less_or_equal,
.greater_or_equal,
.assign_mul,
.assign_div,
.assign_mod,
.assign_add,
.assign_sub,
.assign_bit_shift_left,
.assign_bit_shift_right,
.assign_bit_and,
.assign_bit_xor,
.assign_bit_or,
.assign_mul_wrap,
.assign_add_wrap,
.assign_sub_wrap,
.assign,
.merge_error_sets,
.mul,
.div,
.mod,
.array_mult,
.mul_wrap,
.add,
.sub,
.array_cat,
.add_wrap,
.sub_wrap,
.bit_shift_left,
.bit_shift_right,
.bit_and,
.bit_xor,
.bit_or,
.@"orelse",
.bool_and,
.bool_or,
.anyframe_type,
.error_union,
.if_simple,
.while_simple,
.for_simple,
.fn_proto_simple,
.fn_proto_multi,
.ptr_type_aligned,
.ptr_type_sentinel,
.ptr_type,
.ptr_type_bit_range,
.array_type,
.switch_case_one,
.switch_case,
.switch_range,
=> n = datas[n].rhs,
.field_access,
.unwrap_optional,
.grouped_expression,
.multiline_string_literal,
.error_set_decl,
.asm_simple,
.asm_output,
.asm_input,
.error_value,
=> return datas[n].rhs + end_offset,
.@"anytype",
.anyframe_literal,
.char_literal,
.integer_literal,
.float_literal,
.false_literal,
.true_literal,
.null_literal,
.undefined_literal,
.unreachable_literal,
.identifier,
.deref,
.enum_literal,
.string_literal,
=> return main_tokens[n] + end_offset,
.@"return" => if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
return main_tokens[n] + end_offset;
},
.call, .async_call => {
end_offset += 1; // for the rparen
const params = tree.extraData(datas[n].rhs, Node.SubRange);
if (params.end - params.start == 0) {
return main_tokens[n] + end_offset;
}
n = tree.extra_data[params.end - 1]; // last parameter
},
.tagged_union_enum_tag => {
const members = tree.extraData(datas[n].rhs, Node.SubRange);
if (members.end - members.start == 0) {
end_offset += 4; // for the rparen + rparen + lbrace + rbrace
n = datas[n].lhs;
} else {
end_offset += 1; // for the rbrace
n = tree.extra_data[members.end - 1]; // last parameter
}
},
.call_comma,
.async_call_comma,
.tagged_union_enum_tag_trailing,
=> {
end_offset += 2; // for the comma/semicolon + rparen/rbrace
const params = tree.extraData(datas[n].rhs, Node.SubRange);
assert(params.end > params.start);
n = tree.extra_data[params.end - 1]; // last parameter
},
.@"switch" => {
const cases = tree.extraData(datas[n].rhs, Node.SubRange);
if (cases.end - cases.start == 0) {
end_offset += 3; // rparen, lbrace, rbrace
n = datas[n].lhs; // condition expression
} else {
end_offset += 1; // for the rbrace
n = tree.extra_data[cases.end - 1]; // last case
}
},
.container_decl_arg => {
const members = tree.extraData(datas[n].rhs, Node.SubRange);
if (members.end - members.start == 0) {
end_offset += 3; // for the rparen + lbrace + rbrace
n = datas[n].lhs;
} else {
end_offset += 1; // for the rbrace
n = tree.extra_data[members.end - 1]; // last parameter
}
},
.@"asm" => {
const extra = tree.extraData(datas[n].rhs, Node.Asm);
return extra.rparen + end_offset;
},
.array_init,
.struct_init,
=> {
const elements = tree.extraData(datas[n].rhs, Node.SubRange);
assert(elements.end - elements.start > 0);
end_offset += 1; // for the rbrace
n = tree.extra_data[elements.end - 1]; // last element
},
.array_init_comma,
.struct_init_comma,
.container_decl_arg_trailing,
.switch_comma,
=> {
const members = tree.extraData(datas[n].rhs, Node.SubRange);
assert(members.end - members.start > 0);
end_offset += 2; // for the comma + rbrace
n = tree.extra_data[members.end - 1]; // last parameter
},
.array_init_dot,
.struct_init_dot,
.block,
.container_decl,
.tagged_union,
.builtin_call,
=> {
assert(datas[n].rhs - datas[n].lhs > 0);
end_offset += 1; // for the rbrace
n = tree.extra_data[datas[n].rhs - 1]; // last statement
},
.array_init_dot_comma,
.struct_init_dot_comma,
.block_semicolon,
.container_decl_trailing,
.tagged_union_trailing,
.builtin_call_comma,
=> {
assert(datas[n].rhs - datas[n].lhs > 0);
end_offset += 2; // for the comma/semicolon + rbrace/rparen
n = tree.extra_data[datas[n].rhs - 1]; // last member
},
.call_one,
.async_call_one,
.array_access,
=> {
end_offset += 1; // for the rparen/rbracket
if (datas[n].rhs == 0) {
return main_tokens[n] + end_offset;
}
n = datas[n].rhs;
},
.array_init_dot_two,
.block_two,
.builtin_call_two,
.struct_init_dot_two,
.container_decl_two,
.tagged_union_two,
=> {
if (datas[n].rhs != 0) {
end_offset += 1; // for the rparen/rbrace
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
end_offset += 1; // for the rparen/rbrace
n = datas[n].lhs;
} else {
switch (tags[n]) {
.array_init_dot_two,
.block_two,
.struct_init_dot_two,
=> end_offset += 1, // rbrace
.builtin_call_two => end_offset += 2, // lparen/lbrace + rparen/rbrace
.container_decl_two => {
var i: u32 = 2; // lbrace + rbrace
while (token_tags[main_tokens[n] + i] == .container_doc_comment) i += 1;
end_offset += i;
},
.tagged_union_two => {
var i: u32 = 5; // (enum) {}
while (token_tags[main_tokens[n] + i] == .container_doc_comment) i += 1;
end_offset += i;
},
else => unreachable,
}
return main_tokens[n] + end_offset;
}
},
.array_init_dot_two_comma,
.builtin_call_two_comma,
.block_two_semicolon,
.struct_init_dot_two_comma,
.container_decl_two_trailing,
.tagged_union_two_trailing,
=> {
end_offset += 2; // for the comma/semicolon + rbrace/rparen
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
unreachable;
}
},
.simple_var_decl => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
end_offset += 1; // from mut token to name
return main_tokens[n] + end_offset;
}
},
.aligned_var_decl => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
end_offset += 1; // for the rparen
n = datas[n].lhs;
} else {
end_offset += 1; // from mut token to name
return main_tokens[n] + end_offset;
}
},
.global_var_decl => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else {
const extra = tree.extraData(datas[n].lhs, Node.GlobalVarDecl);
if (extra.section_node != 0) {
end_offset += 1; // for the rparen
n = extra.section_node;
} else if (extra.align_node != 0) {
end_offset += 1; // for the rparen
n = extra.align_node;
} else if (extra.type_node != 0) {
n = extra.type_node;
} else {
end_offset += 1; // from mut token to name
return main_tokens[n] + end_offset;
}
}
},
.local_var_decl => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else {
const extra = tree.extraData(datas[n].lhs, Node.LocalVarDecl);
if (extra.align_node != 0) {
end_offset += 1; // for the rparen
n = extra.align_node;
} else if (extra.type_node != 0) {
n = extra.type_node;
} else {
end_offset += 1; // from mut token to name
return main_tokens[n] + end_offset;
}
}
},
.container_field_init => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
return main_tokens[n] + end_offset;
}
},
.container_field_align => {
if (datas[n].rhs != 0) {
end_offset += 1; // for the rparen
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
return main_tokens[n] + end_offset;
}
},
.container_field => {
const extra = tree.extraData(datas[n].rhs, Node.ContainerField);
if (extra.value_expr != 0) {
n = extra.value_expr;
} else if (extra.align_expr != 0) {
end_offset += 1; // for the rparen
n = extra.align_expr;
} else if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
return main_tokens[n] + end_offset;
}
},
.array_init_one,
.struct_init_one,
=> {
end_offset += 1; // rbrace
if (datas[n].rhs == 0) {
return main_tokens[n] + end_offset;
} else {
n = datas[n].rhs;
}
},
.slice_open,
.call_one_comma,
.async_call_one_comma,
.array_init_one_comma,
.struct_init_one_comma,
=> {
end_offset += 2; // ellipsis2 + rbracket, or comma + rparen
n = datas[n].rhs;
assert(n != 0);
},
.slice => {
const extra = tree.extraData(datas[n].rhs, Node.Slice);
assert(extra.end != 0); // should have used slice_open
end_offset += 1; // rbracket
n = extra.end;
},
.slice_sentinel => {
const extra = tree.extraData(datas[n].rhs, Node.SliceSentinel);
assert(extra.sentinel != 0); // should have used slice
end_offset += 1; // rbracket
n = extra.sentinel;
},
.@"continue" => {
if (datas[n].lhs != 0) {
return datas[n].lhs + end_offset;
} else {
return main_tokens[n] + end_offset;
}
},
.@"break" => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else if (datas[n].lhs != 0) {
return datas[n].lhs + end_offset;
} else {
return main_tokens[n] + end_offset;
}
},
.fn_decl => {
if (datas[n].rhs != 0) {
n = datas[n].rhs;
} else {
n = datas[n].lhs;
}
},
.fn_proto_one => {
const extra = tree.extraData(datas[n].lhs, Node.FnProtoOne);
// linksection, callconv, align can appear in any order, so we
// find the last one here.
var max_node: Node.Index = datas[n].rhs;
var max_start = token_starts[main_tokens[max_node]];
var max_offset: TokenIndex = 0;
if (extra.align_expr != 0) {
const start = token_starts[main_tokens[extra.align_expr]];
if (start > max_start) {
max_node = extra.align_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
if (extra.section_expr != 0) {
const start = token_starts[main_tokens[extra.section_expr]];
if (start > max_start) {
max_node = extra.section_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
if (extra.callconv_expr != 0) {
const start = token_starts[main_tokens[extra.callconv_expr]];
if (start > max_start) {
max_node = extra.callconv_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
n = max_node;
end_offset += max_offset;
},
.fn_proto => {
const extra = tree.extraData(datas[n].lhs, Node.FnProto);
// linksection, callconv, align can appear in any order, so we
// find the last one here.
var max_node: Node.Index = datas[n].rhs;
var max_start = token_starts[main_tokens[max_node]];
var max_offset: TokenIndex = 0;
if (extra.align_expr != 0) {
const start = token_starts[main_tokens[extra.align_expr]];
if (start > max_start) {
max_node = extra.align_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
if (extra.section_expr != 0) {
const start = token_starts[main_tokens[extra.section_expr]];
if (start > max_start) {
max_node = extra.section_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
if (extra.callconv_expr != 0) {
const start = token_starts[main_tokens[extra.callconv_expr]];
if (start > max_start) {
max_node = extra.callconv_expr;
max_start = start;
max_offset = 1; // for the rparen
}
}
n = max_node;
end_offset += max_offset;
},
.while_cont => {
const extra = tree.extraData(datas[n].rhs, Node.WhileCont);
assert(extra.then_expr != 0);
n = extra.then_expr;
},
.@"while" => {
const extra = tree.extraData(datas[n].rhs, Node.While);
assert(extra.else_expr != 0);
n = extra.else_expr;
},
.@"if", .@"for" => {
const extra = tree.extraData(datas[n].rhs, Node.If);
assert(extra.else_expr != 0);
n = extra.else_expr;
},
.@"suspend" => {
if (datas[n].lhs != 0) {
n = datas[n].lhs;
} else {
return main_tokens[n] + end_offset;
}
},
.array_type_sentinel => {
const extra = tree.extraData(datas[n].rhs, Node.ArrayTypeSentinel);
n = extra.elem_type;
},
};
}
pub fn tokensOnSameLine(tree: Tree, token1: TokenIndex, token2: TokenIndex) bool {
const token_starts = tree.tokens.items(.start);
const source = tree.source[token_starts[token1]..token_starts[token2]];
return mem.indexOfScalar(u8, source, '\n') == null;
}
pub fn getNodeSource(tree: Tree, node: Node.Index) []const u8 {
const token_starts = tree.tokens.items(.start);
const first_token = tree.firstToken(node);
const last_token = tree.lastToken(node);
const start = token_starts[first_token];
const end = token_starts[last_token] + tree.tokenSlice(last_token).len;
return tree.source[start..end];
}
pub fn globalVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
assert(tree.nodes.items(.tag)[node] == .global_var_decl);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.GlobalVarDecl);
return tree.fullVarDecl(.{
.type_node = extra.type_node,
.align_node = extra.align_node,
.section_node = extra.section_node,
.init_node = data.rhs,
.mut_token = tree.nodes.items(.main_token)[node],
});
}
pub fn localVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
assert(tree.nodes.items(.tag)[node] == .local_var_decl);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.LocalVarDecl);
return tree.fullVarDecl(.{
.type_node = extra.type_node,
.align_node = extra.align_node,
.section_node = 0,
.init_node = data.rhs,
.mut_token = tree.nodes.items(.main_token)[node],
});
}
pub fn simpleVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
assert(tree.nodes.items(.tag)[node] == .simple_var_decl);
const data = tree.nodes.items(.data)[node];
return tree.fullVarDecl(.{
.type_node = data.lhs,
.align_node = 0,
.section_node = 0,
.init_node = data.rhs,
.mut_token = tree.nodes.items(.main_token)[node],
});
}
pub fn alignedVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
assert(tree.nodes.items(.tag)[node] == .aligned_var_decl);
const data = tree.nodes.items(.data)[node];
return tree.fullVarDecl(.{
.type_node = 0,
.align_node = data.lhs,
.section_node = 0,
.init_node = data.rhs,
.mut_token = tree.nodes.items(.main_token)[node],
});
}
pub fn ifSimple(tree: Tree, node: Node.Index) full.If {
assert(tree.nodes.items(.tag)[node] == .if_simple);
const data = tree.nodes.items(.data)[node];
return tree.fullIf(.{
.cond_expr = data.lhs,
.then_expr = data.rhs,
.else_expr = 0,
.if_token = tree.nodes.items(.main_token)[node],
});
}
pub fn ifFull(tree: Tree, node: Node.Index) full.If {
assert(tree.nodes.items(.tag)[node] == .@"if");
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.If);
return tree.fullIf(.{
.cond_expr = data.lhs,
.then_expr = extra.then_expr,
.else_expr = extra.else_expr,
.if_token = tree.nodes.items(.main_token)[node],
});
}
pub fn containerField(tree: Tree, node: Node.Index) full.ContainerField {
assert(tree.nodes.items(.tag)[node] == .container_field);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.ContainerField);
return tree.fullContainerField(.{
.name_token = tree.nodes.items(.main_token)[node],
.type_expr = data.lhs,
.value_expr = extra.value_expr,
.align_expr = extra.align_expr,
});
}
pub fn containerFieldInit(tree: Tree, node: Node.Index) full.ContainerField {
assert(tree.nodes.items(.tag)[node] == .container_field_init);
const data = tree.nodes.items(.data)[node];
return tree.fullContainerField(.{
.name_token = tree.nodes.items(.main_token)[node],
.type_expr = data.lhs,
.value_expr = data.rhs,
.align_expr = 0,
});
}
pub fn containerFieldAlign(tree: Tree, node: Node.Index) full.ContainerField {
assert(tree.nodes.items(.tag)[node] == .container_field_align);
const data = tree.nodes.items(.data)[node];
return tree.fullContainerField(.{
.name_token = tree.nodes.items(.main_token)[node],
.type_expr = data.lhs,
.value_expr = 0,
.align_expr = data.rhs,
});
}
pub fn fnProtoSimple(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.FnProto {
assert(tree.nodes.items(.tag)[node] == .fn_proto_simple);
const data = tree.nodes.items(.data)[node];
buffer[0] = data.lhs;
const params = if (data.lhs == 0) buffer[0..0] else buffer[0..1];
return tree.fullFnProto(.{
.proto_node = node,
.fn_token = tree.nodes.items(.main_token)[node],
.return_type = data.rhs,
.params = params,
.align_expr = 0,
.section_expr = 0,
.callconv_expr = 0,
});
}
pub fn fnProtoMulti(tree: Tree, node: Node.Index) full.FnProto {
assert(tree.nodes.items(.tag)[node] == .fn_proto_multi);
const data = tree.nodes.items(.data)[node];
const params_range = tree.extraData(data.lhs, Node.SubRange);
const params = tree.extra_data[params_range.start..params_range.end];
return tree.fullFnProto(.{
.proto_node = node,
.fn_token = tree.nodes.items(.main_token)[node],
.return_type = data.rhs,
.params = params,
.align_expr = 0,
.section_expr = 0,
.callconv_expr = 0,
});
}
pub fn fnProtoOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.FnProto {
assert(tree.nodes.items(.tag)[node] == .fn_proto_one);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.FnProtoOne);
buffer[0] = extra.param;
const params = if (extra.param == 0) buffer[0..0] else buffer[0..1];
return tree.fullFnProto(.{
.proto_node = node,
.fn_token = tree.nodes.items(.main_token)[node],
.return_type = data.rhs,
.params = params,
.align_expr = extra.align_expr,
.section_expr = extra.section_expr,
.callconv_expr = extra.callconv_expr,
});
}
pub fn fnProto(tree: Tree, node: Node.Index) full.FnProto {
assert(tree.nodes.items(.tag)[node] == .fn_proto);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.FnProto);
const params = tree.extra_data[extra.params_start..extra.params_end];
return tree.fullFnProto(.{
.proto_node = node,
.fn_token = tree.nodes.items(.main_token)[node],
.return_type = data.rhs,
.params = params,
.align_expr = extra.align_expr,
.section_expr = extra.section_expr,
.callconv_expr = extra.callconv_expr,
});
}
pub fn structInitOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.StructInit {
assert(tree.nodes.items(.tag)[node] == .struct_init_one or
tree.nodes.items(.tag)[node] == .struct_init_one_comma);
const data = tree.nodes.items(.data)[node];
buffer[0] = data.rhs;
const fields = if (data.rhs == 0) buffer[0..0] else buffer[0..1];
return tree.fullStructInit(.{
.lbrace = tree.nodes.items(.main_token)[node],
.fields = fields,
.type_expr = data.lhs,
});
}
pub fn structInitDotTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.StructInit {
assert(tree.nodes.items(.tag)[node] == .struct_init_dot_two or
tree.nodes.items(.tag)[node] == .struct_init_dot_two_comma);
const data = tree.nodes.items(.data)[node];
buffer.* = .{ data.lhs, data.rhs };
const fields = if (data.rhs != 0)
buffer[0..2]
else if (data.lhs != 0)
buffer[0..1]
else
buffer[0..0];
return tree.fullStructInit(.{
.lbrace = tree.nodes.items(.main_token)[node],
.fields = fields,
.type_expr = 0,
});
}
pub fn structInitDot(tree: Tree, node: Node.Index) full.StructInit {
assert(tree.nodes.items(.tag)[node] == .struct_init_dot or
tree.nodes.items(.tag)[node] == .struct_init_dot_comma);
const data = tree.nodes.items(.data)[node];
return tree.fullStructInit(.{
.lbrace = tree.nodes.items(.main_token)[node],
.fields = tree.extra_data[data.lhs..data.rhs],
.type_expr = 0,
});
}
pub fn structInit(tree: Tree, node: Node.Index) full.StructInit {
assert(tree.nodes.items(.tag)[node] == .struct_init or
tree.nodes.items(.tag)[node] == .struct_init_comma);
const data = tree.nodes.items(.data)[node];
const fields_range = tree.extraData(data.rhs, Node.SubRange);
return tree.fullStructInit(.{
.lbrace = tree.nodes.items(.main_token)[node],
.fields = tree.extra_data[fields_range.start..fields_range.end],
.type_expr = data.lhs,
});
}
pub fn arrayInitOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.ArrayInit {
assert(tree.nodes.items(.tag)[node] == .array_init_one or
tree.nodes.items(.tag)[node] == .array_init_one_comma);
const data = tree.nodes.items(.data)[node];
buffer[0] = data.rhs;
const elements = if (data.rhs == 0) buffer[0..0] else buffer[0..1];
return .{
.ast = .{
.lbrace = tree.nodes.items(.main_token)[node],
.elements = elements,
.type_expr = data.lhs,
},
};
}
pub fn arrayInitDotTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ArrayInit {
assert(tree.nodes.items(.tag)[node] == .array_init_dot_two or
tree.nodes.items(.tag)[node] == .array_init_dot_two_comma);
const data = tree.nodes.items(.data)[node];
buffer.* = .{ data.lhs, data.rhs };
const elements = if (data.rhs != 0)
buffer[0..2]
else if (data.lhs != 0)
buffer[0..1]
else
buffer[0..0];
return .{
.ast = .{
.lbrace = tree.nodes.items(.main_token)[node],
.elements = elements,
.type_expr = 0,
},
};
}
pub fn arrayInitDot(tree: Tree, node: Node.Index) full.ArrayInit {
assert(tree.nodes.items(.tag)[node] == .array_init_dot or
tree.nodes.items(.tag)[node] == .array_init_dot_comma);
const data = tree.nodes.items(.data)[node];
return .{
.ast = .{
.lbrace = tree.nodes.items(.main_token)[node],
.elements = tree.extra_data[data.lhs..data.rhs],
.type_expr = 0,
},
};
}
pub fn arrayInit(tree: Tree, node: Node.Index) full.ArrayInit {
assert(tree.nodes.items(.tag)[node] == .array_init or
tree.nodes.items(.tag)[node] == .array_init_comma);
const data = tree.nodes.items(.data)[node];
const elem_range = tree.extraData(data.rhs, Node.SubRange);
return .{
.ast = .{
.lbrace = tree.nodes.items(.main_token)[node],
.elements = tree.extra_data[elem_range.start..elem_range.end],
.type_expr = data.lhs,
},
};
}
pub fn arrayType(tree: Tree, node: Node.Index) full.ArrayType {
assert(tree.nodes.items(.tag)[node] == .array_type);
const data = tree.nodes.items(.data)[node];
return .{
.ast = .{
.lbracket = tree.nodes.items(.main_token)[node],
.elem_count = data.lhs,
.sentinel = 0,
.elem_type = data.rhs,
},
};
}
pub fn arrayTypeSentinel(tree: Tree, node: Node.Index) full.ArrayType {
assert(tree.nodes.items(.tag)[node] == .array_type_sentinel);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.ArrayTypeSentinel);
assert(extra.sentinel != 0);
return .{
.ast = .{
.lbracket = tree.nodes.items(.main_token)[node],
.elem_count = data.lhs,
.sentinel = extra.sentinel,
.elem_type = extra.elem_type,
},
};
}
pub fn ptrTypeAligned(tree: Tree, node: Node.Index) full.PtrType {
assert(tree.nodes.items(.tag)[node] == .ptr_type_aligned);
const data = tree.nodes.items(.data)[node];
return tree.fullPtrType(.{
.main_token = tree.nodes.items(.main_token)[node],
.align_node = data.lhs,
.sentinel = 0,
.bit_range_start = 0,
.bit_range_end = 0,
.child_type = data.rhs,
});
}
pub fn ptrTypeSentinel(tree: Tree, node: Node.Index) full.PtrType {
assert(tree.nodes.items(.tag)[node] == .ptr_type_sentinel);
const data = tree.nodes.items(.data)[node];
return tree.fullPtrType(.{
.main_token = tree.nodes.items(.main_token)[node],
.align_node = 0,
.sentinel = data.lhs,
.bit_range_start = 0,
.bit_range_end = 0,
.child_type = data.rhs,
});
}
pub fn ptrType(tree: Tree, node: Node.Index) full.PtrType {
assert(tree.nodes.items(.tag)[node] == .ptr_type);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.PtrType);
return tree.fullPtrType(.{
.main_token = tree.nodes.items(.main_token)[node],
.align_node = extra.align_node,
.sentinel = extra.sentinel,
.bit_range_start = 0,
.bit_range_end = 0,
.child_type = data.rhs,
});
}
pub fn ptrTypeBitRange(tree: Tree, node: Node.Index) full.PtrType {
assert(tree.nodes.items(.tag)[node] == .ptr_type_bit_range);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.PtrTypeBitRange);
return tree.fullPtrType(.{
.main_token = tree.nodes.items(.main_token)[node],
.align_node = extra.align_node,
.sentinel = extra.sentinel,
.bit_range_start = extra.bit_range_start,
.bit_range_end = extra.bit_range_end,
.child_type = data.rhs,
});
}
pub fn sliceOpen(tree: Tree, node: Node.Index) full.Slice {
assert(tree.nodes.items(.tag)[node] == .slice_open);
const data = tree.nodes.items(.data)[node];
return .{
.ast = .{
.sliced = data.lhs,
.lbracket = tree.nodes.items(.main_token)[node],
.start = data.rhs,
.end = 0,
.sentinel = 0,
},
};
}
pub fn slice(tree: Tree, node: Node.Index) full.Slice {
assert(tree.nodes.items(.tag)[node] == .slice);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.Slice);
return .{
.ast = .{
.sliced = data.lhs,
.lbracket = tree.nodes.items(.main_token)[node],
.start = extra.start,
.end = extra.end,
.sentinel = 0,
},
};
}
pub fn sliceSentinel(tree: Tree, node: Node.Index) full.Slice {
assert(tree.nodes.items(.tag)[node] == .slice_sentinel);
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.SliceSentinel);
return .{
.ast = .{
.sliced = data.lhs,
.lbracket = tree.nodes.items(.main_token)[node],
.start = extra.start,
.end = extra.end,
.sentinel = extra.sentinel,
},
};
}
pub fn containerDeclTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .container_decl_two or
tree.nodes.items(.tag)[node] == .container_decl_two_trailing);
const data = tree.nodes.items(.data)[node];
buffer.* = .{ data.lhs, data.rhs };
const members = if (data.rhs != 0)
buffer[0..2]
else if (data.lhs != 0)
buffer[0..1]
else
buffer[0..0];
return tree.fullContainerDecl(.{
.main_token = tree.nodes.items(.main_token)[node],
.enum_token = null,
.members = members,
.arg = 0,
});
}
pub fn containerDecl(tree: Tree, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .container_decl or
tree.nodes.items(.tag)[node] == .container_decl_trailing);
const data = tree.nodes.items(.data)[node];
return tree.fullContainerDecl(.{
.main_token = tree.nodes.items(.main_token)[node],
.enum_token = null,
.members = tree.extra_data[data.lhs..data.rhs],
.arg = 0,
});
}
pub fn containerDeclArg(tree: Tree, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .container_decl_arg or
tree.nodes.items(.tag)[node] == .container_decl_arg_trailing);
const data = tree.nodes.items(.data)[node];
const members_range = tree.extraData(data.rhs, Node.SubRange);
return tree.fullContainerDecl(.{
.main_token = tree.nodes.items(.main_token)[node],
.enum_token = null,
.members = tree.extra_data[members_range.start..members_range.end],
.arg = data.lhs,
});
}
pub fn taggedUnionTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .tagged_union_two or
tree.nodes.items(.tag)[node] == .tagged_union_two_trailing);
const data = tree.nodes.items(.data)[node];
buffer.* = .{ data.lhs, data.rhs };
const members = if (data.rhs != 0)
buffer[0..2]
else if (data.lhs != 0)
buffer[0..1]
else
buffer[0..0];
const main_token = tree.nodes.items(.main_token)[node];
return tree.fullContainerDecl(.{
.main_token = main_token,
.enum_token = main_token + 2, // union lparen enum
.members = members,
.arg = 0,
});
}
pub fn taggedUnion(tree: Tree, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .tagged_union or
tree.nodes.items(.tag)[node] == .tagged_union_trailing);
const data = tree.nodes.items(.data)[node];
const main_token = tree.nodes.items(.main_token)[node];
return tree.fullContainerDecl(.{
.main_token = main_token,
.enum_token = main_token + 2, // union lparen enum
.members = tree.extra_data[data.lhs..data.rhs],
.arg = 0,
});
}
pub fn taggedUnionEnumTag(tree: Tree, node: Node.Index) full.ContainerDecl {
assert(tree.nodes.items(.tag)[node] == .tagged_union_enum_tag or
tree.nodes.items(.tag)[node] == .tagged_union_enum_tag_trailing);
const data = tree.nodes.items(.data)[node];
const members_range = tree.extraData(data.rhs, Node.SubRange);
const main_token = tree.nodes.items(.main_token)[node];
return tree.fullContainerDecl(.{
.main_token = main_token,
.enum_token = main_token + 2, // union lparen enum
.members = tree.extra_data[members_range.start..members_range.end],
.arg = data.lhs,
});
}
pub fn switchCaseOne(tree: Tree, node: Node.Index) full.SwitchCase {
const data = &tree.nodes.items(.data)[node];
const values: *[1]Node.Index = &data.lhs;
return tree.fullSwitchCase(.{
.values = if (data.lhs == 0) values[0..0] else values[0..1],
.arrow_token = tree.nodes.items(.main_token)[node],
.target_expr = data.rhs,
});
}
pub fn switchCase(tree: Tree, node: Node.Index) full.SwitchCase {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.lhs, Node.SubRange);
return tree.fullSwitchCase(.{
.values = tree.extra_data[extra.start..extra.end],
.arrow_token = tree.nodes.items(.main_token)[node],
.target_expr = data.rhs,
});
}
pub fn asmSimple(tree: Tree, node: Node.Index) full.Asm {
const data = tree.nodes.items(.data)[node];
return tree.fullAsm(.{
.asm_token = tree.nodes.items(.main_token)[node],
.template = data.lhs,
.items = &.{},
.rparen = data.rhs,
});
}
pub fn asmFull(tree: Tree, node: Node.Index) full.Asm {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.Asm);
return tree.fullAsm(.{
.asm_token = tree.nodes.items(.main_token)[node],
.template = data.lhs,
.items = tree.extra_data[extra.items_start..extra.items_end],
.rparen = extra.rparen,
});
}
pub fn whileSimple(tree: Tree, node: Node.Index) full.While {
const data = tree.nodes.items(.data)[node];
return tree.fullWhile(.{
.while_token = tree.nodes.items(.main_token)[node],
.cond_expr = data.lhs,
.cont_expr = 0,
.then_expr = data.rhs,
.else_expr = 0,
});
}
pub fn whileCont(tree: Tree, node: Node.Index) full.While {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.WhileCont);
return tree.fullWhile(.{
.while_token = tree.nodes.items(.main_token)[node],
.cond_expr = data.lhs,
.cont_expr = extra.cont_expr,
.then_expr = extra.then_expr,
.else_expr = 0,
});
}
pub fn whileFull(tree: Tree, node: Node.Index) full.While {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.While);
return tree.fullWhile(.{
.while_token = tree.nodes.items(.main_token)[node],
.cond_expr = data.lhs,
.cont_expr = extra.cont_expr,
.then_expr = extra.then_expr,
.else_expr = extra.else_expr,
});
}
pub fn forSimple(tree: Tree, node: Node.Index) full.While {
const data = tree.nodes.items(.data)[node];
return tree.fullWhile(.{
.while_token = tree.nodes.items(.main_token)[node],
.cond_expr = data.lhs,
.cont_expr = 0,
.then_expr = data.rhs,
.else_expr = 0,
});
}
pub fn forFull(tree: Tree, node: Node.Index) full.While {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.If);
return tree.fullWhile(.{
.while_token = tree.nodes.items(.main_token)[node],
.cond_expr = data.lhs,
.cont_expr = 0,
.then_expr = extra.then_expr,
.else_expr = extra.else_expr,
});
}
pub fn callOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.Call {
const data = tree.nodes.items(.data)[node];
buffer.* = .{data.rhs};
const params = if (data.rhs != 0) buffer[0..1] else buffer[0..0];
return tree.fullCall(.{
.lparen = tree.nodes.items(.main_token)[node],
.fn_expr = data.lhs,
.params = params,
});
}
pub fn callFull(tree: Tree, node: Node.Index) full.Call {
const data = tree.nodes.items(.data)[node];
const extra = tree.extraData(data.rhs, Node.SubRange);
return tree.fullCall(.{
.lparen = tree.nodes.items(.main_token)[node],
.fn_expr = data.lhs,
.params = tree.extra_data[extra.start..extra.end],
});
}
fn fullVarDecl(tree: Tree, info: full.VarDecl.Ast) full.VarDecl {
const token_tags = tree.tokens.items(.tag);
var result: full.VarDecl = .{
.ast = info,
.visib_token = null,
.extern_export_token = null,
.lib_name = null,
.threadlocal_token = null,
.comptime_token = null,
};
var i = info.mut_token;
while (i > 0) {
i -= 1;
switch (token_tags[i]) {
.keyword_extern, .keyword_export => result.extern_export_token = i,
.keyword_comptime => result.comptime_token = i,
.keyword_pub => result.visib_token = i,
.keyword_threadlocal => result.threadlocal_token = i,
.string_literal => result.lib_name = i,
else => break,
}
}
return result;
}
fn fullIf(tree: Tree, info: full.If.Ast) full.If {
const token_tags = tree.tokens.items(.tag);
var result: full.If = .{
.ast = info,
.payload_token = null,
.error_token = null,
.else_token = undefined,
};
// if (cond_expr) |x|
// ^ ^
const payload_pipe = tree.lastToken(info.cond_expr) + 2;
if (token_tags[payload_pipe] == .pipe) {
result.payload_token = payload_pipe + 1;
}
if (info.else_expr != 0) {
// then_expr else |x|
// ^ ^
result.else_token = tree.lastToken(info.then_expr) + 1;
if (token_tags[result.else_token + 1] == .pipe) {
result.error_token = result.else_token + 2;
}
}
return result;
}
fn fullContainerField(tree: Tree, info: full.ContainerField.Ast) full.ContainerField {
const token_tags = tree.tokens.items(.tag);
var result: full.ContainerField = .{
.ast = info,
.comptime_token = null,
};
// comptime name: type = init,
// ^
if (info.name_token > 0 and token_tags[info.name_token - 1] == .keyword_comptime) {
result.comptime_token = info.name_token - 1;
}
return result;
}
fn fullFnProto(tree: Tree, info: full.FnProto.Ast) full.FnProto {
const token_tags = tree.tokens.items(.tag);
var result: full.FnProto = .{
.ast = info,
.visib_token = null,
.extern_export_token = null,
.lib_name = null,
.name_token = null,
.lparen = undefined,
};
var i = info.fn_token;
while (i > 0) {
i -= 1;
switch (token_tags[i]) {
.keyword_extern, .keyword_export => result.extern_export_token = i,
.keyword_pub => result.visib_token = i,
.string_literal => result.lib_name = i,
else => break,
}
}
const after_fn_token = info.fn_token + 1;
if (token_tags[after_fn_token] == .identifier) {
result.name_token = after_fn_token;
result.lparen = after_fn_token + 1;
} else {
result.lparen = after_fn_token;
}
assert(token_tags[result.lparen] == .l_paren);
return result;
}
fn fullStructInit(tree: Tree, info: full.StructInit.Ast) full.StructInit {
const token_tags = tree.tokens.items(.tag);
var result: full.StructInit = .{
.ast = info,
};
return result;
}
fn fullPtrType(tree: Tree, info: full.PtrType.Ast) full.PtrType {
const token_tags = tree.tokens.items(.tag);
// TODO: looks like stage1 isn't quite smart enough to handle enum
// literals in some places here
const Size = std.builtin.TypeInfo.Pointer.Size;
const size: Size = switch (token_tags[info.main_token]) {
.asterisk,
.asterisk_asterisk,
=> switch (token_tags[info.main_token + 1]) {
.r_bracket, .colon => .Many,
.identifier => if (token_tags[info.main_token - 1] == .l_bracket) Size.C else .One,
else => .One,
},
.l_bracket => Size.Slice,
else => unreachable,
};
var result: full.PtrType = .{
.size = size,
.allowzero_token = null,
.const_token = null,
.volatile_token = null,
.ast = info,
};
// We need to be careful that we don't iterate over any sub-expressions
// here while looking for modifiers as that could result in false
// positives. Therefore, start after a sentinel if there is one and
// skip over any align node and bit range nodes.
var i = if (info.sentinel != 0) tree.lastToken(info.sentinel) + 1 else info.main_token;
const end = tree.firstToken(info.child_type);
while (i < end) : (i += 1) {
switch (token_tags[i]) {
.keyword_allowzero => result.allowzero_token = i,
.keyword_const => result.const_token = i,
.keyword_volatile => result.volatile_token = i,
.keyword_align => {
assert(info.align_node != 0);
if (info.bit_range_end != 0) {
assert(info.bit_range_start != 0);
i = tree.lastToken(info.bit_range_end) + 1;
} else {
i = tree.lastToken(info.align_node) + 1;
}
},
else => {},
}
}
return result;
}
fn fullContainerDecl(tree: Tree, info: full.ContainerDecl.Ast) full.ContainerDecl {
const token_tags = tree.tokens.items(.tag);
var result: full.ContainerDecl = .{
.ast = info,
.layout_token = null,
};
switch (token_tags[info.main_token - 1]) {
.keyword_extern, .keyword_packed => result.layout_token = info.main_token - 1,
else => {},
}
return result;
}
fn fullSwitchCase(tree: Tree, info: full.SwitchCase.Ast) full.SwitchCase {
const token_tags = tree.tokens.items(.tag);
var result: full.SwitchCase = .{
.ast = info,
.payload_token = null,
};
if (token_tags[info.arrow_token + 1] == .pipe) {
result.payload_token = info.arrow_token + 2;
}
return result;
}
fn fullAsm(tree: Tree, info: full.Asm.Ast) full.Asm {
const token_tags = tree.tokens.items(.tag);
const node_tags = tree.nodes.items(.tag);
var result: full.Asm = .{
.ast = info,
.volatile_token = null,
.inputs = &.{},
.outputs = &.{},
.first_clobber = null,
};
if (token_tags[info.asm_token + 1] == .keyword_volatile) {
result.volatile_token = info.asm_token + 1;
}
const outputs_end: usize = for (info.items) |item, i| {
switch (node_tags[item]) {
.asm_output => continue,
else => break i,
}
} else info.items.len;
result.outputs = info.items[0..outputs_end];
result.inputs = info.items[outputs_end..];
if (info.items.len == 0) {
// asm ("foo" ::: "a", "b");
const template_token = tree.lastToken(info.template);
if (token_tags[template_token + 1] == .colon and
token_tags[template_token + 2] == .colon and
token_tags[template_token + 3] == .colon and
token_tags[template_token + 4] == .string_literal)
{
result.first_clobber = template_token + 4;
}
} else if (result.inputs.len != 0) {
// asm ("foo" :: [_] "" (y) : "a", "b");
const last_input = result.inputs[result.inputs.len - 1];
const rparen = tree.lastToken(last_input);
var i = rparen + 1;
// Allow a (useless) comma right after the closing parenthesis.
if (token_tags[i] == .comma) i += 1;
if (token_tags[i] == .colon and
token_tags[i + 1] == .string_literal)
{
result.first_clobber = i + 1;
}
} else {
// asm ("foo" : [_] "" (x) :: "a", "b");
const last_output = result.outputs[result.outputs.len - 1];
const rparen = tree.lastToken(last_output);
var i = rparen + 1;
// Allow a (useless) comma right after the closing parenthesis.
if (token_tags[i] == .comma) i += 1;
if (token_tags[i] == .colon and
token_tags[i + 1] == .colon and
token_tags[i + 2] == .string_literal)
{
result.first_clobber = i + 2;
}
}
return result;
}
fn fullWhile(tree: Tree, info: full.While.Ast) full.While {
const token_tags = tree.tokens.items(.tag);
var result: full.While = .{
.ast = info,
.inline_token = null,
.label_token = null,
.payload_token = null,
.else_token = undefined,
.error_token = null,
};
var tok_i = info.while_token - 1;
if (token_tags[tok_i] == .keyword_inline) {
result.inline_token = tok_i;
tok_i -= 1;
}
if (token_tags[tok_i] == .colon and
token_tags[tok_i - 1] == .identifier)
{
result.label_token = tok_i - 1;
}
const last_cond_token = tree.lastToken(info.cond_expr);
if (token_tags[last_cond_token + 2] == .pipe) {
result.payload_token = last_cond_token + 3;
}
if (info.else_expr != 0) {
// then_expr else |x|
// ^ ^
result.else_token = tree.lastToken(info.then_expr) + 1;
if (token_tags[result.else_token + 1] == .pipe) {
result.error_token = result.else_token + 2;
}
}
return result;
}
fn fullCall(tree: Tree, info: full.Call.Ast) full.Call {
const token_tags = tree.tokens.items(.tag);
var result: full.Call = .{
.ast = info,
.async_token = null,
};
const maybe_async_token = tree.firstToken(info.fn_expr) - 1;
if (token_tags[maybe_async_token] == .keyword_async) {
result.async_token = maybe_async_token;
}
return result;
}
};
/// Fully assembled AST node information.
pub const full = struct {
pub const VarDecl = struct {
visib_token: ?TokenIndex,
extern_export_token: ?TokenIndex,
lib_name: ?TokenIndex,
threadlocal_token: ?TokenIndex,
comptime_token: ?TokenIndex,
ast: Ast,
pub const Ast = struct {
mut_token: TokenIndex,
type_node: Node.Index,
align_node: Node.Index,
section_node: Node.Index,
init_node: Node.Index,
};
};
pub const If = struct {
/// Points to the first token after the `|`. Will either be an identifier or
/// a `*` (with an identifier immediately after it).
payload_token: ?TokenIndex,
/// Points to the identifier after the `|`.
error_token: ?TokenIndex,
/// Populated only if else_expr != 0.
else_token: TokenIndex,
ast: Ast,
pub const Ast = struct {
if_token: TokenIndex,
cond_expr: Node.Index,
then_expr: Node.Index,
else_expr: Node.Index,
};
};
pub const While = struct {
ast: Ast,
inline_token: ?TokenIndex,
label_token: ?TokenIndex,
payload_token: ?TokenIndex,
error_token: ?TokenIndex,
/// Populated only if else_expr != 0.
else_token: TokenIndex,
pub const Ast = struct {
while_token: TokenIndex,
cond_expr: Node.Index,
cont_expr: Node.Index,
then_expr: Node.Index,
else_expr: Node.Index,
};
};
pub const ContainerField = struct {
comptime_token: ?TokenIndex,
ast: Ast,
pub const Ast = struct {
name_token: TokenIndex,
type_expr: Node.Index,
value_expr: Node.Index,
align_expr: Node.Index,
};
};
pub const FnProto = struct {
visib_token: ?TokenIndex,
extern_export_token: ?TokenIndex,
lib_name: ?TokenIndex,
name_token: ?TokenIndex,
lparen: TokenIndex,
ast: Ast,
pub const Ast = struct {
proto_node: Node.Index,
fn_token: TokenIndex,
return_type: Node.Index,
params: []const Node.Index,
align_expr: Node.Index,
section_expr: Node.Index,
callconv_expr: Node.Index,
};
pub const Param = struct {
first_doc_comment: ?TokenIndex,
name_token: ?TokenIndex,
comptime_noalias: ?TokenIndex,
anytype_ellipsis3: ?TokenIndex,
type_expr: Node.Index,
};
/// Abstracts over the fact that anytype and ... are not included
/// in the params slice, since they are simple identifiers and
/// not sub-expressions.
pub const Iterator = struct {
tree: *const Tree,
fn_proto: *const FnProto,
param_i: usize,
tok_i: TokenIndex,
tok_flag: bool,
pub fn next(it: *Iterator) ?Param {
const token_tags = it.tree.tokens.items(.tag);
while (true) {
var first_doc_comment: ?TokenIndex = null;
var comptime_noalias: ?TokenIndex = null;
var name_token: ?TokenIndex = null;
if (!it.tok_flag) {
if (it.param_i >= it.fn_proto.ast.params.len) {
return null;
}
const param_type = it.fn_proto.ast.params[it.param_i];
var tok_i = it.tree.firstToken(param_type) - 1;
while (true) : (tok_i -= 1) switch (token_tags[tok_i]) {
.colon => continue,
.identifier => name_token = tok_i,
.doc_comment => first_doc_comment = tok_i,
.keyword_comptime, .keyword_noalias => comptime_noalias = tok_i,
else => break,
};
it.param_i += 1;
it.tok_i = it.tree.lastToken(param_type) + 1;
// Look for anytype and ... params afterwards.
if (token_tags[it.tok_i] == .comma) {
it.tok_i += 1;
}
it.tok_flag = true;
return Param{
.first_doc_comment = first_doc_comment,
.comptime_noalias = comptime_noalias,
.name_token = name_token,
.anytype_ellipsis3 = null,
.type_expr = param_type,
};
}
if (token_tags[it.tok_i] == .r_paren) {
return null;
}
if (token_tags[it.tok_i] == .doc_comment) {
first_doc_comment = it.tok_i;
while (token_tags[it.tok_i] == .doc_comment) {
it.tok_i += 1;
}
}
switch (token_tags[it.tok_i]) {
.ellipsis3 => {
it.tok_flag = false; // Next iteration should return null.
return Param{
.first_doc_comment = first_doc_comment,
.comptime_noalias = null,
.name_token = null,
.anytype_ellipsis3 = it.tok_i,
.type_expr = 0,
};
},
.keyword_noalias, .keyword_comptime => {
comptime_noalias = it.tok_i;
it.tok_i += 1;
},
else => {},
}
if (token_tags[it.tok_i] == .identifier and
token_tags[it.tok_i + 1] == .colon)
{
name_token = it.tok_i;
it.tok_i += 2;
}
if (token_tags[it.tok_i] == .keyword_anytype) {
it.tok_i += 1;
return Param{
.first_doc_comment = first_doc_comment,
.comptime_noalias = comptime_noalias,
.name_token = name_token,
.anytype_ellipsis3 = it.tok_i - 1,
.type_expr = 0,
};
}
it.tok_flag = false;
}
}
};
pub fn iterate(fn_proto: FnProto, tree: Tree) Iterator {
return .{
.tree = &tree,
.fn_proto = &fn_proto,
.param_i = 0,
.tok_i = fn_proto.lparen + 1,
.tok_flag = true,
};
}
};
pub const StructInit = struct {
ast: Ast,
pub const Ast = struct {
lbrace: TokenIndex,
fields: []const Node.Index,
type_expr: Node.Index,
};
};
pub const ArrayInit = struct {
ast: Ast,
pub const Ast = struct {
lbrace: TokenIndex,
elements: []const Node.Index,
type_expr: Node.Index,
};
};
pub const ArrayType = struct {
ast: Ast,
pub const Ast = struct {
lbracket: TokenIndex,
elem_count: Node.Index,
sentinel: Node.Index,
elem_type: Node.Index,
};
};
pub const PtrType = struct {
size: std.builtin.TypeInfo.Pointer.Size,
allowzero_token: ?TokenIndex,
const_token: ?TokenIndex,
volatile_token: ?TokenIndex,
ast: Ast,
pub const Ast = struct {
main_token: TokenIndex,
align_node: Node.Index,
sentinel: Node.Index,
bit_range_start: Node.Index,
bit_range_end: Node.Index,
child_type: Node.Index,
};
};
pub const Slice = struct {
ast: Ast,
pub const Ast = struct {
sliced: Node.Index,
lbracket: TokenIndex,
start: Node.Index,
end: Node.Index,
sentinel: Node.Index,
};
};
pub const ContainerDecl = struct {
layout_token: ?TokenIndex,
ast: Ast,
pub const Ast = struct {
main_token: TokenIndex,
/// Populated when main_token is Keyword_union.
enum_token: ?TokenIndex,
members: []const Node.Index,
arg: Node.Index,
};
};
pub const SwitchCase = struct {
/// Points to the first token after the `|`. Will either be an identifier or
/// a `*` (with an identifier immediately after it).
payload_token: ?TokenIndex,
ast: Ast,
pub const Ast = struct {
/// If empty, this is an else case
values: []const Node.Index,
arrow_token: TokenIndex,
target_expr: Node.Index,
};
};
pub const Asm = struct {
ast: Ast,
volatile_token: ?TokenIndex,
first_clobber: ?TokenIndex,
outputs: []const Node.Index,
inputs: []const Node.Index,
pub const Ast = struct {
asm_token: TokenIndex,
template: Node.Index,
items: []const Node.Index,
rparen: TokenIndex,
};
};
pub const Call = struct {
ast: Ast,
async_token: ?TokenIndex,
pub const Ast = struct {
lparen: TokenIndex,
fn_expr: Node.Index,
params: []const Node.Index,
};
};
};
pub const Error = struct {
tag: Tag,
token: TokenIndex,
extra: union {
none: void,
expected_tag: Token.Tag,
} = .{ .none = {} },
pub const Tag = enum {
asterisk_after_ptr_deref,
decl_between_fields,
expected_block,
expected_block_or_assignment,
expected_block_or_expr,
expected_block_or_field,
expected_container_members,
expected_expr,
expected_expr_or_assignment,
expected_fn,
expected_inlinable,
expected_labelable,
expected_param_list,
expected_prefix_expr,
expected_primary_type_expr,
expected_pub_item,
expected_return_type,
expected_semi_or_else,
expected_semi_or_lbrace,
expected_statement,
expected_string_literal,
expected_suffix_op,
expected_type_expr,
expected_var_decl,
expected_var_decl_or_fn,
expected_loop_payload,
expected_container,
extra_align_qualifier,
extra_allowzero_qualifier,
extra_const_qualifier,
extra_volatile_qualifier,
ptr_mod_on_array_child_type,
invalid_and,
invalid_bit_range,
invalid_token,
same_line_doc_comment,
unattached_doc_comment,
/// `expected_tag` is populated.
expected_token,
};
};
pub const Node = struct {
tag: Tag,
main_token: TokenIndex,
data: Data,
pub const Index = u32;
comptime {
// Goal is to keep this under one byte for efficiency.
assert(@sizeOf(Tag) == 1);
}
/// Note: The FooComma/FooSemicolon variants exist to ease the implementation of
/// Tree.lastToken()
pub const Tag = enum {
/// sub_list[lhs...rhs]
root,
/// `usingnamespace lhs;`. rhs unused. main_token is `usingnamespace`.
@"usingnamespace",
/// lhs is test name token (must be string literal), if any.
/// rhs is the body node.
test_decl,
/// lhs is the index into extra_data.
/// rhs is the initialization expression, if any.
/// main_token is `var` or `const`.
global_var_decl,
/// `var a: x align(y) = rhs`
/// lhs is the index into extra_data.
/// main_token is `var` or `const`.
local_var_decl,
/// `var a: lhs = rhs`. lhs and rhs may be unused.
/// Can be local or global.
/// main_token is `var` or `const`.
simple_var_decl,
/// `var a align(lhs) = rhs`. lhs and rhs may be unused.
/// Can be local or global.
/// main_token is `var` or `const`.
aligned_var_decl,
/// lhs is the identifier token payload if any,
/// rhs is the deferred expression.
@"errdefer",
/// lhs is unused.
/// rhs is the deferred expression.
@"defer",
/// lhs catch rhs
/// lhs catch |err| rhs
/// main_token is the `catch` keyword.
/// payload is determined by looking at the next token after the `catch` keyword.
@"catch",
/// `lhs.a`. main_token is the dot. rhs is the identifier token index.
field_access,
/// `lhs.?`. main_token is the dot. rhs is the `?` token index.
unwrap_optional,
/// `lhs == rhs`. main_token is op.
equal_equal,
/// `lhs != rhs`. main_token is op.
bang_equal,
/// `lhs < rhs`. main_token is op.
less_than,
/// `lhs > rhs`. main_token is op.
greater_than,
/// `lhs <= rhs`. main_token is op.
less_or_equal,
/// `lhs >= rhs`. main_token is op.
greater_or_equal,
/// `lhs *= rhs`. main_token is op.
assign_mul,
/// `lhs /= rhs`. main_token is op.
assign_div,
/// `lhs *= rhs`. main_token is op.
assign_mod,
/// `lhs += rhs`. main_token is op.
assign_add,
/// `lhs -= rhs`. main_token is op.
assign_sub,
/// `lhs <<= rhs`. main_token is op.
assign_bit_shift_left,
/// `lhs >>= rhs`. main_token is op.
assign_bit_shift_right,
/// `lhs &= rhs`. main_token is op.
assign_bit_and,
/// `lhs ^= rhs`. main_token is op.
assign_bit_xor,
/// `lhs |= rhs`. main_token is op.
assign_bit_or,
/// `lhs *%= rhs`. main_token is op.
assign_mul_wrap,
/// `lhs +%= rhs`. main_token is op.
assign_add_wrap,
/// `lhs -%= rhs`. main_token is op.
assign_sub_wrap,
/// `lhs = rhs`. main_token is op.
assign,
/// `lhs || rhs`. main_token is the `||`.
merge_error_sets,
/// `lhs * rhs`. main_token is the `*`.
mul,
/// `lhs / rhs`. main_token is the `/`.
div,
/// `lhs % rhs`. main_token is the `%`.
mod,
/// `lhs ** rhs`. main_token is the `**`.
array_mult,
/// `lhs *% rhs`. main_token is the `*%`.
mul_wrap,
/// `lhs + rhs`. main_token is the `+`.
add,
/// `lhs - rhs`. main_token is the `-`.
sub,
/// `lhs ++ rhs`. main_token is the `++`.
array_cat,
/// `lhs +% rhs`. main_token is the `+%`.
add_wrap,
/// `lhs -% rhs`. main_token is the `-%`.
sub_wrap,
/// `lhs << rhs`. main_token is the `<<`.
bit_shift_left,
/// `lhs >> rhs`. main_token is the `>>`.
bit_shift_right,
/// `lhs & rhs`. main_token is the `&`.
bit_and,
/// `lhs ^ rhs`. main_token is the `^`.
bit_xor,
/// `lhs | rhs`. main_token is the `|`.
bit_or,
/// `lhs orelse rhs`. main_token is the `orelse`.
@"orelse",
/// `lhs and rhs`. main_token is the `and`.
bool_and,
/// `lhs or rhs`. main_token is the `or`.
bool_or,
/// `op lhs`. rhs unused. main_token is op.
bool_not,
/// `op lhs`. rhs unused. main_token is op.
negation,
/// `op lhs`. rhs unused. main_token is op.
bit_not,
/// `op lhs`. rhs unused. main_token is op.
negation_wrap,
/// `op lhs`. rhs unused. main_token is op.
address_of,
/// `op lhs`. rhs unused. main_token is op.
@"try",
/// `op lhs`. rhs unused. main_token is op.
@"await",
/// `?lhs`. rhs unused. main_token is the `?`.
optional_type,
/// `[lhs]rhs`.
array_type,
/// `[lhs:a]b`. `ArrayTypeSentinel[rhs]`.
array_type_sentinel,
/// `[*]align(lhs) rhs`. lhs can be omitted.
/// `*align(lhs) rhs`. lhs can be omitted.
/// `[]rhs`.
/// main_token is the asterisk if a pointer or the lbracket if a slice
/// main_token might be a ** token, which is shared with a parent/child
/// pointer type and may require special handling.
ptr_type_aligned,
/// `[*:lhs]rhs`. lhs can be omitted.
/// `*rhs`.
/// `[:lhs]rhs`.
/// main_token is the asterisk if a pointer or the lbracket if a slice
/// main_token might be a ** token, which is shared with a parent/child
/// pointer type and may require special handling.
ptr_type_sentinel,
/// lhs is index into ptr_type. rhs is the element type expression.
/// main_token is the asterisk if a pointer or the lbracket if a slice
/// main_token might be a ** token, which is shared with a parent/child
/// pointer type and may require special handling.
ptr_type,
/// lhs is index into ptr_type_bit_range. rhs is the element type expression.
/// main_token is the asterisk if a pointer or the lbracket if a slice
/// main_token might be a ** token, which is shared with a parent/child
/// pointer type and may require special handling.
ptr_type_bit_range,
/// `lhs[rhs..]`
/// main_token is the lbracket.
slice_open,
/// `lhs[b..c]`. rhs is index into Slice
/// main_token is the lbracket.
slice,
/// `lhs[b..c :d]`. rhs is index into SliceSentinel
/// main_token is the lbracket.
slice_sentinel,
/// `lhs.*`. rhs is unused.
deref,
/// `lhs[rhs]`.
array_access,
/// `lhs{rhs}`. rhs can be omitted.
array_init_one,
/// `lhs{rhs,}`. rhs can *not* be omitted
array_init_one_comma,
/// `.{lhs, rhs}`. lhs and rhs can be omitted.
array_init_dot_two,
/// Same as `array_init_dot_two` except there is known to be a trailing comma
/// before the final rbrace.
array_init_dot_two_comma,
/// `.{a, b}`. `sub_list[lhs..rhs]`.
array_init_dot,
/// Same as `array_init_dot` except there is known to be a trailing comma
/// before the final rbrace.
array_init_dot_comma,
/// `lhs{a, b}`. `sub_range_list[rhs]`. lhs can be omitted which means `.{a, b}`.
array_init,
/// Same as `array_init` except there is known to be a trailing comma
/// before the final rbrace.
array_init_comma,
/// `lhs{.a = rhs}`. rhs can be omitted making it empty.
/// main_token is the lbrace.
struct_init_one,
/// `lhs{.a = rhs,}`. rhs can *not* be omitted.
/// main_token is the lbrace.
struct_init_one_comma,
/// `.{.a = lhs, .b = rhs}`. lhs and rhs can be omitted.
/// main_token is the lbrace.
/// No trailing comma before the rbrace.
struct_init_dot_two,
/// Same as `struct_init_dot_two` except there is known to be a trailing comma
/// before the final rbrace.
struct_init_dot_two_comma,
/// `.{.a = b, .c = d}`. `sub_list[lhs..rhs]`.
/// main_token is the lbrace.
struct_init_dot,
/// Same as `struct_init_dot` except there is known to be a trailing comma
/// before the final rbrace.
struct_init_dot_comma,
/// `lhs{.a = b, .c = d}`. `sub_range_list[rhs]`.
/// lhs can be omitted which means `.{.a = b, .c = d}`.
/// main_token is the lbrace.
struct_init,
/// Same as `struct_init` except there is known to be a trailing comma
/// before the final rbrace.
struct_init_comma,
/// `lhs(rhs)`. rhs can be omitted.
/// main_token is the lparen.
call_one,
/// `lhs(rhs,)`. rhs can be omitted.
/// main_token is the lparen.
call_one_comma,
/// `async lhs(rhs)`. rhs can be omitted.
async_call_one,
/// `async lhs(rhs,)`.
async_call_one_comma,
/// `lhs(a, b, c)`. `SubRange[rhs]`.
/// main_token is the `(`.
call,
/// `lhs(a, b, c,)`. `SubRange[rhs]`.
/// main_token is the `(`.
call_comma,
/// `async lhs(a, b, c)`. `SubRange[rhs]`.
/// main_token is the `(`.
async_call,
/// `async lhs(a, b, c,)`. `SubRange[rhs]`.
/// main_token is the `(`.
async_call_comma,
/// `switch(lhs) {}`. `SubRange[rhs]`.
@"switch",
/// Same as switch except there is known to be a trailing comma
/// before the final rbrace
switch_comma,
/// `lhs => rhs`. If lhs is omitted it means `else`.
/// main_token is the `=>`
switch_case_one,
/// `a, b, c => rhs`. `SubRange[lhs]`.
/// main_token is the `=>`
switch_case,
/// `lhs...rhs`.
switch_range,
/// `while (lhs) rhs`.
/// `while (lhs) |x| rhs`.
while_simple,
/// `while (lhs) : (a) b`. `WhileCont[rhs]`.
/// `while (lhs) : (a) b`. `WhileCont[rhs]`.
while_cont,
/// `while (lhs) : (a) b else c`. `While[rhs]`.
/// `while (lhs) |x| : (a) b else c`. `While[rhs]`.
/// `while (lhs) |x| : (a) b else |y| c`. `While[rhs]`.
@"while",
/// `for (lhs) rhs`.
for_simple,
/// `for (lhs) a else b`. `if_list[rhs]`.
@"for",
/// `if (lhs) rhs`.
/// `if (lhs) |a| rhs`.
if_simple,
/// `if (lhs) a else b`. `If[rhs]`.
/// `if (lhs) |x| a else b`. `If[rhs]`.
/// `if (lhs) |x| a else |y| b`. `If[rhs]`.
@"if",
/// `suspend lhs`. lhs can be omitted. rhs is unused.
@"suspend",
/// `resume lhs`. rhs is unused.
@"resume",
/// `continue`. lhs is token index of label if any. rhs is unused.
@"continue",
/// `break :lhs rhs`
/// both lhs and rhs may be omitted.
@"break",
/// `return lhs`. lhs can be omitted. rhs is unused.
@"return",
/// `fn(a: lhs) rhs`. lhs can be omitted.
/// anytype and ... parameters are omitted from the AST tree.
/// main_token is the `fn` keyword.
/// extern function declarations use this tag.
fn_proto_simple,
/// `fn(a: b, c: d) rhs`. `sub_range_list[lhs]`.
/// anytype and ... parameters are omitted from the AST tree.
/// main_token is the `fn` keyword.
/// extern function declarations use this tag.
fn_proto_multi,
/// `fn(a: b) rhs linksection(e) callconv(f)`. `FnProtoOne[lhs]`.
/// zero or one parameters.
/// anytype and ... parameters are omitted from the AST tree.
/// main_token is the `fn` keyword.
/// extern function declarations use this tag.
fn_proto_one,
/// `fn(a: b, c: d) rhs linksection(e) callconv(f)`. `FnProto[lhs]`.
/// anytype and ... parameters are omitted from the AST tree.
/// main_token is the `fn` keyword.
/// extern function declarations use this tag.
fn_proto,
/// lhs is the fn_proto.
/// rhs is the function body block.
/// Note that extern function declarations use the fn_proto tags rather
/// than this one.
fn_decl,
/// `anyframe->rhs`. main_token is `anyframe`. `lhs` is arrow token index.
anyframe_type,
/// Both lhs and rhs unused.
anyframe_literal,
/// Both lhs and rhs unused.
char_literal,
/// Both lhs and rhs unused.
integer_literal,
/// Both lhs and rhs unused.
float_literal,
/// Both lhs and rhs unused.
false_literal,
/// Both lhs and rhs unused.
true_literal,
/// Both lhs and rhs unused.
null_literal,
/// Both lhs and rhs unused.
undefined_literal,
/// Both lhs and rhs unused.
unreachable_literal,
/// Both lhs and rhs unused.
/// Most identifiers will not have explicit AST nodes, however for expressions
/// which could be one of many different kinds of AST nodes, there will be an
/// identifier AST node for it.
identifier,
/// lhs is the dot token index, rhs unused, main_token is the identifier.
enum_literal,
/// main_token is the string literal token
/// Both lhs and rhs unused.
string_literal,
/// main_token is the first token index (redundant with lhs)
/// lhs is the first token index; rhs is the last token index.
/// Could be a series of multiline_string_literal_line tokens, or a single
/// string_literal token.
multiline_string_literal,
/// `(lhs)`. main_token is the `(`; rhs is the token index of the `)`.
grouped_expression,
/// `@a(lhs, rhs)`. lhs and rhs may be omitted.
/// main_token is the builtin token.
builtin_call_two,
/// Same as builtin_call_two but there is known to be a trailing comma before the rparen.
builtin_call_two_comma,
/// `@a(b, c)`. `sub_list[lhs..rhs]`.
/// main_token is the builtin token.
builtin_call,
/// Same as builtin_call but there is known to be a trailing comma before the rparen.
builtin_call_comma,
/// `error{a, b}`.
/// rhs is the rbrace, lhs is unused.
error_set_decl,
/// `struct {}`, `union {}`, `opaque {}`, `enum {}`. `extra_data[lhs..rhs]`.
/// main_token is `struct`, `union`, `opaque`, `enum` keyword.
container_decl,
/// Same as ContainerDecl but there is known to be a trailing comma
/// or semicolon before the rbrace.
container_decl_trailing,
/// `struct {lhs, rhs}`, `union {lhs, rhs}`, `opaque {lhs, rhs}`, `enum {lhs, rhs}`.
/// lhs or rhs can be omitted.
/// main_token is `struct`, `union`, `opaque`, `enum` keyword.
container_decl_two,
/// Same as ContainerDeclTwo except there is known to be a trailing comma
/// or semicolon before the rbrace.
container_decl_two_trailing,
/// `union(lhs)` / `enum(lhs)`. `SubRange[rhs]`.
container_decl_arg,
/// Same as container_decl_arg but there is known to be a trailing
/// comma or semicolon before the rbrace.
container_decl_arg_trailing,
/// `union(enum) {}`. `sub_list[lhs..rhs]`.
/// Note that tagged unions with explicitly provided enums are represented
/// by `container_decl_arg`.
tagged_union,
/// Same as tagged_union but there is known to be a trailing comma
/// or semicolon before the rbrace.
tagged_union_trailing,
/// `union(enum) {lhs, rhs}`. lhs or rhs may be omitted.
/// Note that tagged unions with explicitly provided enums are represented
/// by `container_decl_arg`.
tagged_union_two,
/// Same as tagged_union_two but there is known to be a trailing comma
/// or semicolon before the rbrace.
tagged_union_two_trailing,
/// `union(enum(lhs)) {}`. `SubRange[rhs]`.
tagged_union_enum_tag,
/// Same as tagged_union_enum_tag but there is known to be a trailing comma
/// or semicolon before the rbrace.
tagged_union_enum_tag_trailing,
/// `a: lhs = rhs,`. lhs and rhs can be omitted.
/// main_token is the field name identifier.
/// lastToken() does not include the possible trailing comma.
container_field_init,
/// `a: lhs align(rhs),`. rhs can be omitted.
/// main_token is the field name identifier.
/// lastToken() does not include the possible trailing comma.
container_field_align,
/// `a: lhs align(c) = d,`. `container_field_list[rhs]`.
/// main_token is the field name identifier.
/// lastToken() does not include the possible trailing comma.
container_field,
/// `anytype`. both lhs and rhs unused.
/// Used by `ContainerField`.
@"anytype",
/// `comptime lhs`. rhs unused.
@"comptime",
/// `nosuspend lhs`. rhs unused.
@"nosuspend",
/// `{lhs rhs}`. rhs or lhs can be omitted.
/// main_token points at the lbrace.
block_two,
/// Same as block_two but there is known to be a semicolon before the rbrace.
block_two_semicolon,
/// `{}`. `sub_list[lhs..rhs]`.
/// main_token points at the lbrace.
block,
/// Same as block but there is known to be a semicolon before the rbrace.
block_semicolon,
/// `asm(lhs)`. rhs is the token index of the rparen.
asm_simple,
/// `asm(lhs, a)`. `Asm[rhs]`.
@"asm",
/// `[a] "b" (c)`. lhs is 0, rhs is token index of the rparen.
/// `[a] "b" (-> lhs)`. rhs is token index of the rparen.
/// main_token is `a`.
asm_output,
/// `[a] "b" (lhs)`. rhs is token index of the rparen.
/// main_token is `a`.
asm_input,
/// `error.a`. lhs is token index of `.`. rhs is token index of `a`.
error_value,
/// `lhs!rhs`. main_token is the `!`.
error_union,
pub fn isContainerField(tag: Tag) bool {
return switch (tag) {
.container_field_init,
.container_field_align,
.container_field,
=> true,
else => false,
};
}
};
pub const Data = struct {
lhs: Index,
rhs: Index,
};
pub const LocalVarDecl = struct {
type_node: Index,
align_node: Index,
};
pub const ArrayTypeSentinel = struct {
elem_type: Index,
sentinel: Index,
};
pub const PtrType = struct {
sentinel: Index,
align_node: Index,
};
pub const PtrTypeBitRange = struct {
sentinel: Index,
align_node: Index,
bit_range_start: Index,
bit_range_end: Index,
};
pub const SubRange = struct {
/// Index into sub_list.
start: Index,
/// Index into sub_list.
end: Index,
};
pub const If = struct {
then_expr: Index,
else_expr: Index,
};
pub const ContainerField = struct {
value_expr: Index,
align_expr: Index,
};
pub const GlobalVarDecl = struct {
type_node: Index,
align_node: Index,
section_node: Index,
};
pub const Slice = struct {
start: Index,
end: Index,
};
pub const SliceSentinel = struct {
start: Index,
/// May be 0 if the slice is "open"
end: Index,
sentinel: Index,
};
pub const While = struct {
cont_expr: Index,
then_expr: Index,
else_expr: Index,
};
pub const WhileCont = struct {
cont_expr: Index,
then_expr: Index,
};
pub const FnProtoOne = struct {
/// Populated if there is exactly 1 parameter. Otherwise there are 0 parameters.
param: Index,
/// Populated if align(A) is present.
align_expr: Index,
/// Populated if linksection(A) is present.
section_expr: Index,
/// Populated if callconv(A) is present.
callconv_expr: Index,
};
pub const FnProto = struct {
params_start: Index,
params_end: Index,
/// Populated if align(A) is present.
align_expr: Index,
/// Populated if linksection(A) is present.
section_expr: Index,
/// Populated if callconv(A) is present.
callconv_expr: Index,
};
pub const Asm = struct {
items_start: Index,
items_end: Index,
/// Needed to make lastToken() work.
rparen: TokenIndex,
};
}; | lib/std/zig/ast.zig |
const std = @import("std");
const version = @import("version");
const zzz = @import("zzz");
const api = @import("api.zig");
const uri = @import("uri");
const build_options = @import("build_options");
const Dependency = @import("Dependency.zig");
usingnamespace @import("common.zig");
const Self = @This();
const Allocator = std.mem.Allocator;
const Hasher = std.crypto.hash.blake2.Blake2b128;
const testing = std.testing;
arena: std.heap.ArenaAllocator,
text: []const u8,
entries: std.ArrayList(*Entry),
pub const Entry = union(enum) {
pkg: struct {
user: []const u8,
name: []const u8,
version: version.Semver,
repository: []const u8,
},
github: struct {
user: []const u8,
repo: []const u8,
ref: []const u8,
commit: []const u8,
root: []const u8,
},
url: struct {
str: []const u8,
root: []const u8,
},
local: struct {
path: []const u8,
root: []const u8,
},
pub fn fromLine(line: []const u8) !Entry {
var it = std.mem.tokenize(line, " ");
const first = it.next() orelse return error.EmptyLine;
var ret: Entry = undefined;
if (std.mem.eql(u8, first, "url")) {
ret = Entry{
.url = .{
.root = it.next() orelse return error.NoRoot,
.str = it.next() orelse return error.NoUrl,
},
};
const url = try uri.parse(ret.url.str);
} else if (std.mem.eql(u8, first, "local")) {
ret = Entry{
.local = .{
.root = it.next() orelse return error.NoRoot,
.path = it.next() orelse return error.NoPath,
},
};
} else if (std.mem.eql(u8, first, "github")) {
ret = Entry{
.github = .{
.user = it.next() orelse return error.NoUser,
.repo = it.next() orelse return error.NoRepo,
.ref = it.next() orelse return error.NoRef,
.root = it.next() orelse return error.NoRoot,
.commit = it.next() orelse return error.NoCommit,
},
};
} else if (std.mem.eql(u8, first, "pkg")) {
const repo = it.next() orelse return error.NoRepo;
ret = Entry{
.pkg = .{
.repository = if (std.mem.eql(u8, repo, "default")) build_options.default_repo else repo,
.user = it.next() orelse return error.NoUser,
.name = it.next() orelse return error.NoName,
.version = try version.Semver.parse(it.next() orelse return error.NoVersion),
},
};
} else return error.UnknownEntryType;
return ret;
}
pub fn getDeps(self: Entry, arena: *std.heap.ArenaAllocator) ![]Dependency {
try self.fetch(arena.child_allocator);
const file = switch (self) {
.pkg => |pkg| blk: {
const package_path = try self.packagePath(arena.child_allocator);
defer arena.child_allocator.free(package_path);
var base_dir = try std.fs.cwd().openDir(
package_path,
.{ .access_sub_paths = true },
);
defer base_dir.close();
break :blk base_dir.openFile(
"manifest.zzz",
.{ .read = true },
) catch |err| {
return if (err == error.FileNotFound) &[_]Dependency{} else err;
};
},
.url, .github, .local => blk: {
const base_path = try self.basePath(arena);
var base_dir = try std.fs.cwd().openDir(
base_path,
.{ .access_sub_paths = true },
);
defer base_dir.close();
break :blk base_dir.openFile(
"gyro.zzz",
.{ .read = true },
) catch |err| {
return if (err == error.FileNotFound) &[_]Dependency{} else err;
};
},
};
defer file.close();
const text = try file.reader().readAllAlloc(
&arena.allocator,
std.math.maxInt(usize),
);
var deps = std.ArrayListUnmanaged(Dependency){};
var ztree = zzz.ZTree(1, 1000){};
var root = try ztree.appendText(text);
if (zFindChild(root, "deps")) |deps_node| {
var it = ZChildIterator.init(deps_node);
while (it.next()) |node|
try deps.append(
&arena.allocator,
try Dependency.fromZNode(node),
);
}
switch (self) {
.url, .github => {
// search for pkg with matching root file
if (zFindChild(root, "pkgs")) |pkgs_node| {
const entry_root = switch (self) {
.url => |url| url.root,
.github => |gh| gh.root,
else => unreachable,
};
var pkg_it = ZChildIterator.init(pkgs_node);
while (pkg_it.next()) |pkg_node| {
const pkg_root = (try zFindString(pkg_node, "root")) orelse "src/main.zig";
if (std.mem.eql(u8, pkg_root, entry_root)) {
if (zFindChild(pkg_node, "deps")) |deps_node| {
var it = ZChildIterator.init(deps_node);
while (it.next()) |dep_node| {
const dep = try Dependency.fromZNode(dep_node);
try deps.append(&arena.allocator, dep);
}
}
}
}
}
},
else => {},
}
return deps.items;
}
fn basePath(self: Entry, arena: *std.heap.ArenaAllocator) ![]const u8 {
return if (self == .local)
self.local.path
else blk: {
const package_path = try self.packagePath(arena.child_allocator);
defer arena.child_allocator.free(package_path);
break :blk try std.fs.path.join(&arena.allocator, &[_][]const u8{
package_path,
"pkg",
});
};
}
pub fn getRootPath(self: Entry, arena: *std.heap.ArenaAllocator) ![]const u8 {
const package_path = try self.packagePath(arena.child_allocator);
defer arena.child_allocator.free(package_path);
var root_path = try arena.allocator.dupe(u8, switch (self) {
.pkg => |pkg| blk: {
var dir = try std.fs.cwd().openDir(package_path, .{ .access_sub_paths = true });
defer dir.close();
const file = try dir.openFile("manifest.zzz", .{ .read = true });
defer file.close();
var text = try file.reader().readAllAlloc(&arena.allocator, std.math.maxInt(usize));
var tree = zzz.ZTree(1, 1000){};
var root = try tree.appendText(text);
break :blk (try zFindString(root, "root")) orelse {
std.log.err("Root missing for package: {s}/{s}-{} from {s}", .{
pkg.user,
pkg.name,
pkg.version,
pkg.repository,
});
return error.Explained;
};
},
.github => |gh| gh.root,
.url => |url| url.root,
.local => |local| {
var ret = try std.fs.path.join(&arena.allocator, &[_][]const u8{ local.path, local.root });
if (std.fs.path.sep == std.fs.path.sep_windows) {
for (ret) |*c| {
if (c.* == '/') {
c.* = '\\';
}
}
}
return ret;
},
});
if (std.fs.path.sep == std.fs.path.sep_windows) {
for (root_path) |*c| {
if (c.* == '/') {
c.* = '\\';
}
}
}
return try std.fs.path.join(&arena.allocator, &[_][]const u8{
package_path,
"pkg",
root_path,
});
}
pub fn getEscapedRootPath(self: Entry, arena: *std.heap.ArenaAllocator) ![]const u8 {
var root_path = try self.getRootPath(arena);
return if (std.fs.path.sep == std.fs.path.sep_windows)
try std.mem.replaceOwned(
u8,
&arena.allocator,
root_path,
"\\",
"\\\\",
)
else
root_path;
}
pub fn getEscapedPackageDir(self: Entry, arena: *std.heap.ArenaAllocator) ![]const u8 {
var package_path = switch (self) {
.local => try self.packagePath(&arena.allocator),
else => try std.fs.path.join(&arena.allocator, &.{
try self.packagePath(&arena.allocator),
"pkg",
}),
};
return if (std.fs.path.sep == std.fs.path.sep_windows)
try std.mem.replaceOwned(
u8,
&arena.allocator,
package_path,
"\\",
"\\\\",
)
else
package_path;
}
pub fn packagePath(self: Entry, allocator: *Allocator) ![]const u8 {
var tree = zzz.ZTree(1, 1000){};
var root = try tree.addNode(null, .{ .Null = {} });
var ver_buf: [80]u8 = undefined;
switch (self) {
.pkg => |pkg| {
var ver_stream = std.io.fixedBufferStream(&ver_buf);
try ver_stream.writer().print("{}", .{pkg.version});
var node = try tree.addNode(root, .{ .String = "pkg" });
try zPutKeyString(&tree, node, "user", pkg.user);
try zPutKeyString(&tree, node, "name", pkg.name);
try zPutKeyString(&tree, node, "version", ver_stream.getWritten());
try zPutKeyString(&tree, node, "repository", pkg.repository);
},
.github => |gh| {
var node = try tree.addNode(root, .{ .String = "github" });
try zPutKeyString(&tree, node, "user", gh.user);
try zPutKeyString(&tree, node, "repo", gh.repo);
try zPutKeyString(&tree, node, "commit", gh.commit);
},
.url => |url| {
try zPutKeyString(&tree, root, "url", url.str);
},
.local => |local| return try allocator.dupe(u8, local.path),
}
var buf: [std.mem.page_size]u8 = undefined;
var digest: [Hasher.digest_length]u8 = undefined;
var ret: [Hasher.digest_length * 2]u8 = undefined;
var stream = std.io.fixedBufferStream(&buf);
try root.stringify(stream.writer());
Hasher.hash(stream.getWritten(), &digest, .{});
const lookup = "012345678789abcdef";
for (digest) |val, i| {
ret[2 * i] = lookup[val >> 4];
ret[(2 * i) + 1] = lookup[@truncate(u4, val)];
}
var fifo = std.fifo.LinearFifo(u8, .{ .Dynamic = {} }).init(allocator);
defer fifo.deinit();
switch (self) {
.pkg => |pkg| try fifo.writer().print("{s}-{s}-{}-{s}", .{ pkg.name, pkg.user, pkg.version, &ret }),
.github => |gh| try fifo.writer().print("{s}-{s}-{s}", .{ gh.repo, gh.user, gh.commit }),
.url => |url| try fifo.writer().print("{s}", .{&ret}),
.local => |local| try fifo.writer().print("{s}", .{&ret}),
}
return std.fs.path.join(allocator, &[_][]const u8{
".gyro",
fifo.readableSlice(0),
});
}
pub fn fetch(self: Entry, allocator: *Allocator) !void {
switch (self) {
.url => |url| if (std.mem.startsWith(u8, url.str, "file://"))
return,
else => {},
}
const base_path = try self.packagePath(allocator);
defer allocator.free(base_path);
// here: check for ok file and return if it exists
var base_dir = try std.fs.cwd().makeOpenPath(base_path, .{
.access_sub_paths = true,
});
defer base_dir.close();
var found = true;
base_dir.access("ok", .{ .read = true }) catch |err| {
if (err == error.FileNotFound)
found = false
else
return err;
};
if (found) return;
switch (self) {
.pkg => |pkg| try api.getPkg(allocator, pkg.repository, pkg.user, pkg.name, pkg.version, base_dir),
.github => |gh| {
var pkg_dir = try base_dir.makeOpenPath("pkg", .{ .access_sub_paths = true });
defer pkg_dir.close();
try api.getGithubTarGz(allocator, gh.user, gh.repo, gh.commit, pkg_dir);
},
.url => |url| {
var pkg_dir = try base_dir.makeOpenPath("pkg", .{ .access_sub_paths = true });
defer pkg_dir.close();
try api.getTarGz(allocator, url.str, pkg_dir);
},
.local => {},
}
const ok = try base_dir.createFile("ok", .{ .read = true });
defer ok.close();
}
pub fn write(self: Entry, writer: anytype) !void {
switch (self) {
.pkg => |pkg| {
const repo = if (std.mem.eql(u8, pkg.repository, build_options.default_repo))
"default"
else
pkg.repository;
try writer.print("pkg {s} {s} {s} {}", .{ repo, pkg.user, pkg.name, pkg.version });
},
.github => |gh| try writer.print("github {s} {s} {s} {s} {s}", .{
gh.user,
gh.repo,
gh.ref,
gh.root,
gh.commit,
}),
.url => |url| try writer.print("url {s} {s}", .{ url.root, url.str }),
.local => |local| try writer.print("local {s} {s}", .{ local.root, local.path }),
}
try writer.writeAll("\n");
}
};
fn fromReader(allocator: *Allocator, reader: anytype) !Self {
var ret = Self{
.arena = std.heap.ArenaAllocator.init(allocator),
.entries = std.ArrayList(*Entry).init(allocator),
.text = try reader.readAllAlloc(allocator, std.math.maxInt(usize)),
};
var it = std.mem.tokenize(ret.text, "\n");
while (it.next()) |line| {
const entry = try ret.arena.allocator.create(Entry);
entry.* = try Entry.fromLine(line);
try ret.entries.append(entry);
}
return ret;
}
pub fn fromFile(allocator: *Allocator, file: std.fs.File) !Self {
return fromReader(allocator, file.reader());
}
pub fn deinit(self: *Self) void {
self.entries.allocator.free(self.text);
self.entries.deinit();
self.arena.deinit();
}
pub fn save(self: Self, file: std.fs.File) !void {
try file.seekTo(0);
for (self.entries.items) |entry| {
if (entry.* == .local)
continue;
try entry.write(file.writer());
}
}
pub fn fetchAll(self: Self) !void {
for (self.entries.items) |entry|
try entry.fetch(self.arena.child_allocator);
}
fn expectEntryEqual(expected: Entry, actual: Entry) !void {
const SourceType = std.meta.Tag(Entry);
try testing.expectEqual(@as(SourceType, expected), @as(SourceType, actual));
switch (expected) {
.pkg => |pkg| {
try testing.expectEqualStrings(pkg.user, actual.pkg.user);
try testing.expectEqualStrings(pkg.name, actual.pkg.name);
try testing.expectEqualStrings(pkg.repository, actual.pkg.repository);
try testing.expectEqual(pkg.version, actual.pkg.version);
},
.github => |gh| {
try testing.expectEqualStrings(gh.user, actual.github.user);
try testing.expectEqualStrings(gh.repo, actual.github.repo);
try testing.expectEqualStrings(gh.ref, actual.github.ref);
try testing.expectEqualStrings(gh.commit, actual.github.commit);
try testing.expectEqualStrings(gh.root, actual.github.root);
},
.url => |url| {
try testing.expectEqualStrings(url.str, actual.url.str);
try testing.expectEqualStrings(url.root, actual.url.root);
},
.local => |local| {
try testing.expectEqualStrings(local.path, actual.local.path);
try testing.expectEqualStrings(local.root, actual.local.root);
},
}
}
test "entry from pkg: default repository" {
const actual = try Entry.fromLine("pkg default matt something 0.1.0");
const expected = Entry{
.pkg = .{
.user = "matt",
.name = "something",
.repository = build_options.default_repo,
.version = version.Semver{
.major = 0,
.minor = 1,
.patch = 0,
},
},
};
try expectEntryEqual(expected, actual);
}
test "entry from pkg: non-default repository" {
const actual = try Entry.fromLine("pkg my_own_repository matt foo 0.2.0");
const expected = Entry{
.pkg = .{
.user = "matt",
.name = "foo",
.repository = "my_own_repository",
.version = version.Semver{
.major = 0,
.minor = 2,
.patch = 0,
},
},
};
try expectEntryEqual(expected, actual);
}
test "entry from github" {
var actual = try Entry.fromLine("github my_user my_repo master src/foo.zig 30d004329543603f76bd9d7daca054878a04fdb5");
var expected = Entry{
.github = .{
.user = "my_user",
.repo = "my_repo",
.ref = "master",
.root = "src/foo.zig",
.commit = "<PASSWORD>",
},
};
try expectEntryEqual(expected, actual);
}
test "entry from url" {
const actual = try Entry.fromLine("url src/foo.zig https://example.com/something.tar.gz");
const expected = Entry{
.url = .{
.root = "src/foo.zig",
.str = "https://example.com/something.tar.gz",
},
};
try expectEntryEqual(expected, actual);
}
test "local entry" {
const actual = try Entry.fromLine("local src/foo.zig mypkgs/cool-project");
const expected = Entry{
.local = .{
.root = "src/foo.zig",
.path = "mypkgs/cool-project",
},
};
try expectEntryEqual(expected, actual);
}
test "lockfile with example of all" {
const text =
\\pkg default matt something 0.1.0
\\pkg my_repository matt foo 0.4.5
\\github my_user my_repo master src/foo.zig 30d004329543603f76bd9d7daca054878a04fdb5
\\url src/foo.zig https://example.com/something.tar.gz
\\local src/foo.zig mypkgs/cool-project
;
var stream = std.io.fixedBufferStream(text);
var actual = try Self.fromReader(std.testing.allocator, stream.reader());
defer actual.deinit();
var expected = [_]Entry{
.{
.pkg = .{
.user = "matt",
.name = "something",
.repository = build_options.default_repo,
.version = version.Semver{
.major = 0,
.minor = 1,
.patch = 0,
},
},
},
.{
.pkg = .{
.user = "matt",
.name = "foo",
.repository = "my_repository",
.version = version.Semver{
.major = 0,
.minor = 4,
.patch = 5,
},
},
},
.{
.github = .{
.user = "my_user",
.repo = "my_repo",
.ref = "master",
.root = "src/foo.zig",
.commit = "30d004329543603f76bd9d7daca054878a04fdb5",
},
},
.{
.url = .{
.root = "src/foo.zig",
.str = "https://example.com/something.tar.gz",
},
},
.{
.local = .{
.root = "src/foo.zig",
.path = "mypkgs/cool-project",
},
},
};
for (expected) |exp, i| {
try expectEntryEqual(exp, actual.entries.items[i].*);
}
} | src/Lockfile.zig |
const std = @import("std");
const mem = std.mem;
const hzzp = @import("hzzp");
const zuri = @import("uri");
const tls = @import("iguanaTLS");
const conn = @import("connection.zig");
const Protocol = conn.Protocol;
const Connection = conn.Connection;
/// All RFC 7231 and RFC 5789 HTTP methods.
pub const Method = enum {
GET,
HEAD,
POST,
PUT,
DELETE,
CONNECT,
OPTIONS,
TRACE,
PATCH,
pub fn name(self: Method) []const u8 {
return @tagName(self);
}
pub const HasPayload = enum { yes, no, maybe };
pub fn hasPayload(self: Method) HasPayload {
switch (self) {
.GET, .HEAD, .CONNECT, .OPTIONS, .TRACE => return .no,
.POST, .PUT, .PATCH => return .yes,
.DELETE => return .maybe,
}
}
};
const root = @import("root");
const read_buffer_size = if (@hasDecl(root, "zfetch_read_buffer_size"))
root.zfetch_read_buffer_size
else if (@hasDecl(root, "zfetch_buffer_size"))
root.zfetch_buffer_size
else if (@hasDecl(root, "zfetch_large_buffer"))
if (root.zfetch_large_buffer) 32768 else 4096
else
4096;
const write_buffer_size = if (@hasDecl(root, "zfetch_write_buffer_size"))
root.zfetch_write_buffer_size
else if (@hasDecl(root, "zfetch_buffer_size"))
root.zfetch_buffer_size
else if (@hasDecl(root, "zfetch_large_buffer"))
if (root.zfetch_large_buffer) 32768 else 4096
else
4096;
const BufferedReader = std.io.BufferedReader(read_buffer_size, Connection.Reader);
const BufferedWriter = std.io.BufferedWriter(write_buffer_size, Connection.Writer);
const HttpClient = hzzp.base.client.BaseClient(BufferedReader.Reader, BufferedWriter.Writer);
pub const Request = struct {
pub const Status = struct {
/// The response code
code: u16,
/// The reason for this response code, may be non-standard.
reason: []const u8,
};
allocator: mem.Allocator,
/// The connection that this request is using.
socket: Connection,
/// A duplicate of the url provided when initialized.
url: []const u8,
/// The components of the url provided when initialized.
uri: zuri.UriComponents,
buffer: []u8 = undefined,
client: HttpClient,
/// The response status.
status: Status,
/// The response headers.
headers: hzzp.Headers,
buffered_reader: *BufferedReader,
buffered_writer: *BufferedWriter,
// assumes scheme://hostname[:port]/ url
/// Start a new request to the specified url. This will open a connection to the server.
/// `url` must remain alive until the request is sent (see commit).
pub fn init(allocator: mem.Allocator, url: []const u8, trust: ?tls.x509.CertificateChain) !*Request {
const uri = try zuri.parse(url);
const protocol: Protocol = proto: {
if (uri.scheme) |scheme| {
if (mem.eql(u8, scheme, "http")) {
break :proto .http;
} else if (mem.eql(u8, scheme, "https")) {
break :proto .https;
} else {
return error.InvalidScheme;
}
} else {
return error.MissingScheme;
}
};
var req = try allocator.create(Request);
errdefer allocator.destroy(req);
if (uri.host == null) return error.MissingHost;
req.allocator = allocator;
req.socket = try Connection.connect(allocator, uri.host.?, uri.port, protocol, trust);
errdefer req.socket.close();
req.buffer = try allocator.alloc(u8, mem.page_size);
errdefer allocator.free(req.buffer);
req.url = url;
req.uri = uri;
req.buffered_reader = try allocator.create(BufferedReader);
errdefer allocator.destroy(req.buffered_reader);
req.buffered_reader.* = .{ .unbuffered_reader = req.socket.reader() };
req.buffered_writer = try allocator.create(BufferedWriter);
errdefer allocator.destroy(req.buffered_writer);
req.buffered_writer.* = .{ .unbuffered_writer = req.socket.writer() };
req.client = HttpClient.init(req.buffer, req.buffered_reader.reader(), req.buffered_writer.writer());
req.headers = hzzp.Headers.init(allocator);
req.status = Status{
.code = 0,
.reason = "",
};
return req;
}
pub fn reset(self: *Request, url: []const u8) !void {
const uri = try zuri.parse(url);
const protocol: Protocol = proto: {
if (uri.scheme) |scheme| {
if (mem.eql(u8, scheme, "http")) {
break :proto .http;
} else if (mem.eql(u8, scheme, "https")) {
break :proto .https;
} else {
return error.InvalidScheme;
}
} else {
return error.MissingScheme;
}
};
if (uri.host == null) return error.MissingHost;
if (protocol != self.socket.protocol) return error.ProtocolMismatch;
if (!mem.eql(u8, uri.host.?, self.socket.hostname)) return error.HostnameMismatch;
if ((uri.port orelse protocol.defaultPort()) != self.socket.port) return error.PortMismatch;
self.url = url;
self.uri = uri;
self.client.reset();
self.headers.deinit();
self.headers = hzzp.Headers.init(self.allocator);
self.allocator.free(self.status.reason);
self.status = Status{
.code = 0,
.reason = "",
};
}
/// End this request. Closes the connection and frees all data.
pub fn deinit(self: *Request) void {
self.socket.close();
self.headers.deinit();
self.uri = undefined;
self.allocator.free(self.buffer);
self.allocator.free(self.status.reason);
self.allocator.destroy(self.buffered_reader);
self.allocator.destroy(self.buffered_writer);
self.allocator.destroy(self);
}
/// See `commit` and `fulfill`
pub fn do(self: *Request, method: Method, headers: ?hzzp.Headers, payload: ?[]const u8) !void {
try self.commit(method, headers, payload);
try self.fulfill();
}
/// Performs the initial request. This verifies whether the method you are using requires or disallows a payload.
/// Default headers such as Host, Authorization (when using basic authentication), Connection, User-Agent, and
/// Content-Length are provided automatically, therefore headers is nullable. This only writes information to allow
/// for greater compatibility for change in the future.
pub fn commit(self: *Request, method: Method, headers: ?hzzp.Headers, payload: ?[]const u8) !void {
if (method.hasPayload() == .yes and payload == null) return error.MissingPayload;
if (method.hasPayload() == .no and payload != null) return error.MustOmitPayload;
try self.client.writeStatusLineParts(method.name(), self.uri.path orelse "/", self.uri.query, self.uri.fragment);
if (headers == null or !headers.?.contains("Host")) {
try self.client.writeHeaderValue("Host", self.uri.host.?);
}
if (self.uri.user != null or self.uri.password != null) {
if (self.uri.user == null) return error.MissingUsername;
if (self.uri.password == null) return error.MissingPassword;
if (headers != null and headers.?.contains("Authorization")) return error.AuthorizationMismatch;
var unencoded = try std.fmt.allocPrint(self.allocator, "{s}:{s}", .{ self.uri.user, self.uri.password });
defer self.allocator.free(unencoded);
var auth = try self.allocator.alloc(u8, std.base64.standard.Encoder.calcSize(unencoded.len));
defer self.allocator.free(auth);
_ = std.base64.standard.Encoder.encode(auth, unencoded);
try self.client.writeHeaderFormat("Authorization", "Basic {s}", .{auth});
}
if (headers == null or !headers.?.contains("Connection")) {
try self.client.writeHeaderValue("Connection", "close");
}
if (headers == null or !headers.?.contains("User-Agent")) {
try self.client.writeHeaderValue("User-Agent", "zfetch");
}
if (payload != null and (headers == null or !headers.?.contains("Content-Length") and !headers.?.contains("Transfer-Encoding"))) {
try self.client.writeHeaderFormat("Content-Length", "{d}", .{payload.?.len});
}
if (headers) |hdrs| {
try self.client.writeHeaders(hdrs.list.items);
}
try self.client.finishHeaders();
try self.client.writePayload(payload);
try self.buffered_writer.flush();
}
/// Waits for the head of the response to be returned. This is not safe for malicious servers, which may stall
/// forever.
pub fn fulfill(self: *Request) !void {
while (try self.client.next()) |event| {
switch (event) {
.status => |stat| {
self.status.code = stat.code;
self.status.reason = try self.allocator.dupe(u8, stat.reason);
},
.header => |header| {
try self.headers.append(header);
},
.head_done => {
return;
},
.skip => {},
.payload, .end => unreachable,
}
}
}
pub const Reader = HttpClient.PayloadReader;
/// A reader for the response payload. This should only be called after the request is fulfilled.
pub fn reader(self: *Request) Reader {
return self.client.reader();
}
};
test "makes request" {
try conn.init();
defer conn.deinit();
var req = try Request.init(std.testing.allocator, "https://httpbin.org/get", null);
defer req.deinit();
try req.do(.GET, null, null);
try std.testing.expect(req.status.code == 200);
try std.testing.expectEqualStrings("OK", req.status.reason);
try std.testing.expectEqualStrings("application/json", req.headers.get("content-type").?);
var body = try req.reader().readAllAlloc(std.testing.allocator, 4 * 1024);
defer std.testing.allocator.free(body);
var json = std.json.Parser.init(std.testing.allocator, false);
defer json.deinit();
var tree = try json.parse(body);
defer tree.deinit();
try std.testing.expectEqualStrings("https://httpbin.org/get", tree.root.Object.get("url").?.String);
try std.testing.expectEqualStrings("zfetch", tree.root.Object.get("headers").?.Object.get("User-Agent").?.String);
}
test "does basic auth" {
try conn.init();
defer conn.deinit();
var req = try Request.init(std.testing.allocator, "https://username:[email protected]/basic-auth/username/password", null);
defer req.deinit();
try req.do(.GET, null, null);
try std.testing.expect(req.status.code == 200);
try std.testing.expectEqualStrings("OK", req.status.reason);
try std.testing.expectEqualStrings("application/json", req.headers.get("content-type").?);
var body = try req.reader().readAllAlloc(std.testing.allocator, 4 * 1024);
defer std.testing.allocator.free(body);
var json = std.json.Parser.init(std.testing.allocator, false);
defer json.deinit();
var tree = try json.parse(body);
defer tree.deinit();
try std.testing.expect(tree.root.Object.get("authenticated").?.Bool == true);
try std.testing.expectEqualStrings("username", tree.root.Object.get("user").?.String);
}
test "can reset and resend" {
try conn.init();
defer conn.deinit();
var headers = hzzp.Headers.init(std.testing.allocator);
defer headers.deinit();
try headers.appendValue("Connection", "keep-alive");
var req = try Request.init(std.testing.allocator, "https://httpbin.org/user-agent", null);
defer req.deinit();
try req.do(.GET, headers, null);
try std.testing.expect(req.status.code == 200);
try std.testing.expectEqualStrings("OK", req.status.reason);
try std.testing.expectEqualStrings("application/json", req.headers.get("content-type").?);
var body = try req.reader().readAllAlloc(std.testing.allocator, 4 * 1024);
defer std.testing.allocator.free(body);
var json = std.json.Parser.init(std.testing.allocator, false);
defer json.deinit();
var tree = try json.parse(body);
defer tree.deinit();
try std.testing.expectEqualStrings("zfetch", tree.root.Object.get("user-agent").?.String);
try req.reset("https://httpbin.org/get");
try req.do(.GET, null, null);
try std.testing.expect(req.status.code == 200);
try std.testing.expectEqualStrings("OK", req.status.reason);
try std.testing.expectEqualStrings("application/json", req.headers.get("content-type").?);
var body1 = try req.reader().readAllAlloc(std.testing.allocator, 4 * 1024);
defer std.testing.allocator.free(body1);
var json1 = std.json.Parser.init(std.testing.allocator, false);
defer json1.deinit();
var tree1 = try json1.parse(body1);
defer tree1.deinit();
try std.testing.expectEqualStrings("https://httpbin.org/get", tree1.root.Object.get("url").?.String);
try std.testing.expectEqualStrings("zfetch", tree1.root.Object.get("headers").?.Object.get("User-Agent").?.String);
}
comptime {
std.testing.refAllDecls(@This());
} | src/request.zig |
const std = @import("std");
const console = @import("src/console.zig");
pub fn build(b: *std.build.Builder) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
const imgui = b.option(bool, "imgui", "Use imgui for extra features") orelse false;
const precision = b.option(console.Precision, "precision", "Whether to prioritize performance or accuracy") orelse .accurate;
const log_step = b.option(bool, "log-step", "Whether to log every cpu step to stdout") orelse false;
if (imgui and precision == .fast) {
@panic("Not supporting imgui and fast precision right now (not sure if I want to?)");
}
const exe = b.addExecutable("badnes", "src/main.zig");
exe.linkLibC();
exe.linkSystemLibrary("SDL2");
exe.linkSystemLibrary("opengl");
if (imgui) {
linkImgui(b, exe);
}
exe.setTarget(target);
exe.setBuildMode(mode);
exe.install();
const exe_options = b.addOptions();
exe.addOptions("build_options", exe_options);
exe_options.addOption(console.Precision, "precision", precision);
exe_options.addOption(bool, "log_step", log_step);
exe_options.addOption(bool, "imgui", imgui);
const run_cmd = exe.run();
run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| {
run_cmd.addArgs(args);
}
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
const test_step = b.step("test", "Run all the tests");
test_step.dependOn(b.getInstallStep());
const tests = b.addTest("src/tests.zig");
tests.setBuildMode(.Debug);
tests.addOptions("build_options", exe_options);
test_step.dependOn(&tests.step);
}
fn linkImgui(b: *std.build.Builder, exe: *std.build.LibExeObjStep) void {
const imgui = b.addStaticLibrary("imgui", null);
imgui.linkLibC();
imgui.linkLibCpp();
imgui.linkSystemLibrary("SDL2");
imgui.linkSystemLibrary("opengl");
imgui.addIncludeDir("cimgui/imgui");
imgui.defineCMacro("IMGUI_DISABLE_OBSOLETE_FUNCTIONS", "1");
imgui.defineCMacro("IMGUI_IMPL_API", "extern \"C\"");
const source_files = [_]([]const u8){
"cimgui/imgui/imgui.cpp",
"cimgui/imgui/imgui_tables.cpp",
"cimgui/imgui/imgui_draw.cpp",
"cimgui/imgui/imgui_widgets.cpp",
"cimgui/imgui/imgui_demo.cpp",
"cimgui/imgui/backends/imgui_impl_opengl3.cpp",
"cimgui/imgui/backends/imgui_impl_sdl.cpp",
"cimgui/cimgui.cpp",
};
var flags = std.ArrayList([]const u8).init(std.heap.page_allocator);
if (b.is_release) flags.append("-Os") catch unreachable;
imgui.addCSourceFiles(source_files[0..], flags.items[0..]);
exe.addIncludeDir("cimgui");
exe.addIncludeDir("cimgui/generator/output");
exe.linkLibrary(imgui);
} | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ines = @import("../ines.zig");
const console_ = @import("../console.zig");
const Config = console_.Config;
const Console = console_.Console;
const Cpu = @import("../cpu.zig").Cpu;
const Ppu = @import("../ppu.zig").Ppu;
const GenericMapper = @import("../mapper.zig").GenericMapper;
const common = @import("common.zig");
pub fn Mapper(comptime config: Config) type {
const G = GenericMapper(config);
return struct {
const Self = @This();
cpu: *Cpu(config),
ppu: *Ppu(config),
prg_ram: common.PrgRam,
prgs: common.BankSwitcher(0x2000, 4),
chrs: common.BankSwitcher(0x400, 8),
mirroring: ines.Mirroring,
prg_bank_mode: enum(u1) {
swap_8000 = 0,
swap_c000 = 1,
} = .swap_8000,
chr_bank_mode: enum(u1) {
/// Two 2kb followed by four 1kb banks
two_then_four = 0,
/// Four 1kb followed by two 2kb banks
four_then_two = 1,
} = .two_then_four,
bank_registers: [8]u8 = std.mem.zeroes([8]u8),
select_register: u3 = 0,
irq_enabled: bool = false,
irq_reload: bool = false,
irq_latch: u8 = 0,
irq_counter: u8 = 0,
ppu_a12_low_cycles: u2 = 0,
pub fn initMem(
self: *Self,
allocator: *Allocator,
console: *Console(config),
info: *ines.RomInfo,
) Allocator.Error!void {
std.debug.assert(info.prg_rom_mul_16kb >= 2);
self.* = Self{
.cpu = &console.cpu,
.ppu = &console.ppu,
.prg_ram = try common.PrgRam.init(allocator, true, info.has_sram),
.prgs = try common.BankSwitcher(0x2000, 4).init(allocator, info.prg_rom),
.chrs = try common.BankSwitcher(0x400, 8).init(allocator, info.chr_rom),
.mirroring = info.mirroring,
};
self.updatePrg();
self.updateChr();
}
pub fn deinitMem(generic: G, allocator: *Allocator) void {
const self = common.fromGeneric(Self, config, generic);
self.prg_ram.deinit(allocator);
self.prgs.deinit(allocator);
self.chrs.deinit(allocator);
allocator.destroy(self);
}
pub fn cpuCycled(generic: *G) void {
const self = common.fromGeneric(Self, config, generic.*);
// we're waiting for 3 cpu cycles where vram_addr & 0x1000 == 0
// and then a cycle where it goes high
if (self.ppu.mem.address_bus & 0x1000 == 0) {
self.ppu_a12_low_cycles +|= 1;
} else if (self.ppu_a12_low_cycles == 3) {
if (self.irq_counter == 0 or self.irq_reload) {
self.irq_counter = self.irq_latch;
self.irq_reload = false;
} else {
self.irq_counter -= 1;
}
if (self.irq_counter == 0 and self.irq_enabled) {
self.cpu.setIrqSource("mapper");
}
self.ppu_a12_low_cycles = 0;
}
}
pub fn mirrorNametable(generic: G, addr: u16) u12 {
const self = common.fromGeneric(Self, config, generic);
return common.mirrorNametable(self.mirroring, addr);
}
pub fn readPrg(generic: G, addr: u16) ?u8 {
const self = common.fromGeneric(Self, config, generic);
return switch (addr) {
0x4020...0x5fff => null,
0x6000...0x7fff => self.prg_ram.read(addr),
0x8000...0xffff => self.prgs.read(addr),
else => unreachable,
};
}
pub fn readChr(generic: G, addr: u16) u8 {
const self = common.fromGeneric(Self, config, generic);
return self.chrs.read(addr);
}
pub fn writePrg(generic: *G, addr: u16, val: u8) void {
const self = common.fromGeneric(Self, config, generic.*);
switch (addr) {
0x4020...0x5fff => {},
0x6000...0x7fff => self.prg_ram.write(addr, val),
0x8000...0xffff => self.writeRom(addr, val),
else => unreachable,
}
}
fn updatePrg(self: *Self) void {
self.prgs.setBank(1, self.bank_registers[7]);
self.prgs.setBank(3, self.prgs.bankCount() - 1);
switch (self.prg_bank_mode) {
.swap_8000 => {
self.prgs.setBank(0, self.bank_registers[6]);
self.prgs.setBank(2, self.prgs.bankCount() - 2);
},
.swap_c000 => {
self.prgs.setBank(0, self.prgs.bankCount() - 2);
self.prgs.setBank(2, self.bank_registers[6]);
},
}
}
fn updateChr(self: *Self) void {
switch (self.chr_bank_mode) {
.two_then_four => {
self.chrs.setConsecutiveBanks(0, 2, self.bank_registers[0]);
self.chrs.setConsecutiveBanks(2, 2, self.bank_registers[1]);
self.chrs.setBank(4, self.bank_registers[2]);
self.chrs.setBank(5, self.bank_registers[3]);
self.chrs.setBank(6, self.bank_registers[4]);
self.chrs.setBank(7, self.bank_registers[5]);
},
.four_then_two => {
self.chrs.setBank(0, self.bank_registers[2]);
self.chrs.setBank(1, self.bank_registers[3]);
self.chrs.setBank(2, self.bank_registers[4]);
self.chrs.setBank(3, self.bank_registers[5]);
self.chrs.setConsecutiveBanks(4, 2, self.bank_registers[0]);
self.chrs.setConsecutiveBanks(6, 2, self.bank_registers[1]);
},
}
}
fn writeRomEven(self: *Self, addr: u16, val: u8) void {
switch (addr) {
0x8000...0x9ffe => {
self.select_register = @truncate(u3, val);
self.prg_bank_mode = @intToEnum(@TypeOf(self.prg_bank_mode), @truncate(u1, val >> 6));
self.chr_bank_mode = @intToEnum(@TypeOf(self.chr_bank_mode), @truncate(u1, val >> 7));
self.updatePrg();
self.updateChr();
},
0xa000...0xbffe => if (self.mirroring != .four_screen) {
self.mirroring = @intToEnum(ines.Mirroring, ~@truncate(u1, val));
},
0xc000...0xdffe => self.irq_latch = val,
0xe000...0xfffe => {
self.irq_enabled = false;
self.cpu.clearIrqSource("mapper");
},
else => unreachable,
}
}
fn writeRomOdd(self: *Self, addr: u16, val: u8) void {
switch (addr) {
0x8001...0x9fff => {
const fixed_val = switch (self.select_register) {
0, 1 => val & 0xfe,
6, 7 => val & 0x3f,
else => val,
};
self.bank_registers[self.select_register] = fixed_val;
self.updateChr();
self.updatePrg();
},
0xa001...0xbfff => {
self.prg_ram.writable = val & 0x40 == 0;
self.prg_ram.enabled = val & 0x80 != 0;
},
0xc001...0xdfff => {
self.irq_reload = true;
self.irq_counter = 0;
},
0xe001...0xffff => self.irq_enabled = true,
else => unreachable,
}
}
fn writeRom(self: *Self, addr: u16, val: u8) void {
if (addr & 1 == 0) {
self.writeRomEven(addr, val);
} else {
self.writeRomOdd(addr, val);
}
}
pub fn writeChr(generic: *G, addr: u16, val: u8) void {
const self = common.fromGeneric(Self, config, generic.*);
self.chrs.write(addr, val);
}
};
} | src/mapper/mmc3.zig |
const kernel = @import("../../kernel.zig");
const x86_64 = @import("../x86_64.zig");
const log = kernel.log.scoped(.ACPI);
const TODO = kernel.TODO;
const Virtual = kernel.Virtual;
const Physical = kernel.Physical;
const Signature = enum(u32) {
APIC = @ptrCast(*const u32, "APIC").*,
FACP = @ptrCast(*const u32, "FACP").*,
HPET = @ptrCast(*const u32, "HPET").*,
MCFG = @ptrCast(*const u32, "MCFG").*,
WAET = @ptrCast(*const u32, "WAET").*,
};
/// ACPI initialization. We should have a page mapper ready before executing this function
pub fn init(rsdp_physical_address: kernel.Physical.Address) void {
var rsdp_physical_page = rsdp_physical_address;
log.debug("RSDP: 0x{x}", .{rsdp_physical_address.value});
rsdp_physical_page.page_align_backward();
kernel.address_space.map(rsdp_physical_page, rsdp_physical_page.to_higher_half_virtual_address(), kernel.Virtual.AddressSpace.Flags.empty());
const rsdp1 = rsdp_physical_address.access_higher_half(*align(1) RSDP1);
if (rsdp1.revision == 0) {
log.debug("First version", .{});
log.debug("RSDT: 0x{x}", .{rsdp1.RSDT_address});
const rsdt_physical_address = Physical.Address.new(rsdp1.RSDT_address);
var rsdt_physical_page = rsdt_physical_address;
rsdt_physical_page.page_align_backward();
kernel.address_space.map(rsdt_physical_page, rsdt_physical_page.to_higher_half_virtual_address(), kernel.Virtual.AddressSpace.Flags.empty());
log.debug("Mapped RSDT: 0x{x}", .{rsdt_physical_page.to_higher_half_virtual_address().value});
const rsdt = rsdt_physical_address.access_higher_half(*align(1) Header);
log.debug("RSDT length: {}", .{rsdt.length});
const rsdt_table_count = (rsdt.length - @sizeOf(Header)) / @sizeOf(u32);
log.debug("RSDT table count: {}", .{rsdt_table_count});
const tables = @intToPtr([*]align(1) u32, @ptrToInt(rsdt) + @sizeOf(Header))[0..rsdt_table_count];
for (tables) |table_address| {
log.debug("Table address: 0x{x}", .{table_address});
const table_physical_address = kernel.Physical.Address.new(table_address);
var table_physical_page = table_physical_address;
table_physical_page.page_align_backward();
kernel.address_space.map(table_physical_page, table_physical_page.to_higher_half_virtual_address(), kernel.Virtual.AddressSpace.Flags.empty());
const header = table_physical_address.access_higher_half(*align(1) Header);
switch (header.signature) {
.APIC => {
const madt = @ptrCast(*align(1) MADT, header);
log.debug("MADT: {}", .{madt});
log.debug("LAPIC address: 0x{x}", .{madt.LAPIC_address});
const madt_top = @ptrToInt(madt) + madt.header.length;
var offset = @ptrToInt(madt) + @sizeOf(MADT);
var processor_count: u64 = 0;
var iso_count: u64 = 0;
var entry_length: u64 = 0;
while (offset != madt_top) : (offset += entry_length) {
const entry_type = @intToPtr(*MADT.Type, offset).*;
entry_length = @intToPtr(*u8, offset + 1).*;
processor_count += @boolToInt(entry_type == .LAPIC);
iso_count += @boolToInt(entry_type == .ISO);
}
x86_64.iso = kernel.core_heap.allocate_many(x86_64.ISO, iso_count) orelse @panic("iso");
var iso_i: u64 = 0;
kernel.assert(@src(), processor_count == kernel.cpus.len);
offset = @ptrToInt(madt) + @sizeOf(MADT);
while (offset != madt_top) : (offset += entry_length) {
const entry_type = @intToPtr(*MADT.Type, offset).*;
entry_length = @intToPtr(*u8, offset + 1).*;
switch (entry_type) {
.LAPIC => {
const lapic = @intToPtr(*align(1) MADT.LAPIC, offset);
log.debug("LAPIC: {}", .{lapic});
kernel.assert(@src(), @sizeOf(MADT.LAPIC) == entry_length);
},
.IO_APIC => {
const ioapic = @intToPtr(*align(1) MADT.IO_APIC, offset);
log.debug("IO_APIC: {}", .{ioapic});
kernel.assert(@src(), @sizeOf(MADT.IO_APIC) == entry_length);
x86_64.ioapic.gsi = ioapic.global_system_interrupt_base;
x86_64.ioapic.address = kernel.Physical.Address.new(ioapic.IO_APIC_address);
kernel.address_space.map(x86_64.ioapic.address, x86_64.ioapic.address.to_higher_half_virtual_address(), kernel.Virtual.AddressSpace.Flags.from_flags(&.{ .read_write, .cache_disable }));
x86_64.ioapic.id = ioapic.IO_APIC_ID;
},
.ISO => {
const iso = @intToPtr(*align(1) MADT.InterruptSourceOverride, offset);
log.debug("ISO: {}", .{iso});
kernel.assert(@src(), @sizeOf(MADT.InterruptSourceOverride) == entry_length);
const iso_ptr = &x86_64.iso[iso_i];
iso_i += 1;
iso_ptr.gsi = iso.global_system_interrupt;
iso_ptr.source_IRQ = iso.source;
iso_ptr.active_low = iso.flags & 2 != 0;
iso_ptr.level_triggered = iso.flags & 8 != 0;
},
.LAPIC_NMI => {
const lapic_nmi = @intToPtr(*align(1) MADT.LAPIC_NMI, offset);
log.debug("LAPIC_NMI: {}", .{lapic_nmi});
kernel.assert(@src(), @sizeOf(MADT.LAPIC_NMI) == entry_length);
},
else => kernel.panic("ni: {}", .{entry_type}),
}
}
},
else => {
log.debug("Ignored table: {s}", .{@tagName(header.signature)});
},
}
}
} else {
kernel.assert(@src(), rsdp1.revision == 2);
//const rsdp2 = @ptrCast(*RSDP2, rsdp1);
log.debug("Second version", .{});
TODO(@src());
}
}
const rsdt_signature = [4]u8{ 'R', 'S', 'D', 'T' };
pub fn check_valid_sdt(rsdt: *align(1) Header) void {
log.debug("Header size: {}", .{@sizeOf(Header)});
kernel.assert(@src(), @sizeOf(Header) == 36);
if (rsdt.revision != 1) {
@panic("bad revision");
}
if (!kernel.string_eq(&rsdt.signature, &rsdt_signature)) {
@panic("bad signature");
}
if (rsdt.length >= 16384) {
@panic("bad length");
}
if (checksum(@ptrCast([*]u8, rsdt)[0..rsdt.length]) != 0) {
@panic("bad checksum");
}
}
fn checksum(slice: []const u8) u8 {
if (slice.len == 0) return 0;
var total: u64 = 0;
for (slice) |byte| {
total += byte;
}
return @truncate(u8, total);
}
const RSDP1 = extern struct {
signature: [8]u8,
checksum: u8,
OEM_ID: [6]u8,
revision: u8,
RSDT_address: u32,
comptime {
kernel.assert_unsafe(@sizeOf(RSDP1) == 20);
}
};
const RSDP2 = packed struct {
rsdp1: RSDP1,
length: u32,
XSDT_address: u64,
extended_checksum: u8,
reserved: [3]u8,
};
const Header = extern struct {
signature: Signature,
length: u32,
revision: u8,
checksum: u8,
OEM_ID: [6]u8,
OEM_table_ID: [8]u8,
OEM_revision: u32,
creator_ID: u32,
creator_revision: u32,
comptime {
kernel.assert_unsafe(@sizeOf(Header) == 36);
}
};
const MADT = extern struct {
header: Header,
LAPIC_address: u32,
flags: u32,
const Type = enum(u8) {
LAPIC = 0,
IO_APIC = 1,
ISO = 2,
NMI_source = 3,
LAPIC_NMI = 4,
LAPIC_address_override = 5,
IO_SAPIC = 6,
LSAPIC = 7,
platform_interrupt_sources = 8,
Lx2APIC = 9,
Lx2APIC_NMI = 0xa,
GIC_CPU_interface = 0xb,
GIC_distributor = 0xc,
GIC_MSI_frame = 0xd,
GIC_redistributor = 0xe,
GIC_interrupt_translation_service = 0xf,
};
const LAPIC = struct {
type: Type,
length: u8,
ACPI_processor_UID: u8,
APIC_ID: u8,
flags: u32,
};
const IO_APIC = struct {
type: Type,
length: u8,
IO_APIC_ID: u8,
reserved: u8,
IO_APIC_address: u32,
global_system_interrupt_base: u32,
};
const InterruptSourceOverride = packed struct {
type: Type,
length: u8,
bus: u8,
source: u8,
global_system_interrupt: u32,
flags: u16,
};
const LAPIC_NMI = packed struct {
type: Type,
length: u8,
ACPI_processor_UID: u8,
flags: u16,
LAPIC_lint: u8,
};
};
const MCFG = packed struct {
header: Header,
reserved: u64,
fn get_configurations(mcfg: *align(1) MCFG) []Configuration {
const entry_count = (mcfg.header.length - @sizeOf(MCFG)) / @sizeOf(Configuration);
const configuration_base = @ptrToInt(mcfg) + @sizeOf(MCFG);
return @intToPtr([*]Configuration, configuration_base)[0..entry_count];
}
comptime {
kernel.assert_unsafe(@sizeOf(MCFG) == @sizeOf(Header) + @sizeOf(u64));
kernel.assert_unsafe(@sizeOf(Configuration) == 0x10);
}
const Configuration = packed struct {
base_address: u64,
segment_group_number: u16,
start_bus: u8,
end_bus: u8,
reserved: u32,
};
}; | src/kernel/arch/x86_64/acpi.zig |
pub const SHORT_PACKET_TERMINATE = @as(u32, 1);
pub const AUTO_CLEAR_STALL = @as(u32, 2);
pub const PIPE_TRANSFER_TIMEOUT = @as(u32, 3);
pub const IGNORE_SHORT_PACKETS = @as(u32, 4);
pub const ALLOW_PARTIAL_READS = @as(u32, 5);
pub const AUTO_FLUSH = @as(u32, 6);
pub const RAW_IO = @as(u32, 7);
pub const MAXIMUM_TRANSFER_SIZE = @as(u32, 8);
pub const RESET_PIPE_ON_RESUME = @as(u32, 9);
pub const AUTO_SUSPEND = @as(u32, 129);
pub const SUSPEND_DELAY = @as(u32, 131);
pub const DEVICE_SPEED = @as(u32, 1);
pub const LowSpeed = @as(u32, 1);
pub const FullSpeed = @as(u32, 2);
pub const HighSpeed = @as(u32, 3);
pub const IOCTL_GENERICUSBFN_TRANSFER_IN = @as(u32, 2277389);
pub const IOCTL_GENERICUSBFN_TRANSFER_IN_APPEND_ZERO_PKT = @as(u32, 2277393);
pub const IOCTL_GENERICUSBFN_TRANSFER_OUT = @as(u32, 2277398);
pub const IOCTL_GENERICUSBFN_CONTROL_STATUS_HANDSHAKE_IN = @as(u32, 2277400);
pub const IOCTL_GENERICUSBFN_CONTROL_STATUS_HANDSHAKE_OUT = @as(u32, 2277404);
pub const IOCTL_GENERICUSBFN_GET_CLASS_INFO = @as(u32, 2277410);
pub const IOCTL_GENERICUSBFN_GET_PIPE_STATE = @as(u32, 2277414);
pub const IOCTL_GENERICUSBFN_SET_PIPE_STATE = @as(u32, 2277417);
pub const IOCTL_GENERICUSBFN_ACTIVATE_USB_BUS = @as(u32, 2277420);
pub const IOCTL_GENERICUSBFN_DEACTIVATE_USB_BUS = @as(u32, 2277424);
pub const IOCTL_GENERICUSBFN_BUS_EVENT_NOTIFICATION = @as(u32, 2277430);
pub const IOCTL_GENERICUSBFN_GET_CLASS_INFO_EX = @as(u32, 2277434);
pub const IOCTL_GENERICUSBFN_GET_INTERFACE_DESCRIPTOR_SET = @as(u32, 2277438);
pub const IOCTL_GENERICUSBFN_REGISTER_USB_STRING = @as(u32, 2277441);
pub const USBUSER_VERSION = @as(u32, 4);
pub const USBUSER_GET_CONTROLLER_INFO_0 = @as(u32, 1);
pub const USBUSER_GET_CONTROLLER_DRIVER_KEY = @as(u32, 2);
pub const USBUSER_PASS_THRU = @as(u32, 3);
pub const USBUSER_GET_POWER_STATE_MAP = @as(u32, 4);
pub const USBUSER_GET_BANDWIDTH_INFORMATION = @as(u32, 5);
pub const USBUSER_GET_BUS_STATISTICS_0 = @as(u32, 6);
pub const USBUSER_GET_ROOTHUB_SYMBOLIC_NAME = @as(u32, 7);
pub const USBUSER_GET_USB_DRIVER_VERSION = @as(u32, 8);
pub const USBUSER_GET_USB2_HW_VERSION = @as(u32, 9);
pub const USBUSER_USB_REFRESH_HCT_REG = @as(u32, 10);
pub const USBUSER_OP_SEND_ONE_PACKET = @as(u32, 268435457);
pub const USBUSER_OP_RAW_RESET_PORT = @as(u32, 536870913);
pub const USBUSER_OP_OPEN_RAW_DEVICE = @as(u32, 536870914);
pub const USBUSER_OP_CLOSE_RAW_DEVICE = @as(u32, 536870915);
pub const USBUSER_OP_SEND_RAW_COMMAND = @as(u32, 536870916);
pub const USBUSER_SET_ROOTPORT_FEATURE = @as(u32, 536870917);
pub const USBUSER_CLEAR_ROOTPORT_FEATURE = @as(u32, 536870918);
pub const USBUSER_GET_ROOTPORT_STATUS = @as(u32, 536870919);
pub const USBUSER_INVALID_REQUEST = @as(u32, 4294967280);
pub const USBUSER_OP_MASK_DEVONLY_API = @as(u32, 268435456);
pub const USBUSER_OP_MASK_HCTEST_API = @as(u32, 536870912);
pub const USB_PACKETFLAG_LOW_SPEED = @as(u32, 1);
pub const USB_PACKETFLAG_FULL_SPEED = @as(u32, 2);
pub const USB_PACKETFLAG_HIGH_SPEED = @as(u32, 4);
pub const USB_PACKETFLAG_ASYNC_IN = @as(u32, 8);
pub const USB_PACKETFLAG_ASYNC_OUT = @as(u32, 16);
pub const USB_PACKETFLAG_ISO_IN = @as(u32, 32);
pub const USB_PACKETFLAG_ISO_OUT = @as(u32, 64);
pub const USB_PACKETFLAG_SETUP = @as(u32, 128);
pub const USB_PACKETFLAG_TOGGLE0 = @as(u32, 256);
pub const USB_PACKETFLAG_TOGGLE1 = @as(u32, 512);
pub const USB_HC_FEATURE_FLAG_PORT_POWER_SWITCHING = @as(u32, 1);
pub const USB_HC_FEATURE_FLAG_SEL_SUSPEND = @as(u32, 2);
pub const USB_HC_FEATURE_LEGACY_BIOS = @as(u32, 4);
pub const USB_HC_FEATURE_TIME_SYNC_API = @as(u32, 8);
pub const USB_SUBMIT_URB = @as(u32, 0);
pub const USB_RESET_PORT = @as(u32, 1);
pub const USB_GET_ROOTHUB_PDO = @as(u32, 3);
pub const USB_GET_PORT_STATUS = @as(u32, 4);
pub const USB_ENABLE_PORT = @as(u32, 5);
pub const USB_GET_HUB_COUNT = @as(u32, 6);
pub const USB_CYCLE_PORT = @as(u32, 7);
pub const USB_GET_HUB_NAME = @as(u32, 8);
pub const USB_IDLE_NOTIFICATION = @as(u32, 9);
pub const USB_RECORD_FAILURE = @as(u32, 10);
pub const USB_GET_BUS_INFO = @as(u32, 264);
pub const USB_GET_CONTROLLER_NAME = @as(u32, 265);
pub const USB_GET_BUSGUID_INFO = @as(u32, 266);
pub const USB_GET_PARENT_HUB_INFO = @as(u32, 267);
pub const USB_GET_DEVICE_HANDLE = @as(u32, 268);
pub const USB_GET_DEVICE_HANDLE_EX = @as(u32, 269);
pub const USB_GET_TT_DEVICE_HANDLE = @as(u32, 270);
pub const USB_GET_TOPOLOGY_ADDRESS = @as(u32, 271);
pub const USB_IDLE_NOTIFICATION_EX = @as(u32, 272);
pub const USB_REQ_GLOBAL_SUSPEND = @as(u32, 273);
pub const USB_REQ_GLOBAL_RESUME = @as(u32, 274);
pub const USB_GET_HUB_CONFIG_INFO = @as(u32, 275);
pub const USB_FAIL_GET_STATUS = @as(u32, 280);
pub const USB_REGISTER_COMPOSITE_DEVICE = @as(u32, 0);
pub const USB_UNREGISTER_COMPOSITE_DEVICE = @as(u32, 1);
pub const USB_REQUEST_REMOTE_WAKE_NOTIFICATION = @as(u32, 2);
pub const HCD_GET_STATS_1 = @as(u32, 255);
pub const HCD_DIAGNOSTIC_MODE_ON = @as(u32, 256);
pub const HCD_DIAGNOSTIC_MODE_OFF = @as(u32, 257);
pub const HCD_GET_ROOT_HUB_NAME = @as(u32, 258);
pub const HCD_GET_DRIVERKEY_NAME = @as(u32, 265);
pub const HCD_GET_STATS_2 = @as(u32, 266);
pub const HCD_DISABLE_PORT = @as(u32, 268);
pub const HCD_ENABLE_PORT = @as(u32, 269);
pub const HCD_USER_REQUEST = @as(u32, 270);
pub const HCD_TRACE_READ_REQUEST = @as(u32, 275);
pub const USB_GET_NODE_INFORMATION = @as(u32, 258);
pub const USB_GET_NODE_CONNECTION_INFORMATION = @as(u32, 259);
pub const USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION = @as(u32, 260);
pub const USB_GET_NODE_CONNECTION_NAME = @as(u32, 261);
pub const USB_DIAG_IGNORE_HUBS_ON = @as(u32, 262);
pub const USB_DIAG_IGNORE_HUBS_OFF = @as(u32, 263);
pub const USB_GET_NODE_CONNECTION_DRIVERKEY_NAME = @as(u32, 264);
pub const USB_GET_HUB_CAPABILITIES = @as(u32, 271);
pub const USB_GET_NODE_CONNECTION_ATTRIBUTES = @as(u32, 272);
pub const USB_HUB_CYCLE_PORT = @as(u32, 273);
pub const USB_GET_NODE_CONNECTION_INFORMATION_EX = @as(u32, 274);
pub const USB_RESET_HUB = @as(u32, 275);
pub const USB_GET_HUB_CAPABILITIES_EX = @as(u32, 276);
pub const USB_GET_HUB_INFORMATION_EX = @as(u32, 277);
pub const USB_GET_PORT_CONNECTOR_PROPERTIES = @as(u32, 278);
pub const USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 = @as(u32, 279);
pub const USB_GET_TRANSPORT_CHARACTERISTICS = @as(u32, 281);
pub const USB_REGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 282);
pub const USB_NOTIFY_ON_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 283);
pub const USB_UNREGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 284);
pub const USB_START_TRACKING_FOR_TIME_SYNC = @as(u32, 285);
pub const USB_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC = @as(u32, 286);
pub const USB_STOP_TRACKING_FOR_TIME_SYNC = @as(u32, 287);
pub const USB_GET_DEVICE_CHARACTERISTICS = @as(u32, 288);
pub const GUID_DEVINTERFACE_USB_HUB = Guid.initString("f18a0e88-c30c-11d0-8815-00a0c906bed8");
pub const GUID_DEVINTERFACE_USB_BILLBOARD = Guid.initString("5e9adaef-f879-473f-b807-4e5ea77d1b1c");
pub const GUID_DEVINTERFACE_USB_DEVICE = Guid.initString("a5dcbf10-6530-11d2-901f-00c04fb951ed");
pub const GUID_DEVINTERFACE_USB_HOST_CONTROLLER = Guid.initString("3abf6f2d-71c4-462a-8a92-1e6861e6af27");
pub const GUID_USB_WMI_STD_DATA = Guid.initString("4e623b20-cb14-11d1-b331-00a0c959bbd2");
pub const GUID_USB_WMI_STD_NOTIFICATION = Guid.initString("4e623b20-cb14-11d1-b331-00a0c959bbd2");
pub const GUID_USB_WMI_DEVICE_PERF_INFO = Guid.initString("66c1aa3c-499f-49a0-a9a5-61e2359f6407");
pub const GUID_USB_WMI_NODE_INFO = Guid.initString("9c179357-dc7a-4f41-b66b-323b9ddcb5b1");
pub const GUID_USB_WMI_TRACING = Guid.initString("3a61881b-b4e6-4bf9-ae0f-3cd8f394e52f");
pub const GUID_USB_TRANSFER_TRACING = Guid.initString("681eb8aa-403d-452c-9f8a-f0616fac9540");
pub const GUID_USB_PERFORMANCE_TRACING = Guid.initString("d5de77a6-6ae9-425c-b1e2-f5615fd348a9");
pub const GUID_USB_WMI_SURPRISE_REMOVAL_NOTIFICATION = Guid.initString("9bbbf831-a2f2-43b4-96d1-86944b5914b3");
pub const FILE_DEVICE_USB = @as(u32, 34);
pub const BMREQUEST_HOST_TO_DEVICE = @as(u32, 0);
pub const BMREQUEST_DEVICE_TO_HOST = @as(u32, 1);
pub const BMREQUEST_STANDARD = @as(u32, 0);
pub const BMREQUEST_CLASS = @as(u32, 1);
pub const BMREQUEST_VENDOR = @as(u32, 2);
pub const BMREQUEST_TO_DEVICE = @as(u32, 0);
pub const BMREQUEST_TO_INTERFACE = @as(u32, 1);
pub const BMREQUEST_TO_ENDPOINT = @as(u32, 2);
pub const BMREQUEST_TO_OTHER = @as(u32, 3);
pub const USB_REQUEST_GET_STATUS = @as(u32, 0);
pub const USB_REQUEST_CLEAR_FEATURE = @as(u32, 1);
pub const USB_REQUEST_SET_FEATURE = @as(u32, 3);
pub const USB_REQUEST_SET_ADDRESS = @as(u32, 5);
pub const USB_REQUEST_GET_DESCRIPTOR = @as(u32, 6);
pub const USB_REQUEST_SET_DESCRIPTOR = @as(u32, 7);
pub const USB_REQUEST_GET_CONFIGURATION = @as(u32, 8);
pub const USB_REQUEST_SET_CONFIGURATION = @as(u32, 9);
pub const USB_REQUEST_GET_INTERFACE = @as(u32, 10);
pub const USB_REQUEST_SET_INTERFACE = @as(u32, 11);
pub const USB_REQUEST_SYNC_FRAME = @as(u32, 12);
pub const USB_REQUEST_GET_FIRMWARE_STATUS = @as(u32, 26);
pub const USB_REQUEST_SET_FIRMWARE_STATUS = @as(u32, 27);
pub const USB_GET_FIRMWARE_ALLOWED_OR_DISALLOWED_STATE = @as(u32, 0);
pub const USB_GET_FIRMWARE_HASH = @as(u32, 1);
pub const USB_DEVICE_FIRMWARE_HASH_LENGTH = @as(u32, 32);
pub const USB_DISALLOW_FIRMWARE_UPDATE = @as(u32, 0);
pub const USB_ALLOW_FIRMWARE_UPDATE = @as(u32, 1);
pub const USB_REQUEST_SET_SEL = @as(u32, 48);
pub const USB_REQUEST_ISOCH_DELAY = @as(u32, 49);
pub const USB_DEVICE_DESCRIPTOR_TYPE = @as(u32, 1);
pub const USB_CONFIGURATION_DESCRIPTOR_TYPE = @as(u32, 2);
pub const USB_STRING_DESCRIPTOR_TYPE = @as(u32, 3);
pub const USB_INTERFACE_DESCRIPTOR_TYPE = @as(u32, 4);
pub const USB_ENDPOINT_DESCRIPTOR_TYPE = @as(u32, 5);
pub const USB_DEVICE_QUALIFIER_DESCRIPTOR_TYPE = @as(u32, 6);
pub const USB_OTHER_SPEED_CONFIGURATION_DESCRIPTOR_TYPE = @as(u32, 7);
pub const USB_INTERFACE_POWER_DESCRIPTOR_TYPE = @as(u32, 8);
pub const USB_OTG_DESCRIPTOR_TYPE = @as(u32, 9);
pub const USB_DEBUG_DESCRIPTOR_TYPE = @as(u32, 10);
pub const USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE = @as(u32, 11);
pub const USB_BOS_DESCRIPTOR_TYPE = @as(u32, 15);
pub const USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE = @as(u32, 16);
pub const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR_TYPE = @as(u32, 48);
pub const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR_TYPE = @as(u32, 49);
pub const USB_RESERVED_DESCRIPTOR_TYPE = @as(u32, 6);
pub const USB_CONFIG_POWER_DESCRIPTOR_TYPE = @as(u32, 7);
pub const USB_FEATURE_ENDPOINT_STALL = @as(u32, 0);
pub const USB_FEATURE_REMOTE_WAKEUP = @as(u32, 1);
pub const USB_FEATURE_TEST_MODE = @as(u32, 2);
pub const USB_FEATURE_FUNCTION_SUSPEND = @as(u32, 0);
pub const USB_FEATURE_U1_ENABLE = @as(u32, 48);
pub const USB_FEATURE_U2_ENABLE = @as(u32, 49);
pub const USB_FEATURE_LTM_ENABLE = @as(u32, 50);
pub const USB_FEATURE_LDM_ENABLE = @as(u32, 53);
pub const USB_FEATURE_BATTERY_WAKE_MASK = @as(u32, 40);
pub const USB_FEATURE_OS_IS_PD_AWARE = @as(u32, 41);
pub const USB_FEATURE_POLICY_MODE = @as(u32, 42);
pub const USB_FEATURE_CHARGING_POLICY = @as(u32, 54);
pub const USB_CHARGING_POLICY_DEFAULT = @as(u32, 0);
pub const USB_CHARGING_POLICY_ICCHPF = @as(u32, 1);
pub const USB_CHARGING_POLICY_ICCLPF = @as(u32, 2);
pub const USB_CHARGING_POLICY_NO_POWER = @as(u32, 3);
pub const USB_STATUS_PORT_STATUS = @as(u32, 0);
pub const USB_STATUS_PD_STATUS = @as(u32, 1);
pub const USB_STATUS_EXT_PORT_STATUS = @as(u32, 2);
pub const USB_GETSTATUS_SELF_POWERED = @as(u32, 1);
pub const USB_GETSTATUS_REMOTE_WAKEUP_ENABLED = @as(u32, 2);
pub const USB_GETSTATUS_U1_ENABLE = @as(u32, 4);
pub const USB_GETSTATUS_U2_ENABLE = @as(u32, 8);
pub const USB_GETSTATUS_LTM_ENABLE = @as(u32, 16);
pub const USB_DEVICE_CLASS_RESERVED = @as(u32, 0);
pub const USB_DEVICE_CLASS_AUDIO = @as(u32, 1);
pub const USB_DEVICE_CLASS_COMMUNICATIONS = @as(u32, 2);
pub const USB_DEVICE_CLASS_HUMAN_INTERFACE = @as(u32, 3);
pub const USB_DEVICE_CLASS_MONITOR = @as(u32, 4);
pub const USB_DEVICE_CLASS_PHYSICAL_INTERFACE = @as(u32, 5);
pub const USB_DEVICE_CLASS_POWER = @as(u32, 6);
pub const USB_DEVICE_CLASS_IMAGE = @as(u32, 6);
pub const USB_DEVICE_CLASS_PRINTER = @as(u32, 7);
pub const USB_DEVICE_CLASS_STORAGE = @as(u32, 8);
pub const USB_DEVICE_CLASS_HUB = @as(u32, 9);
pub const USB_DEVICE_CLASS_CDC_DATA = @as(u32, 10);
pub const USB_DEVICE_CLASS_SMART_CARD = @as(u32, 11);
pub const USB_DEVICE_CLASS_CONTENT_SECURITY = @as(u32, 13);
pub const USB_DEVICE_CLASS_VIDEO = @as(u32, 14);
pub const USB_DEVICE_CLASS_PERSONAL_HEALTHCARE = @as(u32, 15);
pub const USB_DEVICE_CLASS_AUDIO_VIDEO = @as(u32, 16);
pub const USB_DEVICE_CLASS_BILLBOARD = @as(u32, 17);
pub const USB_DEVICE_CLASS_DIAGNOSTIC_DEVICE = @as(u32, 220);
pub const USB_DEVICE_CLASS_WIRELESS_CONTROLLER = @as(u32, 224);
pub const USB_DEVICE_CLASS_MISCELLANEOUS = @as(u32, 239);
pub const USB_DEVICE_CLASS_APPLICATION_SPECIFIC = @as(u32, 254);
pub const USB_DEVICE_CLASS_VENDOR_SPECIFIC = @as(u32, 255);
pub const USB_DEVICE_CAPABILITY_WIRELESS_USB = @as(u32, 1);
pub const USB_DEVICE_CAPABILITY_USB20_EXTENSION = @as(u32, 2);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_USB = @as(u32, 3);
pub const USB_DEVICE_CAPABILITY_CONTAINER_ID = @as(u32, 4);
pub const USB_DEVICE_CAPABILITY_PLATFORM = @as(u32, 5);
pub const USB_DEVICE_CAPABILITY_POWER_DELIVERY = @as(u32, 6);
pub const USB_DEVICE_CAPABILITY_BATTERY_INFO = @as(u32, 7);
pub const USB_DEVICE_CAPABILITY_PD_CONSUMER_PORT = @as(u32, 8);
pub const USB_DEVICE_CAPABILITY_PD_PROVIDER_PORT = @as(u32, 9);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB = @as(u32, 10);
pub const USB_DEVICE_CAPABILITY_PRECISION_TIME_MEASUREMENT = @as(u32, 11);
pub const USB_DEVICE_CAPABILITY_BILLBOARD = @as(u32, 13);
pub const USB_DEVICE_CAPABILITY_FIRMWARE_STATUS = @as(u32, 17);
pub const USB_DEVICE_CAPABILITY_USB20_EXTENSION_BMATTRIBUTES_RESERVED_MASK = @as(u32, 4294901985);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_RESERVED_MASK = @as(u32, 253);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_BMATTRIBUTES_LTM_CAPABLE = @as(u32, 2);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_RESERVED_MASK = @as(u32, 65520);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_LOW = @as(u32, 1);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_FULL = @as(u32, 2);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_HIGH = @as(u32, 4);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_SPEEDS_SUPPORTED_SUPER = @as(u32, 8);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_U1_DEVICE_EXIT_MAX_VALUE = @as(u32, 10);
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_U2_DEVICE_EXIT_MAX_VALUE = @as(u32, 2047);
pub const USB_DEVICE_CAPABILITY_MAX_U1_LATENCY = @as(u32, 10);
pub const USB_DEVICE_CAPABILITY_MAX_U2_LATENCY = @as(u32, 2047);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_BPS = @as(u32, 0);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_KBPS = @as(u32, 1);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_MBPS = @as(u32, 2);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_LSE_GBPS = @as(u32, 3);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_SYMMETRIC = @as(u32, 0);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_MODE_ASYMMETRIC = @as(u32, 1);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_RX = @as(u32, 0);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_DIR_TX = @as(u32, 1);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_PROTOCOL_SS = @as(u32, 0);
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED_PROTOCOL_SSP = @as(u32, 1);
pub const GUID_USB_MSOS20_PLATFORM_CAPABILITY_ID = Guid.initString("d8dd60df-4589-4cc7-9cd2-659d9e648a9f");
pub const USB_CONFIG_POWERED_MASK = @as(u32, 192);
pub const USB_CONFIG_BUS_POWERED = @as(u32, 128);
pub const USB_CONFIG_SELF_POWERED = @as(u32, 64);
pub const USB_CONFIG_REMOTE_WAKEUP = @as(u32, 32);
pub const USB_CONFIG_RESERVED = @as(u32, 31);
pub const USB_ENDPOINT_DIRECTION_MASK = @as(u32, 128);
pub const USB_ENDPOINT_ADDRESS_MASK = @as(u32, 15);
pub const USB_ENDPOINT_TYPE_MASK = @as(u32, 3);
pub const USB_ENDPOINT_TYPE_CONTROL = @as(u32, 0);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS = @as(u32, 1);
pub const USB_ENDPOINT_TYPE_BULK = @as(u32, 2);
pub const USB_ENDPOINT_TYPE_INTERRUPT = @as(u32, 3);
pub const USB_ENDPOINT_TYPE_BULK_RESERVED_MASK = @as(u32, 252);
pub const USB_ENDPOINT_TYPE_CONTROL_RESERVED_MASK = @as(u32, 252);
pub const USB_20_ENDPOINT_TYPE_INTERRUPT_RESERVED_MASK = @as(u32, 252);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_RESERVED_MASK = @as(u32, 204);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_RESERVED_MASK = @as(u32, 192);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_MASK = @as(u32, 48);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_PERIODIC = @as(u32, 0);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_NOTIFICATION = @as(u32, 16);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_RESERVED10 = @as(u32, 32);
pub const USB_30_ENDPOINT_TYPE_INTERRUPT_USAGE_RESERVED11 = @as(u32, 48);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_MASK = @as(u32, 12);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_NO_SYNCHRONIZATION = @as(u32, 0);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_ASYNCHRONOUS = @as(u32, 4);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_ADAPTIVE = @as(u32, 8);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_SYNCHRONIZATION_SYNCHRONOUS = @as(u32, 12);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_MASK = @as(u32, 48);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_DATA_ENDOINT = @as(u32, 0);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_FEEDBACK_ENDPOINT = @as(u32, 16);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_IMPLICIT_FEEDBACK_DATA_ENDPOINT = @as(u32, 32);
pub const USB_ENDPOINT_TYPE_ISOCHRONOUS_USAGE_RESERVED = @as(u32, 48);
pub const USB_ENDPOINT_SUPERSPEED_BULK_MAX_PACKET_SIZE = @as(u32, 1024);
pub const USB_ENDPOINT_SUPERSPEED_CONTROL_MAX_PACKET_SIZE = @as(u32, 512);
pub const USB_ENDPOINT_SUPERSPEED_ISO_MAX_PACKET_SIZE = @as(u32, 1024);
pub const USB_ENDPOINT_SUPERSPEED_INTERRUPT_MAX_PACKET_SIZE = @as(u32, 1024);
pub const MAXIMUM_USB_STRING_LENGTH = @as(u32, 255);
pub const USB_SUPERSPEED_ISOCHRONOUS_MAX_MULTIPLIER = @as(u32, 2);
pub const USB_SUPERSPEEDPLUS_ISOCHRONOUS_MIN_BYTESPERINTERVAL = @as(u32, 49153);
pub const USB_SUPERSPEEDPLUS_ISOCHRONOUS_MAX_BYTESPERINTERVAL = @as(u32, 16777215);
pub const USB_20_HUB_DESCRIPTOR_TYPE = @as(u32, 41);
pub const USB_30_HUB_DESCRIPTOR_TYPE = @as(u32, 42);
pub const USB_REQUEST_GET_STATE = @as(u32, 2);
pub const USB_REQUEST_CLEAR_TT_BUFFER = @as(u32, 8);
pub const USB_REQUEST_RESET_TT = @as(u32, 9);
pub const USB_REQUEST_GET_TT_STATE = @as(u32, 10);
pub const USB_REQUEST_STOP_TT = @as(u32, 11);
pub const USB_REQUEST_SET_HUB_DEPTH = @as(u32, 12);
pub const USB_REQUEST_GET_PORT_ERR_COUNT = @as(u32, 13);
pub const USB_PORT_STATUS_CONNECT = @as(u32, 1);
pub const USB_PORT_STATUS_ENABLE = @as(u32, 2);
pub const USB_PORT_STATUS_SUSPEND = @as(u32, 4);
pub const USB_PORT_STATUS_OVER_CURRENT = @as(u32, 8);
pub const USB_PORT_STATUS_RESET = @as(u32, 16);
pub const USB_PORT_STATUS_POWER = @as(u32, 256);
pub const USB_PORT_STATUS_LOW_SPEED = @as(u32, 512);
pub const USB_PORT_STATUS_HIGH_SPEED = @as(u32, 1024);
pub const PORT_LINK_STATE_U0 = @as(u32, 0);
pub const PORT_LINK_STATE_U1 = @as(u32, 1);
pub const PORT_LINK_STATE_U2 = @as(u32, 2);
pub const PORT_LINK_STATE_U3 = @as(u32, 3);
pub const PORT_LINK_STATE_DISABLED = @as(u32, 4);
pub const PORT_LINK_STATE_RX_DETECT = @as(u32, 5);
pub const PORT_LINK_STATE_INACTIVE = @as(u32, 6);
pub const PORT_LINK_STATE_POLLING = @as(u32, 7);
pub const PORT_LINK_STATE_RECOVERY = @as(u32, 8);
pub const PORT_LINK_STATE_HOT_RESET = @as(u32, 9);
pub const PORT_LINK_STATE_COMPLIANCE_MODE = @as(u32, 10);
pub const PORT_LINK_STATE_LOOPBACK = @as(u32, 11);
pub const PORT_LINK_STATE_TEST_MODE = @as(u32, 11);
pub const USB_FEATURE_INTERFACE_POWER_D0 = @as(u32, 2);
pub const USB_FEATURE_INTERFACE_POWER_D1 = @as(u32, 3);
pub const USB_FEATURE_INTERFACE_POWER_D2 = @as(u32, 4);
pub const USB_FEATURE_INTERFACE_POWER_D3 = @as(u32, 5);
pub const USB_SUPPORT_D0_COMMAND = @as(u32, 1);
pub const USB_SUPPORT_D1_COMMAND = @as(u32, 2);
pub const USB_SUPPORT_D2_COMMAND = @as(u32, 4);
pub const USB_SUPPORT_D3_COMMAND = @as(u32, 8);
pub const USB_SUPPORT_D1_WAKEUP = @as(u32, 16);
pub const USB_SUPPORT_D2_WAKEUP = @as(u32, 32);
pub const USBDI_VERSION = @as(u32, 1536);
pub const USB_PORTATTR_NO_CONNECTOR = @as(u32, 1);
pub const USB_PORTATTR_SHARED_USB2 = @as(u32, 2);
pub const USB_PORTATTR_MINI_CONNECTOR = @as(u32, 4);
pub const USB_PORTATTR_OEM_CONNECTOR = @as(u32, 8);
pub const USB_PORTATTR_OWNED_BY_CC = @as(u32, 16777216);
pub const USB_PORTATTR_NO_OVERCURRENT_UI = @as(u32, 33554432);
pub const USB_DEFAULT_DEVICE_ADDRESS = @as(u32, 0);
pub const USB_DEFAULT_ENDPOINT_ADDRESS = @as(u32, 0);
pub const USB_DEFAULT_MAX_PACKET = @as(u32, 64);
pub const URB_FUNCTION_SELECT_CONFIGURATION = @as(u32, 0);
pub const URB_FUNCTION_SELECT_INTERFACE = @as(u32, 1);
pub const URB_FUNCTION_ABORT_PIPE = @as(u32, 2);
pub const URB_FUNCTION_TAKE_FRAME_LENGTH_CONTROL = @as(u32, 3);
pub const URB_FUNCTION_RELEASE_FRAME_LENGTH_CONTROL = @as(u32, 4);
pub const URB_FUNCTION_GET_FRAME_LENGTH = @as(u32, 5);
pub const URB_FUNCTION_SET_FRAME_LENGTH = @as(u32, 6);
pub const URB_FUNCTION_GET_CURRENT_FRAME_NUMBER = @as(u32, 7);
pub const URB_FUNCTION_CONTROL_TRANSFER = @as(u32, 8);
pub const URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER = @as(u32, 9);
pub const URB_FUNCTION_ISOCH_TRANSFER = @as(u32, 10);
pub const URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE = @as(u32, 11);
pub const URB_FUNCTION_SET_DESCRIPTOR_TO_DEVICE = @as(u32, 12);
pub const URB_FUNCTION_SET_FEATURE_TO_DEVICE = @as(u32, 13);
pub const URB_FUNCTION_SET_FEATURE_TO_INTERFACE = @as(u32, 14);
pub const URB_FUNCTION_SET_FEATURE_TO_ENDPOINT = @as(u32, 15);
pub const URB_FUNCTION_CLEAR_FEATURE_TO_DEVICE = @as(u32, 16);
pub const URB_FUNCTION_CLEAR_FEATURE_TO_INTERFACE = @as(u32, 17);
pub const URB_FUNCTION_CLEAR_FEATURE_TO_ENDPOINT = @as(u32, 18);
pub const URB_FUNCTION_GET_STATUS_FROM_DEVICE = @as(u32, 19);
pub const URB_FUNCTION_GET_STATUS_FROM_INTERFACE = @as(u32, 20);
pub const URB_FUNCTION_GET_STATUS_FROM_ENDPOINT = @as(u32, 21);
pub const URB_FUNCTION_RESERVED_0X0016 = @as(u32, 22);
pub const URB_FUNCTION_VENDOR_DEVICE = @as(u32, 23);
pub const URB_FUNCTION_VENDOR_INTERFACE = @as(u32, 24);
pub const URB_FUNCTION_VENDOR_ENDPOINT = @as(u32, 25);
pub const URB_FUNCTION_CLASS_DEVICE = @as(u32, 26);
pub const URB_FUNCTION_CLASS_INTERFACE = @as(u32, 27);
pub const URB_FUNCTION_CLASS_ENDPOINT = @as(u32, 28);
pub const URB_FUNCTION_RESERVE_0X001D = @as(u32, 29);
pub const URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL = @as(u32, 30);
pub const URB_FUNCTION_CLASS_OTHER = @as(u32, 31);
pub const URB_FUNCTION_VENDOR_OTHER = @as(u32, 32);
pub const URB_FUNCTION_GET_STATUS_FROM_OTHER = @as(u32, 33);
pub const URB_FUNCTION_CLEAR_FEATURE_TO_OTHER = @as(u32, 34);
pub const URB_FUNCTION_SET_FEATURE_TO_OTHER = @as(u32, 35);
pub const URB_FUNCTION_GET_DESCRIPTOR_FROM_ENDPOINT = @as(u32, 36);
pub const URB_FUNCTION_SET_DESCRIPTOR_TO_ENDPOINT = @as(u32, 37);
pub const URB_FUNCTION_GET_CONFIGURATION = @as(u32, 38);
pub const URB_FUNCTION_GET_INTERFACE = @as(u32, 39);
pub const URB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE = @as(u32, 40);
pub const URB_FUNCTION_SET_DESCRIPTOR_TO_INTERFACE = @as(u32, 41);
pub const URB_FUNCTION_RESERVE_0X002B = @as(u32, 43);
pub const URB_FUNCTION_RESERVE_0X002C = @as(u32, 44);
pub const URB_FUNCTION_RESERVE_0X002D = @as(u32, 45);
pub const URB_FUNCTION_RESERVE_0X002E = @as(u32, 46);
pub const URB_FUNCTION_RESERVE_0X002F = @as(u32, 47);
pub const URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR = @as(u32, 42);
pub const URB_FUNCTION_SYNC_RESET_PIPE = @as(u32, 48);
pub const URB_FUNCTION_SYNC_CLEAR_STALL = @as(u32, 49);
pub const URB_FUNCTION_CONTROL_TRANSFER_EX = @as(u32, 50);
pub const URB_FUNCTION_RESERVE_0X0033 = @as(u32, 51);
pub const URB_FUNCTION_RESERVE_0X0034 = @as(u32, 52);
pub const URB_FUNCTION_OPEN_STATIC_STREAMS = @as(u32, 53);
pub const URB_FUNCTION_CLOSE_STATIC_STREAMS = @as(u32, 54);
pub const URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER_USING_CHAINED_MDL = @as(u32, 55);
pub const URB_FUNCTION_ISOCH_TRANSFER_USING_CHAINED_MDL = @as(u32, 56);
pub const URB_FUNCTION_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS = @as(u32, 61);
pub const URB_FUNCTION_RESET_PIPE = @as(u32, 30);
pub const USBD_SHORT_TRANSFER_OK = @as(u32, 2);
pub const USBD_START_ISO_TRANSFER_ASAP = @as(u32, 4);
pub const USBD_DEFAULT_PIPE_TRANSFER = @as(u32, 8);
pub const USBD_TRANSFER_DIRECTION_OUT = @as(u32, 0);
pub const USBD_TRANSFER_DIRECTION_IN = @as(u32, 1);
pub const USBD_TRANSFER_DIRECTION = @as(u32, 1);
pub const USBD_ISO_START_FRAME_RANGE = @as(u32, 1024);
pub const USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE = @as(u32, 4294967295);
pub const USBD_PF_CHANGE_MAX_PACKET = @as(u32, 1);
pub const USBD_PF_SHORT_PACKET_OPT = @as(u32, 2);
pub const USBD_PF_ENABLE_RT_THREAD_ACCESS = @as(u32, 4);
pub const USBD_PF_MAP_ADD_TRANSFERS = @as(u32, 8);
pub const USBD_PF_VIDEO_PRIORITY = @as(u32, 16);
pub const USBD_PF_VOICE_PRIORITY = @as(u32, 32);
pub const USBD_PF_INTERACTIVE_PRIORITY = @as(u32, 48);
pub const USBD_PF_PRIORITY_MASK = @as(u32, 240);
pub const USBD_PF_HANDLES_SSP_HIGH_BANDWIDTH_ISOCH = @as(u32, 256);
pub const USBD_PF_SSP_HIGH_BANDWIDTH_ISOCH = @as(u32, 65536);
pub const OS_STRING_DESCRIPTOR_INDEX = @as(u32, 238);
pub const MS_GENRE_DESCRIPTOR_INDEX = @as(u32, 1);
pub const MS_POWER_DESCRIPTOR_INDEX = @as(u32, 2);
pub const MS_OS_FLAGS_CONTAINERID = @as(u32, 2);
pub const URB_OPEN_STATIC_STREAMS_VERSION_100 = @as(u32, 256);
pub const MAX_NUM_USBFN_ENDPOINTS = @as(u32, 15);
pub const MAX_CONFIGURATION_NAME_LENGTH = @as(u32, 40);
pub const MAX_USB_STRING_LENGTH = @as(u32, 255);
pub const MAX_SUPPORTED_CONFIGURATIONS = @as(u32, 12);
pub const USBFN_INTERRUPT_ENDPOINT_SIZE_NOT_UPDATEABLE_MASK = @as(u32, 128);
pub const USB_TEST_MODE_TEST_J = @as(u32, 1);
pub const USB_TEST_MODE_TEST_K = @as(u32, 2);
pub const USB_TEST_MODE_TEST_SE0_NAK = @as(u32, 3);
pub const USB_TEST_MODE_TEST_PACKET = @as(u32, 4);
pub const USB_TEST_MODE_TEST_FORCE_ENABLE = @as(u32, 5);
pub const MAX_INTERFACE_NAME_LENGTH = @as(u32, 40);
pub const MAX_ALTERNATE_NAME_LENGTH = @as(u32, 40);
pub const MAX_ASSOCIATION_NAME_LENGTH = @as(u32, 40);
pub const IOCTL_INTERNAL_USB_SUBMIT_URB = @as(u32, 2228227);
pub const IOCTL_INTERNAL_USB_RESET_PORT = @as(u32, 2228231);
pub const IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO = @as(u32, 2228239);
pub const USBD_PORT_ENABLED = @as(u32, 1);
pub const USBD_PORT_CONNECTED = @as(u32, 2);
pub const IOCTL_INTERNAL_USB_GET_PORT_STATUS = @as(u32, 2228243);
pub const IOCTL_INTERNAL_USB_ENABLE_PORT = @as(u32, 2228247);
pub const IOCTL_INTERNAL_USB_GET_HUB_COUNT = @as(u32, 2228251);
pub const IOCTL_INTERNAL_USB_CYCLE_PORT = @as(u32, 2228255);
pub const IOCTL_INTERNAL_USB_GET_HUB_NAME = @as(u32, 2228256);
pub const IOCTL_INTERNAL_USB_GET_BUS_INFO = @as(u32, 2229280);
pub const IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME = @as(u32, 2229284);
pub const IOCTL_INTERNAL_USB_GET_BUSGUID_INFO = @as(u32, 2229288);
pub const IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO = @as(u32, 2229292);
pub const IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION = @as(u32, 2228263);
pub const IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE = @as(u32, 2229299);
pub const IOCTL_INTERNAL_USB_NOTIFY_IDLE_READY = @as(u32, 2229315);
pub const IOCTL_INTERNAL_USB_REQ_GLOBAL_SUSPEND = @as(u32, 2229319);
pub const IOCTL_INTERNAL_USB_REQ_GLOBAL_RESUME = @as(u32, 2229323);
pub const IOCTL_INTERNAL_USB_RECORD_FAILURE = @as(u32, 2228267);
pub const IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE_EX = @as(u32, 2229303);
pub const IOCTL_INTERNAL_USB_GET_TT_DEVICE_HANDLE = @as(u32, 2229307);
pub const IOCTL_INTERNAL_USB_GET_TOPOLOGY_ADDRESS = @as(u32, 2229311);
pub const IOCTL_INTERNAL_USB_GET_DEVICE_CONFIG_INFO = @as(u32, 2229327);
pub const IOCTL_INTERNAL_USB_REGISTER_COMPOSITE_DEVICE = @as(u32, 4784131);
pub const IOCTL_INTERNAL_USB_UNREGISTER_COMPOSITE_DEVICE = @as(u32, 4784135);
pub const IOCTL_INTERNAL_USB_REQUEST_REMOTE_WAKE_NOTIFICATION = @as(u32, 4784139);
pub const IOCTL_INTERNAL_USB_FAIL_GET_STATUS_FROM_DEVICE = @as(u32, 2229347);
pub const IOCTL_USB_HCD_GET_STATS_1 = @as(u32, 2229244);
pub const IOCTL_USB_HCD_GET_STATS_2 = @as(u32, 2229288);
pub const IOCTL_USB_HCD_DISABLE_PORT = @as(u32, 2229296);
pub const IOCTL_USB_HCD_ENABLE_PORT = @as(u32, 2229300);
pub const IOCTL_USB_DIAGNOSTIC_MODE_ON = @as(u32, 2229248);
pub const IOCTL_USB_DIAGNOSTIC_MODE_OFF = @as(u32, 2229252);
pub const IOCTL_USB_GET_ROOT_HUB_NAME = @as(u32, 2229256);
pub const IOCTL_GET_HCD_DRIVERKEY_NAME = @as(u32, 2229284);
pub const IOCTL_USB_GET_NODE_INFORMATION = @as(u32, 2229256);
pub const IOCTL_USB_GET_NODE_CONNECTION_INFORMATION = @as(u32, 2229260);
pub const IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION = @as(u32, 2229264);
pub const IOCTL_USB_GET_NODE_CONNECTION_NAME = @as(u32, 2229268);
pub const IOCTL_USB_DIAG_IGNORE_HUBS_ON = @as(u32, 2229272);
pub const IOCTL_USB_DIAG_IGNORE_HUBS_OFF = @as(u32, 2229276);
pub const IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME = @as(u32, 2229280);
pub const IOCTL_USB_GET_HUB_CAPABILITIES = @as(u32, 2229308);
pub const IOCTL_USB_HUB_CYCLE_PORT = @as(u32, 2229316);
pub const IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES = @as(u32, 2229312);
pub const IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX = @as(u32, 2229320);
pub const IOCTL_USB_RESET_HUB = @as(u32, 2229324);
pub const IOCTL_USB_GET_HUB_CAPABILITIES_EX = @as(u32, 2229328);
pub const IOCTL_USB_GET_HUB_INFORMATION_EX = @as(u32, 2229332);
pub const IOCTL_USB_GET_PORT_CONNECTOR_PROPERTIES = @as(u32, 2229336);
pub const IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX_V2 = @as(u32, 2229340);
pub const IOCTL_USB_GET_TRANSPORT_CHARACTERISTICS = @as(u32, 2229348);
pub const IOCTL_USB_REGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 2229352);
pub const IOCTL_USB_NOTIFY_ON_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 2229356);
pub const IOCTL_USB_UNREGISTER_FOR_TRANSPORT_CHARACTERISTICS_CHANGE = @as(u32, 2229360);
pub const IOCTL_USB_START_TRACKING_FOR_TIME_SYNC = @as(u32, 2229364);
pub const IOCTL_USB_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC = @as(u32, 2229368);
pub const IOCTL_USB_STOP_TRACKING_FOR_TIME_SYNC = @as(u32, 2229372);
pub const IOCTL_USB_GET_DEVICE_CHARACTERISTICS = @as(u32, 2229376);
pub const WMI_USB_DRIVER_INFORMATION = @as(u32, 0);
pub const WMI_USB_DRIVER_NOTIFICATION = @as(u32, 1);
pub const WMI_USB_POWER_DEVICE_ENABLE = @as(u32, 2);
pub const WMI_USB_HUB_NODE_INFORMATION = @as(u32, 4);
pub const WMI_USB_PERFORMANCE_INFORMATION = @as(u32, 1);
pub const WMI_USB_DEVICE_NODE_INFORMATION = @as(u32, 2);
pub const USB_TRANSPORT_CHARACTERISTICS_VERSION_1 = @as(u32, 1);
pub const USB_TRANSPORT_CHARACTERISTICS_LATENCY_AVAILABLE = @as(u32, 1);
pub const USB_TRANSPORT_CHARACTERISTICS_BANDWIDTH_AVAILABLE = @as(u32, 2);
pub const USB_REGISTER_FOR_TRANSPORT_LATENCY_CHANGE = @as(u32, 1);
pub const USB_REGISTER_FOR_TRANSPORT_BANDWIDTH_CHANGE = @as(u32, 2);
pub const USB_DEVICE_CHARACTERISTICS_VERSION_1 = @as(u32, 1);
pub const USB_DEVICE_CHARACTERISTICS_MAXIMUM_PATH_DELAYS_AVAILABLE = @as(u32, 1);
pub const MAX_NUM_PIPES = @as(u32, 8);
pub const BULKIN_FLAG = @as(u32, 128);
pub const FILE_DEVICE_USB_SCAN = @as(u32, 32768);
pub const IOCTL_INDEX = @as(u32, 2048);
pub const IOCTL_GET_VERSION = @as(u32, 2147491840);
pub const IOCTL_CANCEL_IO = @as(u32, 2147491844);
pub const IOCTL_WAIT_ON_DEVICE_EVENT = @as(u32, 2147491848);
pub const IOCTL_READ_REGISTERS = @as(u32, 2147491852);
pub const IOCTL_WRITE_REGISTERS = @as(u32, 2147491856);
pub const IOCTL_GET_CHANNEL_ALIGN_RQST = @as(u32, 2147491860);
pub const IOCTL_GET_DEVICE_DESCRIPTOR = @as(u32, 2147491864);
pub const IOCTL_RESET_PIPE = @as(u32, 2147491868);
pub const IOCTL_GET_USB_DESCRIPTOR = @as(u32, 2147491872);
pub const IOCTL_SEND_USB_REQUEST = @as(u32, 2147491876);
pub const IOCTL_GET_PIPE_CONFIGURATION = @as(u32, 2147491880);
pub const IOCTL_SET_TIMEOUT = @as(u32, 2147491884);
pub const IOCTL_ABORT_PIPE = @as(u32, 2147491844);
pub const WinUSB_TestGuid = Guid.initString("da812bff-12c3-46a2-8e2b-dbd3b7834c43");
//--------------------------------------------------------------------------------
// Section: Types (150)
//--------------------------------------------------------------------------------
pub const USB_DEVICE_SPEED = enum(i32) {
LowSpeed = 0,
FullSpeed = 1,
HighSpeed = 2,
SuperSpeed = 3,
};
pub const UsbLowSpeed = USB_DEVICE_SPEED.LowSpeed;
pub const UsbFullSpeed = USB_DEVICE_SPEED.FullSpeed;
pub const UsbHighSpeed = USB_DEVICE_SPEED.HighSpeed;
pub const UsbSuperSpeed = USB_DEVICE_SPEED.SuperSpeed;
pub const USB_DEVICE_TYPE = enum(i32) {
@"11Device" = 0,
@"20Device" = 1,
};
pub const Usb11Device = USB_DEVICE_TYPE.@"11Device";
pub const Usb20Device = USB_DEVICE_TYPE.@"20Device";
pub const BM_REQUEST_TYPE = extern union {
pub const _BM = extern struct {
_bitfield: u8,
};
s: _BM,
B: u8,
};
pub const USB_DEFAULT_PIPE_SETUP_PACKET = packed struct {
pub const _wIndex = packed union {
Anonymous: extern struct {
LowByte: u8,
HiByte: u8,
},
W: u16,
};
pub const _wValue = packed union {
Anonymous: extern struct {
LowByte: u8,
HiByte: u8,
},
W: u16,
};
bmRequestType: BM_REQUEST_TYPE,
bRequest: u8,
wValue: _wValue,
wIndex: _wIndex,
wLength: u16,
};
pub const USB_DEVICE_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_INTERFACE_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_ENDPOINT_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_COMMON_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
};
pub const USB_DEVICE_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bcdUSB: u16,
bDeviceClass: u8,
bDeviceSubClass: u8,
bDeviceProtocol: u8,
bMaxPacketSize0: u8,
idVendor: u16,
idProduct: u16,
bcdDevice: u16,
iManufacturer: u8,
iProduct: u8,
iSerialNumber: u8,
bNumConfigurations: u8,
};
pub const USB_DEVICE_QUALIFIER_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bcdUSB: u16,
bDeviceClass: u8,
bDeviceSubClass: u8,
bDeviceProtocol: u8,
bMaxPacketSize0: u8,
bNumConfigurations: u8,
bReserved: u8,
};
pub const USB_BOS_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
wTotalLength: u16,
bNumDeviceCaps: u8,
};
pub const USB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bmAttributes: packed union {
AsUlong: u32,
Anonymous: packed struct {
_bitfield: u32,
},
},
};
pub const USB_DEVICE_CAPABILITY_POWER_DELIVERY_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bReserved: u8,
bmAttributes: packed union {
AsUlong: u32,
Anonymous: packed struct {
_bitfield: u32,
},
},
bmProviderPorts: u16,
bmConsumerPorts: u16,
bcdBCVersion: u16,
bcdPDVersion: u16,
bcdUSBTypeCVersion: u16,
};
pub const USB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bReserved: u8,
bmCapabilities: packed union {
AsUshort: u16,
Anonymous: packed struct {
_bitfield: u16,
},
},
wMinVoltage: u16,
wMaxVoltage: u16,
wReserved: u16,
dwMaxOperatingPower: u32,
dwMaxPeakPower: u32,
dwMaxPeakPowerTime: u32,
};
pub const USB_DEVICE_CAPABILITY_SUPERSPEED_USB_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bmAttributes: u8,
wSpeedsSupported: u16,
bFunctionalitySupport: u8,
bU1DevExitLat: u8,
wU2DevExitLat: u16,
};
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED = packed union {
AsUlong32: u32,
Anonymous: packed struct {
_bitfield: u32,
},
};
pub const USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_USB_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bReserved: u8,
bmAttributes: packed union {
AsUlong: u32,
Anonymous: packed struct {
_bitfield: u32,
},
},
wFunctionalitySupport: packed union {
AsUshort: u16,
Anonymous: packed struct {
_bitfield: u16,
},
},
wReserved: u16,
bmSublinkSpeedAttr: [1]USB_DEVICE_CAPABILITY_SUPERSPEEDPLUS_SPEED,
};
pub const USB_DEVICE_CAPABILITY_CONTAINER_ID_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bReserved: u8,
ContainerID: [16]u8,
};
pub const USB_DEVICE_CAPABILITY_PLATFORM_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bReserved: u8,
PlatformCapabilityUuid: Guid,
CapabililityData: [1]u8,
};
pub const USB_DEVICE_CAPABILITY_BILLBOARD_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
iAddtionalInfoURL: u8,
bNumberOfAlternateModes: u8,
bPreferredAlternateMode: u8,
VconnPower: packed union {
AsUshort: u16,
Anonymous: packed struct {
_bitfield: u16,
},
},
bmConfigured: [32]u8,
bReserved: u32,
AlternateMode: [1]packed struct {
wSVID: u16,
bAlternateMode: u8,
iAlternateModeSetting: u8,
},
};
pub const USB_DEVICE_CAPABILITY_FIRMWARE_STATUS_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
bcdDescriptorVersion: u8,
bmAttributes: packed union {
AsUlong: u32,
Anonymous: packed struct {
_bitfield: u32,
},
},
};
pub const USB_DEVICE_CAPABILITY_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bDevCapabilityType: u8,
};
pub const USB_CONFIGURATION_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
wTotalLength: u16,
bNumInterfaces: u8,
bConfigurationValue: u8,
iConfiguration: u8,
bmAttributes: u8,
MaxPower: u8,
};
pub const USB_INTERFACE_ASSOCIATION_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bFirstInterface: u8,
bInterfaceCount: u8,
bFunctionClass: u8,
bFunctionSubClass: u8,
bFunctionProtocol: u8,
iFunction: u8,
};
pub const USB_INTERFACE_DESCRIPTOR = extern struct {
bLength: u8,
bDescriptorType: u8,
bInterfaceNumber: u8,
bAlternateSetting: u8,
bNumEndpoints: u8,
bInterfaceClass: u8,
bInterfaceSubClass: u8,
bInterfaceProtocol: u8,
iInterface: u8,
};
pub const USB_ENDPOINT_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bEndpointAddress: u8,
bmAttributes: u8,
wMaxPacketSize: u16,
bInterval: u8,
};
pub const USB_HIGH_SPEED_MAXPACKET = packed union {
pub const _MP = packed struct {
_bitfield: u16,
};
us: u16,
};
pub const USB_STRING_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bString: [1]u16,
};
pub const USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bMaxBurst: u8,
bmAttributes: extern union {
AsUchar: u8,
Bulk: extern struct {
_bitfield: u8,
},
Isochronous: extern struct {
_bitfield: u8,
},
},
wBytesPerInterval: u16,
};
pub const USB_SUPERSPEEDPLUS_ISOCH_ENDPOINT_COMPANION_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
wReserved: u16,
dwBytesPerInterval: u32,
};
pub const USB_HUB_DESCRIPTOR = packed struct {
bDescriptorLength: u8,
bDescriptorType: u8,
bNumberOfPorts: u8,
wHubCharacteristics: u16,
bPowerOnToPowerGood: u8,
bHubControlCurrent: u8,
bRemoveAndPowerMask: [64]u8,
};
pub const USB_30_HUB_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bNumberOfPorts: u8,
wHubCharacteristics: u16,
bPowerOnToPowerGood: u8,
bHubControlCurrent: u8,
bHubHdrDecLat: u8,
wHubDelay: u16,
DeviceRemovable: u16,
};
pub const USB_HUB_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_HUB_CHANGE = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_HUB_STATUS_AND_CHANGE = packed union {
AsUlong32: u32,
Anonymous: extern struct {
HubStatus: USB_HUB_STATUS,
HubChange: USB_HUB_CHANGE,
},
};
pub const USB_20_PORT_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_20_PORT_CHANGE = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_30_PORT_STATUS = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_30_PORT_CHANGE = packed union {
AsUshort16: u16,
Anonymous: packed struct {
_bitfield: u16,
},
};
pub const USB_PORT_STATUS = packed union {
AsUshort16: u16,
Usb20PortStatus: USB_20_PORT_STATUS,
Usb30PortStatus: USB_30_PORT_STATUS,
};
pub const USB_PORT_CHANGE = packed union {
AsUshort16: u16,
Usb20PortChange: USB_20_PORT_CHANGE,
Usb30PortChange: USB_30_PORT_CHANGE,
};
pub const USB_PORT_EXT_STATUS = packed union {
AsUlong32: u32,
Anonymous: packed struct {
_bitfield: u32,
},
};
pub const USB_PORT_STATUS_AND_CHANGE = packed union {
AsUlong32: u32,
Anonymous: extern struct {
PortStatus: USB_PORT_STATUS,
PortChange: USB_PORT_CHANGE,
},
};
pub const USB_PORT_EXT_STATUS_AND_CHANGE = packed union {
AsUlong64: u64,
Anonymous: extern struct {
PortStatusChange: USB_PORT_STATUS_AND_CHANGE,
PortExtStatus: USB_PORT_EXT_STATUS,
},
};
pub const USB_HUB_30_PORT_REMOTE_WAKE_MASK = extern union {
AsUchar8: u8,
Anonymous: extern struct {
_bitfield: u8,
},
};
pub const USB_FUNCTION_SUSPEND_OPTIONS = extern union {
AsUchar: u8,
Anonymous: extern struct {
_bitfield: u8,
},
};
pub const USB_CONFIGURATION_POWER_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
SelfPowerConsumedD0: [3]u8,
bPowerSummaryId: u8,
bBusPowerSavingD1: u8,
bSelfPowerSavingD1: u8,
bBusPowerSavingD2: u8,
bSelfPowerSavingD2: u8,
bBusPowerSavingD3: u8,
bSelfPowerSavingD3: u8,
TransitionTimeFromD1: u16,
TransitionTimeFromD2: u16,
TransitionTimeFromD3: u16,
};
pub const USB_INTERFACE_POWER_DESCRIPTOR = packed struct {
bLength: u8,
bDescriptorType: u8,
bmCapabilitiesFlags: u8,
bBusPowerSavingD1: u8,
bSelfPowerSavingD1: u8,
bBusPowerSavingD2: u8,
bSelfPowerSavingD2: u8,
bBusPowerSavingD3: u8,
bSelfPowerSavingD3: u8,
TransitionTimeFromD1: u16,
TransitionTimeFromD2: u16,
TransitionTimeFromD3: u16,
};
pub const USB_CONTROLLER_FLAVOR = enum(i32) {
USB_HcGeneric = 0,
OHCI_Generic = 100,
OHCI_Hydra = 101,
OHCI_NEC = 102,
UHCI_Generic = 200,
UHCI_Piix4 = 201,
UHCI_Piix3 = 202,
UHCI_Ich2 = 203,
UHCI_Reserved204 = 204,
UHCI_Ich1 = 205,
UHCI_Ich3m = 206,
UHCI_Ich4 = 207,
UHCI_Ich5 = 208,
UHCI_Ich6 = 209,
UHCI_Intel = 249,
UHCI_VIA = 250,
UHCI_VIA_x01 = 251,
UHCI_VIA_x02 = 252,
UHCI_VIA_x03 = 253,
UHCI_VIA_x04 = 254,
UHCI_VIA_x0E_FIFO = 264,
EHCI_Generic = 1000,
EHCI_NEC = 2000,
EHCI_Lucent = 3000,
EHCI_NVIDIA_Tegra2 = 4000,
EHCI_NVIDIA_Tegra3 = 4001,
EHCI_Intel_Medfield = 5001,
};
pub const USB_HcGeneric = USB_CONTROLLER_FLAVOR.USB_HcGeneric;
pub const OHCI_Generic = USB_CONTROLLER_FLAVOR.OHCI_Generic;
pub const OHCI_Hydra = USB_CONTROLLER_FLAVOR.OHCI_Hydra;
pub const OHCI_NEC = USB_CONTROLLER_FLAVOR.OHCI_NEC;
pub const UHCI_Generic = USB_CONTROLLER_FLAVOR.UHCI_Generic;
pub const UHCI_Piix4 = USB_CONTROLLER_FLAVOR.UHCI_Piix4;
pub const UHCI_Piix3 = USB_CONTROLLER_FLAVOR.UHCI_Piix3;
pub const UHCI_Ich2 = USB_CONTROLLER_FLAVOR.UHCI_Ich2;
pub const UHCI_Reserved204 = USB_CONTROLLER_FLAVOR.UHCI_Reserved204;
pub const UHCI_Ich1 = USB_CONTROLLER_FLAVOR.UHCI_Ich1;
pub const UHCI_Ich3m = USB_CONTROLLER_FLAVOR.UHCI_Ich3m;
pub const UHCI_Ich4 = USB_CONTROLLER_FLAVOR.UHCI_Ich4;
pub const UHCI_Ich5 = USB_CONTROLLER_FLAVOR.UHCI_Ich5;
pub const UHCI_Ich6 = USB_CONTROLLER_FLAVOR.UHCI_Ich6;
pub const UHCI_Intel = USB_CONTROLLER_FLAVOR.UHCI_Intel;
pub const UHCI_VIA = USB_CONTROLLER_FLAVOR.UHCI_VIA;
pub const UHCI_VIA_x01 = USB_CONTROLLER_FLAVOR.UHCI_VIA_x01;
pub const UHCI_VIA_x02 = USB_CONTROLLER_FLAVOR.UHCI_VIA_x02;
pub const UHCI_VIA_x03 = USB_CONTROLLER_FLAVOR.UHCI_VIA_x03;
pub const UHCI_VIA_x04 = USB_CONTROLLER_FLAVOR.UHCI_VIA_x04;
pub const UHCI_VIA_x0E_FIFO = USB_CONTROLLER_FLAVOR.UHCI_VIA_x0E_FIFO;
pub const EHCI_Generic = USB_CONTROLLER_FLAVOR.EHCI_Generic;
pub const EHCI_NEC = USB_CONTROLLER_FLAVOR.EHCI_NEC;
pub const EHCI_Lucent = USB_CONTROLLER_FLAVOR.EHCI_Lucent;
pub const EHCI_NVIDIA_Tegra2 = USB_CONTROLLER_FLAVOR.EHCI_NVIDIA_Tegra2;
pub const EHCI_NVIDIA_Tegra3 = USB_CONTROLLER_FLAVOR.EHCI_NVIDIA_Tegra3;
pub const EHCI_Intel_Medfield = USB_CONTROLLER_FLAVOR.EHCI_Intel_Medfield;
pub const USBD_VERSION_INFORMATION = extern struct {
USBDI_Version: u32,
Supported_USB_Version: u32,
};
pub const USBD_PIPE_TYPE = enum(i32) {
Control = 0,
Isochronous = 1,
Bulk = 2,
Interrupt = 3,
};
pub const UsbdPipeTypeControl = USBD_PIPE_TYPE.Control;
pub const UsbdPipeTypeIsochronous = USBD_PIPE_TYPE.Isochronous;
pub const UsbdPipeTypeBulk = USBD_PIPE_TYPE.Bulk;
pub const UsbdPipeTypeInterrupt = USBD_PIPE_TYPE.Interrupt;
pub const USBD_DEVICE_INFORMATION = extern struct {
OffsetNext: u32,
UsbdDeviceHandle: ?*anyopaque,
DeviceDescriptor: USB_DEVICE_DESCRIPTOR,
};
pub const USBD_PIPE_INFORMATION = extern struct {
MaximumPacketSize: u16,
EndpointAddress: u8,
Interval: u8,
PipeType: USBD_PIPE_TYPE,
PipeHandle: ?*anyopaque,
MaximumTransferSize: u32,
PipeFlags: u32,
};
pub const USBD_ENDPOINT_OFFLOAD_MODE = enum(i32) {
ModeNotSupported = 0,
SoftwareAssisted = 1,
HardwareAssisted = 2,
};
pub const UsbdEndpointOffloadModeNotSupported = USBD_ENDPOINT_OFFLOAD_MODE.ModeNotSupported;
pub const UsbdEndpointOffloadSoftwareAssisted = USBD_ENDPOINT_OFFLOAD_MODE.SoftwareAssisted;
pub const UsbdEndpointOffloadHardwareAssisted = USBD_ENDPOINT_OFFLOAD_MODE.HardwareAssisted;
pub const USBD_ENDPOINT_OFFLOAD_INFORMATION = packed struct {
Size: u32,
EndpointAddress: u16,
ResourceId: u32,
Mode: USBD_ENDPOINT_OFFLOAD_MODE,
_bitfield1: u32,
_bitfield2: u32,
TransferSegmentLA: LARGE_INTEGER,
TransferSegmentVA: ?*anyopaque,
TransferRingSize: usize,
TransferRingInitialCycleBit: u32,
MessageNumber: u32,
EventRingSegmentLA: LARGE_INTEGER,
EventRingSegmentVA: ?*anyopaque,
EventRingSize: usize,
EventRingInitialCycleBit: u32,
};
pub const USBD_INTERFACE_INFORMATION = extern struct {
Length: u16,
InterfaceNumber: u8,
AlternateSetting: u8,
Class: u8,
SubClass: u8,
Protocol: u8,
Reserved: u8,
InterfaceHandle: ?*anyopaque,
NumberOfPipes: u32,
Pipes: [1]USBD_PIPE_INFORMATION,
};
pub const _URB_HCD_AREA = extern struct {
Reserved8: [8]?*anyopaque,
};
pub const _URB_HEADER = extern struct {
Length: u16,
Function: u16,
Status: i32,
UsbdDeviceHandle: ?*anyopaque,
UsbdFlags: u32,
};
pub const _URB_SELECT_INTERFACE = extern struct {
Hdr: _URB_HEADER,
ConfigurationHandle: ?*anyopaque,
Interface: USBD_INTERFACE_INFORMATION,
};
pub const _URB_SELECT_CONFIGURATION = extern struct {
Hdr: _URB_HEADER,
ConfigurationDescriptor: ?*USB_CONFIGURATION_DESCRIPTOR,
ConfigurationHandle: ?*anyopaque,
Interface: USBD_INTERFACE_INFORMATION,
};
pub const _URB_PIPE_REQUEST = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
Reserved: u32,
};
pub const _URB_FRAME_LENGTH_CONTROL = extern struct {
Hdr: _URB_HEADER,
};
pub const _URB_GET_FRAME_LENGTH = extern struct {
Hdr: _URB_HEADER,
FrameLength: u32,
FrameNumber: u32,
};
pub const _URB_SET_FRAME_LENGTH = extern struct {
Hdr: _URB_HEADER,
FrameLengthDelta: i32,
};
pub const _URB_GET_CURRENT_FRAME_NUMBER = extern struct {
Hdr: _URB_HEADER,
FrameNumber: u32,
};
pub const _URB_CONTROL_DESCRIPTOR_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved0: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
Reserved1: u16,
Index: u8,
DescriptorType: u8,
LanguageId: u16,
Reserved2: u16,
};
pub const _URB_CONTROL_GET_STATUS_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved0: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
Reserved1: [4]u8,
Index: u16,
Reserved2: u16,
};
pub const _URB_CONTROL_FEATURE_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved2: u32,
Reserved3: u32,
Reserved4: ?*anyopaque,
Reserved5: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
Reserved0: u16,
FeatureSelector: u16,
Index: u16,
Reserved1: u16,
};
pub const _URB_CONTROL_VENDOR_OR_CLASS_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
TransferFlags: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
RequestTypeReservedBits: u8,
Request: u8,
Value: u16,
Index: u16,
Reserved1: u16,
};
pub const _URB_CONTROL_GET_INTERFACE_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved0: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
Reserved1: [4]u8,
Interface: u16,
Reserved2: u16,
};
pub const _URB_CONTROL_GET_CONFIGURATION_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved0: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
Reserved1: [8]u8,
};
pub const OS_STRING = extern struct {
bLength: u8,
bDescriptorType: u8,
MicrosoftString: [7]u16,
bVendorCode: u8,
Anonymous: extern union {
bPad: u8,
bFlags: u8,
},
};
pub const _URB_OS_FEATURE_DESCRIPTOR_REQUEST = extern struct {
Hdr: _URB_HEADER,
Reserved: ?*anyopaque,
Reserved0: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
_bitfield: u8,
Reserved2: u8,
InterfaceNumber: u8,
MS_PageIndex: u8,
MS_FeatureDescriptorIndex: u16,
Reserved3: u16,
};
pub const _URB_CONTROL_TRANSFER = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
TransferFlags: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
SetupPacket: [8]u8,
};
pub const _URB_CONTROL_TRANSFER_EX = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
TransferFlags: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
Timeout: u32,
hca: _URB_HCD_AREA,
SetupPacket: [8]u8,
};
pub const _URB_BULK_OR_INTERRUPT_TRANSFER = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
TransferFlags: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
};
pub const USBD_ISO_PACKET_DESCRIPTOR = extern struct {
Offset: u32,
Length: u32,
Status: i32,
};
pub const _URB_ISOCH_TRANSFER = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
TransferFlags: u32,
TransferBufferLength: u32,
TransferBuffer: ?*anyopaque,
TransferBufferMDL: ?*anyopaque,
UrbLink: ?*URB,
hca: _URB_HCD_AREA,
StartFrame: u32,
NumberOfPackets: u32,
ErrorCount: u32,
IsoPacket: [1]USBD_ISO_PACKET_DESCRIPTOR,
};
pub const USBD_STREAM_INFORMATION = extern struct {
PipeHandle: ?*anyopaque,
StreamID: u32,
MaximumTransferSize: u32,
PipeFlags: u32,
};
pub const _URB_OPEN_STATIC_STREAMS = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
NumberOfStreams: u32,
StreamInfoVersion: u16,
StreamInfoSize: u16,
Streams: ?*USBD_STREAM_INFORMATION,
};
pub const _URB_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS = extern struct {
Hdr: _URB_HEADER,
PipeHandle: ?*anyopaque,
MaximumSendPathDelayInMilliSeconds: u32,
MaximumCompletionPathDelayInMilliSeconds: u32,
};
pub const URB = extern struct {
Anonymous: extern union {
UrbHeader: _URB_HEADER,
UrbSelectInterface: _URB_SELECT_INTERFACE,
UrbSelectConfiguration: _URB_SELECT_CONFIGURATION,
UrbPipeRequest: _URB_PIPE_REQUEST,
UrbFrameLengthControl: _URB_FRAME_LENGTH_CONTROL,
UrbGetFrameLength: _URB_GET_FRAME_LENGTH,
UrbSetFrameLength: _URB_SET_FRAME_LENGTH,
UrbGetCurrentFrameNumber: _URB_GET_CURRENT_FRAME_NUMBER,
UrbControlTransfer: _URB_CONTROL_TRANSFER,
UrbControlTransferEx: _URB_CONTROL_TRANSFER_EX,
UrbBulkOrInterruptTransfer: _URB_BULK_OR_INTERRUPT_TRANSFER,
UrbIsochronousTransfer: _URB_ISOCH_TRANSFER,
UrbControlDescriptorRequest: _URB_CONTROL_DESCRIPTOR_REQUEST,
UrbControlGetStatusRequest: _URB_CONTROL_GET_STATUS_REQUEST,
UrbControlFeatureRequest: _URB_CONTROL_FEATURE_REQUEST,
UrbControlVendorClassRequest: _URB_CONTROL_VENDOR_OR_CLASS_REQUEST,
UrbControlGetInterfaceRequest: _URB_CONTROL_GET_INTERFACE_REQUEST,
UrbControlGetConfigurationRequest: _URB_CONTROL_GET_CONFIGURATION_REQUEST,
UrbOSFeatureDescriptorRequest: _URB_OS_FEATURE_DESCRIPTOR_REQUEST,
UrbOpenStaticStreams: _URB_OPEN_STATIC_STREAMS,
UrbGetIsochPipeTransferPathDelays: _URB_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS,
},
};
pub const USB_IDLE_CALLBACK = fn(
Context: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
pub const USB_IDLE_CALLBACK_INFO = extern struct {
IdleCallback: ?USB_IDLE_CALLBACK,
IdleContext: ?*anyopaque,
};
pub const USB_USER_ERROR_CODE = enum(i32) {
Success = 0,
NotSupported = 1,
InvalidRequestCode = 2,
FeatureDisabled = 3,
InvalidHeaderParameter = 4,
InvalidParameter = 5,
MiniportError = 6,
BufferTooSmall = 7,
ErrorNotMapped = 8,
DeviceNotStarted = 9,
NoDeviceConnected = 10,
};
pub const UsbUserSuccess = USB_USER_ERROR_CODE.Success;
pub const UsbUserNotSupported = USB_USER_ERROR_CODE.NotSupported;
pub const UsbUserInvalidRequestCode = USB_USER_ERROR_CODE.InvalidRequestCode;
pub const UsbUserFeatureDisabled = USB_USER_ERROR_CODE.FeatureDisabled;
pub const UsbUserInvalidHeaderParameter = USB_USER_ERROR_CODE.InvalidHeaderParameter;
pub const UsbUserInvalidParameter = USB_USER_ERROR_CODE.InvalidParameter;
pub const UsbUserMiniportError = USB_USER_ERROR_CODE.MiniportError;
pub const UsbUserBufferTooSmall = USB_USER_ERROR_CODE.BufferTooSmall;
pub const UsbUserErrorNotMapped = USB_USER_ERROR_CODE.ErrorNotMapped;
pub const UsbUserDeviceNotStarted = USB_USER_ERROR_CODE.DeviceNotStarted;
pub const UsbUserNoDeviceConnected = USB_USER_ERROR_CODE.NoDeviceConnected;
pub const USBUSER_REQUEST_HEADER = packed struct {
UsbUserRequest: u32,
UsbUserStatusCode: USB_USER_ERROR_CODE,
RequestBufferLength: u32,
ActualBufferLength: u32,
};
pub const PACKET_PARAMETERS = packed struct {
DeviceAddress: u8,
EndpointAddress: u8,
MaximumPacketSize: u16,
Timeout: u32,
Flags: u32,
DataLength: u32,
HubDeviceAddress: u16,
PortTTNumber: u16,
ErrorCount: u8,
Pad: [3]u8,
UsbdStatusCode: i32,
Data: [4]u8,
};
pub const USBUSER_SEND_ONE_PACKET = extern struct {
Header: USBUSER_REQUEST_HEADER,
PacketParameters: PACKET_PARAMETERS,
};
pub const RAW_RESET_PORT_PARAMETERS = packed struct {
PortNumber: u16,
PortStatus: u16,
};
pub const USBUSER_RAW_RESET_ROOT_PORT = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: RAW_RESET_PORT_PARAMETERS,
};
pub const RAW_ROOTPORT_FEATURE = packed struct {
PortNumber: u16,
PortFeature: u16,
PortStatus: u16,
};
pub const USBUSER_ROOTPORT_FEATURE_REQUEST = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: RAW_ROOTPORT_FEATURE,
};
pub const RAW_ROOTPORT_PARAMETERS = packed struct {
PortNumber: u16,
PortStatus: u16,
};
pub const USBUSER_ROOTPORT_PARAMETERS = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: RAW_ROOTPORT_PARAMETERS,
};
pub const USB_CONTROLLER_INFO_0 = packed struct {
PciVendorId: u32,
PciDeviceId: u32,
PciRevision: u32,
NumberOfRootPorts: u32,
ControllerFlavor: USB_CONTROLLER_FLAVOR,
HcFeatureFlags: u32,
};
pub const USBUSER_CONTROLLER_INFO_0 = extern struct {
Header: USBUSER_REQUEST_HEADER,
Info0: USB_CONTROLLER_INFO_0,
};
pub const USB_UNICODE_NAME = packed struct {
Length: u32,
String: [1]u16,
};
pub const USBUSER_CONTROLLER_UNICODE_NAME = extern struct {
Header: USBUSER_REQUEST_HEADER,
UnicodeName: USB_UNICODE_NAME,
};
pub const USB_PASS_THRU_PARAMETERS = packed struct {
FunctionGUID: Guid,
ParameterLength: u32,
Parameters: [4]u8,
};
pub const USBUSER_PASS_THRU_REQUEST = extern struct {
Header: USBUSER_REQUEST_HEADER,
PassThru: USB_PASS_THRU_PARAMETERS,
};
pub const WDMUSB_POWER_STATE = enum(i32) {
NotMapped = 0,
SystemUnspecified = 100,
SystemWorking = 101,
SystemSleeping1 = 102,
SystemSleeping2 = 103,
SystemSleeping3 = 104,
SystemHibernate = 105,
SystemShutdown = 106,
DeviceUnspecified = 200,
DeviceD0 = 201,
DeviceD1 = 202,
DeviceD2 = 203,
DeviceD3 = 204,
};
pub const WdmUsbPowerNotMapped = WDMUSB_POWER_STATE.NotMapped;
pub const WdmUsbPowerSystemUnspecified = WDMUSB_POWER_STATE.SystemUnspecified;
pub const WdmUsbPowerSystemWorking = WDMUSB_POWER_STATE.SystemWorking;
pub const WdmUsbPowerSystemSleeping1 = WDMUSB_POWER_STATE.SystemSleeping1;
pub const WdmUsbPowerSystemSleeping2 = WDMUSB_POWER_STATE.SystemSleeping2;
pub const WdmUsbPowerSystemSleeping3 = WDMUSB_POWER_STATE.SystemSleeping3;
pub const WdmUsbPowerSystemHibernate = WDMUSB_POWER_STATE.SystemHibernate;
pub const WdmUsbPowerSystemShutdown = WDMUSB_POWER_STATE.SystemShutdown;
pub const WdmUsbPowerDeviceUnspecified = WDMUSB_POWER_STATE.DeviceUnspecified;
pub const WdmUsbPowerDeviceD0 = WDMUSB_POWER_STATE.DeviceD0;
pub const WdmUsbPowerDeviceD1 = WDMUSB_POWER_STATE.DeviceD1;
pub const WdmUsbPowerDeviceD2 = WDMUSB_POWER_STATE.DeviceD2;
pub const WdmUsbPowerDeviceD3 = WDMUSB_POWER_STATE.DeviceD3;
pub const USB_POWER_INFO = packed struct {
SystemState: WDMUSB_POWER_STATE,
HcDevicePowerState: WDMUSB_POWER_STATE,
HcDeviceWake: WDMUSB_POWER_STATE,
HcSystemWake: WDMUSB_POWER_STATE,
RhDevicePowerState: WDMUSB_POWER_STATE,
RhDeviceWake: WDMUSB_POWER_STATE,
RhSystemWake: WDMUSB_POWER_STATE,
LastSystemSleepState: WDMUSB_POWER_STATE,
CanWakeup: BOOLEAN,
IsPowered: BOOLEAN,
};
pub const USBUSER_POWER_INFO_REQUEST = extern struct {
Header: USBUSER_REQUEST_HEADER,
PowerInformation: USB_POWER_INFO,
};
pub const USB_OPEN_RAW_DEVICE_PARAMETERS = packed struct {
PortStatus: u16,
MaxPacketEp0: u16,
};
pub const USBUSER_OPEN_RAW_DEVICE = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: USB_OPEN_RAW_DEVICE_PARAMETERS,
};
pub const USB_CLOSE_RAW_DEVICE_PARAMETERS = packed struct {
xxx: u32,
};
pub const USBUSER_CLOSE_RAW_DEVICE = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: USB_CLOSE_RAW_DEVICE_PARAMETERS,
};
pub const USB_SEND_RAW_COMMAND_PARAMETERS = packed struct {
Usb_bmRequest: u8,
Usb_bRequest: u8,
Usb_wVlaue: u16,
Usb_wIndex: u16,
Usb_wLength: u16,
DeviceAddress: u16,
MaximumPacketSize: u16,
Timeout: u32,
DataLength: u32,
UsbdStatusCode: i32,
Data: [4]u8,
};
pub const USBUSER_SEND_RAW_COMMAND = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: USB_SEND_RAW_COMMAND_PARAMETERS,
};
pub const USB_BANDWIDTH_INFO = packed struct {
DeviceCount: u32,
TotalBusBandwidth: u32,
Total32secBandwidth: u32,
AllocedBulkAndControl: u32,
AllocedIso: u32,
AllocedInterrupt_1ms: u32,
AllocedInterrupt_2ms: u32,
AllocedInterrupt_4ms: u32,
AllocedInterrupt_8ms: u32,
AllocedInterrupt_16ms: u32,
AllocedInterrupt_32ms: u32,
};
pub const USBUSER_BANDWIDTH_INFO_REQUEST = extern struct {
Header: USBUSER_REQUEST_HEADER,
BandwidthInformation: USB_BANDWIDTH_INFO,
};
pub const USB_BUS_STATISTICS_0 = packed struct {
DeviceCount: u32,
CurrentSystemTime: LARGE_INTEGER,
CurrentUsbFrame: u32,
BulkBytes: u32,
IsoBytes: u32,
InterruptBytes: u32,
ControlDataBytes: u32,
PciInterruptCount: u32,
HardResetCount: u32,
WorkerSignalCount: u32,
CommonBufferBytes: u32,
WorkerIdleTimeMs: u32,
RootHubEnabled: BOOLEAN,
RootHubDevicePowerState: u8,
Unused: u8,
NameIndex: u8,
};
pub const USBUSER_BUS_STATISTICS_0_REQUEST = extern struct {
Header: USBUSER_REQUEST_HEADER,
BusStatistics0: USB_BUS_STATISTICS_0,
};
pub const USB_DRIVER_VERSION_PARAMETERS = packed struct {
DriverTrackingCode: u32,
USBDI_Version: u32,
USBUSER_Version: u32,
CheckedPortDriver: BOOLEAN,
CheckedMiniportDriver: BOOLEAN,
USB_Version: u16,
};
pub const USBUSER_GET_DRIVER_VERSION = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: USB_DRIVER_VERSION_PARAMETERS,
};
pub const USB_USB2HW_VERSION_PARAMETERS = extern struct {
Usb2HwRevision: u8,
};
pub const USBUSER_GET_USB2HW_VERSION = extern struct {
Header: USBUSER_REQUEST_HEADER,
Parameters: USB_USB2HW_VERSION_PARAMETERS,
};
pub const USBUSER_REFRESH_HCT_REG = packed struct {
Header: USBUSER_REQUEST_HEADER,
Flags: u32,
};
pub const WINUSB_PIPE_INFORMATION = extern struct {
PipeType: USBD_PIPE_TYPE,
PipeId: u8,
MaximumPacketSize: u16,
Interval: u8,
};
pub const WINUSB_PIPE_INFORMATION_EX = extern struct {
PipeType: USBD_PIPE_TYPE,
PipeId: u8,
MaximumPacketSize: u16,
Interval: u8,
MaximumBytesPerInterval: u32,
};
pub const WINUSB_SETUP_PACKET = packed struct {
RequestType: u8,
Request: u8,
Value: u16,
Index: u16,
Length: u16,
};
pub const USB_START_TRACKING_FOR_TIME_SYNC_INFORMATION = packed struct {
TimeTrackingHandle: ?HANDLE,
IsStartupDelayTolerable: BOOLEAN,
};
pub const USB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION = packed struct {
TimeTrackingHandle: ?HANDLE,
};
pub const USB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION = packed struct {
TimeTrackingHandle: ?HANDLE,
InputFrameNumber: u32,
InputMicroFrameNumber: u32,
QueryPerformanceCounterAtInputFrameOrMicroFrame: LARGE_INTEGER,
QueryPerformanceCounterFrequency: LARGE_INTEGER,
PredictedAccuracyInMicroSeconds: u32,
CurrentGenerationID: u32,
CurrentQueryPerformanceCounter: LARGE_INTEGER,
CurrentHardwareFrameNumber: u32,
CurrentHardwareMicroFrameNumber: u32,
CurrentUSBFrameNumber: u32,
};
pub const USBFN_EVENT = enum(i32) {
Minimum = 0,
Attach = 1,
Reset = 2,
Detach = 3,
Suspend = 4,
Resume = 5,
SetupPacket = 6,
Configured = 7,
UnConfigured = 8,
PortType = 9,
BusTearDown = 10,
SetInterface = 11,
Maximum = 12,
};
pub const UsbfnEventMinimum = USBFN_EVENT.Minimum;
pub const UsbfnEventAttach = USBFN_EVENT.Attach;
pub const UsbfnEventReset = USBFN_EVENT.Reset;
pub const UsbfnEventDetach = USBFN_EVENT.Detach;
pub const UsbfnEventSuspend = USBFN_EVENT.Suspend;
pub const UsbfnEventResume = USBFN_EVENT.Resume;
pub const UsbfnEventSetupPacket = USBFN_EVENT.SetupPacket;
pub const UsbfnEventConfigured = USBFN_EVENT.Configured;
pub const UsbfnEventUnConfigured = USBFN_EVENT.UnConfigured;
pub const UsbfnEventPortType = USBFN_EVENT.PortType;
pub const UsbfnEventBusTearDown = USBFN_EVENT.BusTearDown;
pub const UsbfnEventSetInterface = USBFN_EVENT.SetInterface;
pub const UsbfnEventMaximum = USBFN_EVENT.Maximum;
pub const USBFN_PORT_TYPE = enum(i32) {
UnknownPort = 0,
StandardDownstreamPort = 1,
ChargingDownstreamPort = 2,
DedicatedChargingPort = 3,
InvalidDedicatedChargingPort = 4,
ProprietaryDedicatedChargingPort = 5,
PortTypeMaximum = 6,
};
pub const UsbfnUnknownPort = USBFN_PORT_TYPE.UnknownPort;
pub const UsbfnStandardDownstreamPort = USBFN_PORT_TYPE.StandardDownstreamPort;
pub const UsbfnChargingDownstreamPort = USBFN_PORT_TYPE.ChargingDownstreamPort;
pub const UsbfnDedicatedChargingPort = USBFN_PORT_TYPE.DedicatedChargingPort;
pub const UsbfnInvalidDedicatedChargingPort = USBFN_PORT_TYPE.InvalidDedicatedChargingPort;
pub const UsbfnProprietaryDedicatedChargingPort = USBFN_PORT_TYPE.ProprietaryDedicatedChargingPort;
pub const UsbfnPortTypeMaximum = USBFN_PORT_TYPE.PortTypeMaximum;
pub const USBFN_BUS_SPEED = enum(i32) {
Low = 0,
Full = 1,
High = 2,
Super = 3,
Maximum = 4,
};
pub const UsbfnBusSpeedLow = USBFN_BUS_SPEED.Low;
pub const UsbfnBusSpeedFull = USBFN_BUS_SPEED.Full;
pub const UsbfnBusSpeedHigh = USBFN_BUS_SPEED.High;
pub const UsbfnBusSpeedSuper = USBFN_BUS_SPEED.Super;
pub const UsbfnBusSpeedMaximum = USBFN_BUS_SPEED.Maximum;
pub const USBFN_DIRECTION = enum(i32) {
Minimum = 0,
In = 1,
Out = 2,
// Tx = 1, this enum value conflicts with In
// Rx = 2, this enum value conflicts with Out
Maximum = 3,
};
pub const UsbfnDirectionMinimum = USBFN_DIRECTION.Minimum;
pub const UsbfnDirectionIn = USBFN_DIRECTION.In;
pub const UsbfnDirectionOut = USBFN_DIRECTION.Out;
pub const UsbfnDirectionTx = USBFN_DIRECTION.In;
pub const UsbfnDirectionRx = USBFN_DIRECTION.Out;
pub const UsbfnDirectionMaximum = USBFN_DIRECTION.Maximum;
pub const USBFN_DEVICE_STATE = enum(i32) {
Minimum = 0,
Attached = 1,
Default = 2,
Detached = 3,
Addressed = 4,
Configured = 5,
Suspended = 6,
StateMaximum = 7,
};
pub const UsbfnDeviceStateMinimum = USBFN_DEVICE_STATE.Minimum;
pub const UsbfnDeviceStateAttached = USBFN_DEVICE_STATE.Attached;
pub const UsbfnDeviceStateDefault = USBFN_DEVICE_STATE.Default;
pub const UsbfnDeviceStateDetached = USBFN_DEVICE_STATE.Detached;
pub const UsbfnDeviceStateAddressed = USBFN_DEVICE_STATE.Addressed;
pub const UsbfnDeviceStateConfigured = USBFN_DEVICE_STATE.Configured;
pub const UsbfnDeviceStateSuspended = USBFN_DEVICE_STATE.Suspended;
pub const UsbfnDeviceStateStateMaximum = USBFN_DEVICE_STATE.StateMaximum;
pub const ALTERNATE_INTERFACE = extern struct {
InterfaceNumber: u16,
AlternateInterfaceNumber: u16,
};
pub const USBFN_NOTIFICATION = extern struct {
Event: USBFN_EVENT,
u: extern union {
BusSpeed: USBFN_BUS_SPEED,
SetupPacket: USB_DEFAULT_PIPE_SETUP_PACKET,
ConfigurationValue: u16,
PortType: USBFN_PORT_TYPE,
AlternateInterface: ALTERNATE_INTERFACE,
},
};
pub const USBFN_PIPE_INFORMATION = extern struct {
EpDesc: USB_ENDPOINT_DESCRIPTOR,
PipeId: u32,
};
pub const USBFN_CLASS_INTERFACE = extern struct {
InterfaceNumber: u8,
PipeCount: u8,
PipeArr: [16]USBFN_PIPE_INFORMATION,
};
pub const USBFN_CLASS_INFORMATION_PACKET = extern struct {
FullSpeedClassInterface: USBFN_CLASS_INTERFACE,
HighSpeedClassInterface: USBFN_CLASS_INTERFACE,
InterfaceName: [40]u16,
InterfaceGuid: [39]u16,
HasInterfaceGuid: BOOLEAN,
SuperSpeedClassInterface: USBFN_CLASS_INTERFACE,
};
pub const USBFN_CLASS_INTERFACE_EX = extern struct {
BaseInterfaceNumber: u8,
InterfaceCount: u8,
PipeCount: u8,
PipeArr: [16]USBFN_PIPE_INFORMATION,
};
pub const USBFN_CLASS_INFORMATION_PACKET_EX = extern struct {
FullSpeedClassInterfaceEx: USBFN_CLASS_INTERFACE_EX,
HighSpeedClassInterfaceEx: USBFN_CLASS_INTERFACE_EX,
SuperSpeedClassInterfaceEx: USBFN_CLASS_INTERFACE_EX,
InterfaceName: [40]u16,
InterfaceGuid: [39]u16,
HasInterfaceGuid: BOOLEAN,
};
pub const USBFN_INTERFACE_INFO = extern struct {
InterfaceNumber: u8,
Speed: USBFN_BUS_SPEED,
Size: u16,
InterfaceDescriptorSet: [1]u8,
};
pub const USBFN_USB_STRING = extern struct {
StringIndex: u8,
UsbString: [255]u16,
};
pub const USBFN_BUS_CONFIGURATION_INFO = extern struct {
ConfigurationName: [40]u16,
IsCurrent: BOOLEAN,
IsActive: BOOLEAN,
};
pub const DRV_VERSION = extern struct {
major: u32,
minor: u32,
internal: u32,
};
pub const IO_BLOCK = extern struct {
uOffset: u32,
uLength: u32,
pbyData: ?*u8,
uIndex: u32,
};
pub const IO_BLOCK_EX = extern struct {
uOffset: u32,
uLength: u32,
pbyData: ?*u8,
uIndex: u32,
bRequest: u8,
bmRequestType: u8,
fTransferDirectionIn: u8,
};
pub const CHANNEL_INFO = extern struct {
EventChannelSize: u32,
uReadDataAlignment: u32,
uWriteDataAlignment: u32,
};
pub const PIPE_TYPE = enum(i32) {
EVENT_PIPE = 0,
READ_DATA_PIPE = 1,
WRITE_DATA_PIPE = 2,
ALL_PIPE = 3,
};
pub const EVENT_PIPE = PIPE_TYPE.EVENT_PIPE;
pub const READ_DATA_PIPE = PIPE_TYPE.READ_DATA_PIPE;
pub const WRITE_DATA_PIPE = PIPE_TYPE.WRITE_DATA_PIPE;
pub const ALL_PIPE = PIPE_TYPE.ALL_PIPE;
pub const USBSCAN_GET_DESCRIPTOR = extern struct {
DescriptorType: u8,
Index: u8,
LanguageId: u16,
};
pub const DEVICE_DESCRIPTOR = extern struct {
usVendorId: u16,
usProductId: u16,
usBcdDevice: u16,
usLanguageId: u16,
};
pub const RAW_PIPE_TYPE = enum(i32) {
CONTROL = 0,
ISOCHRONOUS = 1,
BULK = 2,
INTERRUPT = 3,
};
pub const USBSCAN_PIPE_CONTROL = RAW_PIPE_TYPE.CONTROL;
pub const USBSCAN_PIPE_ISOCHRONOUS = RAW_PIPE_TYPE.ISOCHRONOUS;
pub const USBSCAN_PIPE_BULK = RAW_PIPE_TYPE.BULK;
pub const USBSCAN_PIPE_INTERRUPT = RAW_PIPE_TYPE.INTERRUPT;
pub const USBSCAN_PIPE_INFORMATION = extern struct {
MaximumPacketSize: u16,
EndpointAddress: u8,
Interval: u8,
PipeType: RAW_PIPE_TYPE,
};
pub const USBSCAN_PIPE_CONFIGURATION = extern struct {
NumberOfPipes: u32,
PipeInfo: [8]USBSCAN_PIPE_INFORMATION,
};
pub const USBSCAN_TIMEOUT = extern struct {
TimeoutRead: u32,
TimeoutWrite: u32,
TimeoutEvent: u32,
};
//--------------------------------------------------------------------------------
// Section: Functions (34)
//--------------------------------------------------------------------------------
pub extern "WINUSB" fn WinUsb_Initialize(
DeviceHandle: ?HANDLE,
InterfaceHandle: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_Free(
InterfaceHandle: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetAssociatedInterface(
InterfaceHandle: ?*anyopaque,
AssociatedInterfaceIndex: u8,
AssociatedInterfaceHandle: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetDescriptor(
InterfaceHandle: ?*anyopaque,
DescriptorType: u8,
Index: u8,
LanguageID: u16,
// TODO: what to do with BytesParamIndex 5?
Buffer: ?*u8,
BufferLength: u32,
LengthTransferred: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_QueryInterfaceSettings(
InterfaceHandle: ?*anyopaque,
AlternateInterfaceNumber: u8,
UsbAltInterfaceDescriptor: ?*USB_INTERFACE_DESCRIPTOR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_QueryDeviceInformation(
InterfaceHandle: ?*anyopaque,
InformationType: u32,
BufferLength: ?*u32,
// TODO: what to do with BytesParamIndex 2?
Buffer: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_SetCurrentAlternateSetting(
InterfaceHandle: ?*anyopaque,
SettingNumber: u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetCurrentAlternateSetting(
InterfaceHandle: ?*anyopaque,
SettingNumber: ?*u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_QueryPipe(
InterfaceHandle: ?*anyopaque,
AlternateInterfaceNumber: u8,
PipeIndex: u8,
PipeInformation: ?*WINUSB_PIPE_INFORMATION,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_QueryPipeEx(
InterfaceHandle: ?*anyopaque,
AlternateSettingNumber: u8,
PipeIndex: u8,
PipeInformationEx: ?*WINUSB_PIPE_INFORMATION_EX,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_SetPipePolicy(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
PolicyType: u32,
ValueLength: u32,
// TODO: what to do with BytesParamIndex 3?
Value: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetPipePolicy(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
PolicyType: u32,
ValueLength: ?*u32,
// TODO: what to do with BytesParamIndex 3?
Value: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_ReadPipe(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*u8,
BufferLength: u32,
LengthTransferred: ?*u32,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_WritePipe(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*u8,
BufferLength: u32,
LengthTransferred: ?*u32,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_ControlTransfer(
InterfaceHandle: ?*anyopaque,
SetupPacket: WINUSB_SETUP_PACKET,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*u8,
BufferLength: u32,
LengthTransferred: ?*u32,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_ResetPipe(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_AbortPipe(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_FlushPipe(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_SetPowerPolicy(
InterfaceHandle: ?*anyopaque,
PolicyType: u32,
ValueLength: u32,
// TODO: what to do with BytesParamIndex 2?
Value: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetPowerPolicy(
InterfaceHandle: ?*anyopaque,
PolicyType: u32,
ValueLength: ?*u32,
// TODO: what to do with BytesParamIndex 2?
Value: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_GetOverlappedResult(
InterfaceHandle: ?*anyopaque,
lpOverlapped: ?*OVERLAPPED,
lpNumberOfBytesTransferred: ?*u32,
bWait: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINUSB" fn WinUsb_ParseConfigurationDescriptor(
ConfigurationDescriptor: ?*USB_CONFIGURATION_DESCRIPTOR,
StartPosition: ?*anyopaque,
InterfaceNumber: i32,
AlternateSetting: i32,
InterfaceClass: i32,
InterfaceSubClass: i32,
InterfaceProtocol: i32,
) callconv(@import("std").os.windows.WINAPI) ?*USB_INTERFACE_DESCRIPTOR;
pub extern "WINUSB" fn WinUsb_ParseDescriptors(
// TODO: what to do with BytesParamIndex 1?
DescriptorBuffer: ?*anyopaque,
TotalLength: u32,
StartPosition: ?*anyopaque,
DescriptorType: i32,
) callconv(@import("std").os.windows.WINAPI) ?*USB_COMMON_DESCRIPTOR;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_GetCurrentFrameNumber(
InterfaceHandle: ?*anyopaque,
CurrentFrameNumber: ?*u32,
TimeStamp: ?*LARGE_INTEGER,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_GetAdjustedFrameNumber(
CurrentFrameNumber: ?*u32,
TimeStamp: LARGE_INTEGER,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_RegisterIsochBuffer(
InterfaceHandle: ?*anyopaque,
PipeID: u8,
// TODO: what to do with BytesParamIndex 3?
Buffer: ?*u8,
BufferLength: u32,
IsochBufferHandle: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_UnregisterIsochBuffer(
IsochBufferHandle: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_WriteIsochPipe(
BufferHandle: ?*anyopaque,
Offset: u32,
Length: u32,
FrameNumber: ?*u32,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_ReadIsochPipe(
BufferHandle: ?*anyopaque,
Offset: u32,
Length: u32,
FrameNumber: ?*u32,
NumberOfPackets: u32,
IsoPacketDescriptors: [*]USBD_ISO_PACKET_DESCRIPTOR,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_WriteIsochPipeAsap(
BufferHandle: ?*anyopaque,
Offset: u32,
Length: u32,
ContinueStream: BOOL,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.1'
pub extern "WINUSB" fn WinUsb_ReadIsochPipeAsap(
BufferHandle: ?*anyopaque,
Offset: u32,
Length: u32,
ContinueStream: BOOL,
NumberOfPackets: u32,
IsoPacketDescriptors: [*]USBD_ISO_PACKET_DESCRIPTOR,
Overlapped: ?*OVERLAPPED,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "WINUSB" fn WinUsb_StartTrackingForTimeSync(
InterfaceHandle: ?*anyopaque,
StartTrackingInfo: ?*USB_START_TRACKING_FOR_TIME_SYNC_INFORMATION,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "WINUSB" fn WinUsb_GetCurrentFrameNumberAndQpc(
InterfaceHandle: ?*anyopaque,
FrameQpcInfo: ?*USB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "WINUSB" fn WinUsb_StopTrackingForTimeSync(
InterfaceHandle: ?*anyopaque,
StopTrackingInfo: ?*USB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION,
) callconv(@import("std").os.windows.WINAPI) BOOL;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (6)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const BOOLEAN = @import("../foundation.zig").BOOLEAN;
const HANDLE = @import("../foundation.zig").HANDLE;
const LARGE_INTEGER = @import("../foundation.zig").LARGE_INTEGER;
const OVERLAPPED = @import("../system/io.zig").OVERLAPPED;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "USB_IDLE_CALLBACK")) { _ = USB_IDLE_CALLBACK; }
@setEvalBranchQuota(
@import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (@import("std").meta.declarations(@This())) |decl| {
if (decl.is_pub) {
_ = decl;
}
}
} | win32/devices/usb.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const MemError = @import("../mem.zig").MemError;
const VRAM_SIZE = 64 * 1024;
pub const Vip = struct {
disp_pixels: [224][384]u8,
vram: []u8,
pub fn new(allocator: *Allocator) !Vip {
var vram = try allocator.alloc(u8, VRAM_SIZE);
mem.set(u8, vram, 0);
return Vip{
.disp_pixels = [_][384]u8{[_]u8{0} ** 384} ** 224,
.vram = vram,
};
}
pub fn cycle(self: *Vip) void {
// set display procedure beginning
self.vram[0xf820] |= 0x40;
const disp_ctrl = self.display_control();
if ((disp_ctrl & 0x0200) == 0x0200) {
self.vram[0xf820] |= 0x02;
}
return;
}
fn update_display_status(self: *Vip) void {
const halfword = self.display_control();
if ((halfword & 0x0200) == 0x0200) {
self.vram[0xf820] |= 0x02;
}
}
fn frame_buffer_to_pixels(self: *Vip) void {
for (self.vram[0x00000000..0x00005fff]) |pixel, i| {}
}
fn interrupt_pending(self: *Vip) u16 {
return self.vram[0xf800];
}
fn interrupt_enable(self: *Vip) u16 {
return self.vram[0xf802];
}
fn interrupt_clear(self: *Vip) u16 {
return self.vram[0xf804];
}
fn display_status(self: *Vip) u16 {
const b = self.vram[0xf820];
const a = self.vram[0xf821];
return (@intCast(u16, a) << 8) | b;
}
fn display_control(self: *Vip) u16 {
const b = self.vram[0xf822];
const a = self.vram[0xf823];
return (@intCast(u16, a) << 8) | b;
}
fn led_brightness1(self: *Vip) u16 {
return self.vram[0xf824];
}
fn led_brightness2(self: *Vip) u16 {
return self.vram[0xf826];
}
fn led_brightness3(self: *Vip) u16 {
return self.vram[0xf828];
}
fn led_brightness_idle(self: *Vip) u16 {
return self.vram[0xf82a];
}
fn frame_repeat(self: *Vip) u16 {
return self.vram[0xf82e];
}
fn column_table_address(self: *Vip) u16 {
return self.vram[0xf830];
}
fn drawing_status(self: *Vip) u16 {
return self.vram[0xf840];
}
fn drawing_control(self: *Vip) u16 {
return self.vram[0xf842];
}
fn version(self: *Vip) u16 {
return self.vram[0xf844];
}
fn obj_group0_pointer(self: *Vip) u16 {
return self.vram[0xf848];
}
fn obj_group1_pointer(self: *Vip) u16 {
return self.vram[0xf84a];
}
fn obj_group2_pointer(self: *Vip) u16 {
return self.vram[0xf84c];
}
fn obj_group3_pointer(self: *Vip) u16 {
return self.vram[0xf84e];
}
fn bg_palette0(self: *Vip) u16 {
return self.vram[0xf860];
}
fn bg_palette1(self: *Vip) u16 {
return self.vram[0xf862];
}
fn bg_palette2(self: *Vip) u16 {
return self.vram[0xf864];
}
fn bg_palette3(self: *Vip) u16 {
return self.vram[0xf866];
}
fn obj_palette0(self: *Vip) u16 {
return self.vram[0xf868];
}
fn obj_palette1(self: *Vip) u16 {
return self.vram[0xf86a];
}
fn obj_palette2(self: *Vip) u16 {
return self.vram[0xf86c];
}
fn obj_palette3(self: *Vip) u16 {
return self.vram[0xf86e];
}
fn clear_color(self: *Vip) u16 {
return self.vram[0xf870];
}
}; | src/hw/vip.zig |
const std = @import("std");
const warn = @import("std").debug.warn;
const assert = @import("std").debug.assert;
const draw = @import("draw.zig");
const todo = @import("todo.zig");
const misc = @import("misc.zig");
usingnamespace @import("c.zig");
fn getHomeDir() [*c]u8 {
var homedir = getenv("HOME");
if (homedir == null) {
var pw = getpwuid(getuid());
homedir = pw.*.pw_dir;
}
var result: [*c]u8 = undefined;
var r = asprintf(&result, "%s/", homedir);
assert(r >= 0);
return result;
}
const Config = struct {
enable_unicode: bool = true,
enter_graphical_mode: bool = true,
listfile: [*c]u8 = null,
};
fn cStrToSlice(cstr: [*c]u8) []u8 {
return cstr[0..strlen(cstr)];
}
pub fn main() anyerror!void {
var result = setlocale(LC_ALL, "");
assert(result != 0);
result = setlocale(LC_CTYPE, "");
assert(result != 0);
var homedir = getHomeDir();
defer free(homedir);
const default_listfile = "todolist";
var config = (Config){};
result = asprintf(&config.listfile, "%s%s", homedir, default_listfile);
defer free(config.listfile);
assert(result >= 0);
{
const config_filename: [*c]const u8 = &".config/todo.config"[0];
var config_dir: [*c]u8 = undefined;
_ = asprintf(&config_dir, "%s%s", homedir, config_filename);
defer free(config_dir);
assert(config_dir != null);
if (fopen(config_dir, "r")) |config_file| {
defer _ = fclose(config_file);
var key = [_:0]u8{0} ** 101;
var value = [_:0]u8{0} ** 101;
_ = printf("loaded config file %s\n", config_dir);
while (fscanf(config_file, "%100s %100s\n", &key[0], &value[0]) > 0) {
_ = printf("CONFIG: %s = %s\n", key, value);
if (strcmp(&key, "unicode") == 0) {
if (strcmp(&value, "true") == 0) {
_ = printf("ENABLING UNICODE\n");
config.enable_unicode = true;
} else if (strcmp(&value, "false") == 0) {
_ = printf("DISS UNICODE\n");
config.enable_unicode = false;
} else {
_ = fprintf(stderr, "Unkown value for 'unicode' in config %s\n", value);
exit(EXIT_FAILURE);
}
} else if (strcmp(&key, "listfile") == 0) {
_ = free(config.listfile);
config.listfile = strdup(&value);
_ = printf("Listfile is %s\n", value);
} else {
_ = fprintf(stderr, "Unkown key in config '%s' = '%s'\n", key, value);
exit(EXIT_FAILURE);
}
}
}
}
// TODO a better default allocator that isn't as wasteful!
//const args = try std.process.argsAlloc(std.heap.page_allocator);
//defer std.process.argsFree(std.heap.page_allocator, args);
//for (args) |arg, i| {
// switch (arg[0]) {
//
// }
// std.debug.warn("{}: {}\n", .{i, arg});
//}
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = &arena.allocator;
var global_listing = try todo.loadList(allocator, config.listfile);
defer global_listing.deinit();
const count = global_listing.items.len;
const args = try std.process.argsAlloc(std.heap.page_allocator);
defer std.process.argsFree(std.heap.page_allocator, args);
{
var tp: timespec = undefined;
if (clock_gettime(CLOCK_REALTIME, &tp) == -1)
return error.ClockGetTime;
const tnow = tp.tv_sec;
for (args[1..]) |arg, i| {
switch (arg[0]) {
'-' => {}, // config
else => {
var text: *wchar_t = std.meta.cast(*c_int, calloc(strlen(&arg[0]) + 1, @sizeOf(wchar_t)).?);
if (mbstowcs(text, &arg[0], strlen(&arg[0]) + 1) == -1)
return error.InvalidMultibyteSequence;
var new = try global_listing.addOne();
new.* = .{
.time_added = tnow,
.time_started = 0,
.time_complete = 0,
.state = todo.State.Not_Started,
.text = text,
};
config.enter_graphical_mode = false;
},
}
}
todo.sort(global_listing.items);
}
defer {
todo.sort(global_listing.items);
todo.save(global_listing, config.listfile[0..strlen(config.listfile)]);
}
if (!config.enter_graphical_mode)
return;
_ = initscr(); // start up ncurses
defer _ = endwin();
_ = cbreak(); // don't wait for return when getting chars
_ = noecho(); // don't echo keypresses
_ = nonl(); // we wan't to be able to detect the return key
_ = clear(); // make sure screen is cleared because some implementations don't do it automatically
_ = curs_set(0); // set cursor invisible
_ = start_color();
if (true) {
_ = init_pair(1, COLOR_WHITE + 8, COLOR_BLACK);
_ = init_pair(2, COLOR_BLACK, COLOR_MAGENTA + 8);
_ = init_pair(3, COLOR_BLUE, COLOR_WHITE + 8);
_ = init_pair(4, COLOR_YELLOW + 8, COLOR_BLACK);
_ = init_pair(5, COLOR_GREEN + 8, COLOR_BLACK);
_ = init_pair(6, COLOR_BLACK, COLOR_RED);
} else {
_ = init_pair(1, COLOR_BLACK, COLOR_WHITE);
_ = init_pair(2, COLOR_RED, COLOR_BLACK);
_ = init_pair(3, COLOR_WHITE, COLOR_BLUE);
_ = init_pair(4, COLOR_BLACK, COLOR_YELLOW + 8);
_ = init_pair(5, COLOR_BLACK, COLOR_GREEN);
_ = init_pair(6, COLOR_BLACK, COLOR_RED);
}
_ = intrflush(stdscr, false);
_ = keypad(stdscr, true); // get special keys
_ = idlok(stdscr, true);
_ = leaveok(stdscr, true);
_ = scrollok(stdscr, true); // enable window scrolling
_ = wtimeout(stdscr, -1);
var window_width: c_int = undefined;
var window_height: c_int = undefined;
var selection_index: usize = 0;
var scrolling: usize = 0;
var ch: wint_t = undefined;
// Draw the list at least once
draw.drawTodoListViewToWindow(stdscr, config.enable_unicode, global_listing, selection_index, scrolling);
_ = get_wch(&ch);
while (ch != 'q') : (_ = get_wch(&ch)) {
curses_getmaxyx(stdscr, &window_height, &window_width);
if (ch == KEY_UP) {
if (selection_index > 0)
selection_index -= 1;
if (selection_index < scrolling) {
if (scrolling == 0) {
selection_index = 0;
} else
scrolling -= 1;
}
}
if (ch == KEY_DOWN) {
const list_count = global_listing.items.len;
selection_index += 1;
if (selection_index >= list_count)
selection_index = list_count - 1;
if (selection_index - scrolling >= window_height - draw.dateline_count - 1)
scrolling += 1;
}
if (ch == KEY_LEFT) {
var selected = &global_listing.items[selection_index];
selected.*.state = .Not_Started;
}
if (ch == KEY_RIGHT) {
var item = &global_listing.items[selection_index];
switch (item.state) {
.Not_Started, .Priority => {
item.state = .Doing;
var tp: timespec = undefined;
_ = clock_gettime(CLOCK_REALTIME, &tp);
item.time_started = tp.tv_sec;
},
.Doing => {
item.state = .In_Review;
},
.In_Review => {
item.state = .Done;
var tp: timespec = undefined;
_ = clock_gettime(CLOCK_REALTIME, &tp);
item.time_complete = tp.tv_sec;
},
.Done => {},
.Discarded => {
item.state = .Not_Started;
},
}
}
if (ch == 'd') {
var item = &global_listing.items[selection_index];
item.state = .Discarded;
}
if (ch == '!') {
var item = &global_listing.items[selection_index];
item.state = .Priority;
var tp: timespec = undefined;
_ = clock_gettime(CLOCK_REALTIME, &tp);
item.time_started = tp.tv_sec;
}
draw.drawTodoListViewToWindow(stdscr, config.enable_unicode, global_listing, selection_index, scrolling);
}
} | src/main.zig |
const std = @import("std");
pub const ErasedPtr = struct {
ptr: usize,
pub fn init(ptr: anytype) ErasedPtr {
if (@sizeOf(@TypeOf(ptr)) == 0) {
return .{ .ptr = undefined };
}
return .{ .ptr = @ptrToInt(ptr) };
}
pub fn as(self: ErasedPtr, comptime T: type) *T {
if (@sizeOf(T) == 0)
return @as(T, undefined);
return self.asPtr(*T);
}
pub fn asPtr(self: ErasedPtr, comptime PtrT: type) PtrT {
if (@sizeOf(PtrT) == 0)
return @as(PtrT, undefined);
return @intToPtr(PtrT, self.ptr);
}
};
pub fn ReverseSliceIterator(comptime T: type) type {
return struct {
slice: []T,
index: usize,
pub fn init(slice: []T) @This() {
return .{
.slice = slice,
.index = slice.len,
};
}
pub fn next(self: *@This()) ?T {
if (self.index == 0) return null;
self.index -= 1;
return self.slice[self.index];
}
pub fn reset(self: *@This()) void {
self.index = slice.len;
}
};
}
/// sorts items using lessThan and keeps sub_items with the same sort
pub fn sortSub(comptime T1: type, comptime T2: type, items: []T1, sub_items: []T2, comptime lessThan: fn (void, lhs: T1, rhs: T1) bool) void {
var i: usize = 1;
while (i < items.len) : (i += 1) {
const x = items[i];
const y = sub_items[i];
var j: usize = i;
while (j > 0 and lessThan({}, x, items[j - 1])) : (j -= 1) {
items[j] = items[j - 1];
sub_items[j] = sub_items[j - 1];
}
items[j] = x;
sub_items[j] = y;
}
}
pub fn sortSubSub(comptime T1: type, comptime T2: type, items: []T1, sub_items: []T2, context: anytype, comptime lessThan: fn (@TypeOf(context), lhs: T1, rhs: T1) bool) void {
var i: usize = 1;
while (i < items.len) : (i += 1) {
const x = items[i];
const y = sub_items[i];
var j: usize = i;
while (j > 0 and lessThan(context, x, items[j - 1])) : (j -= 1) {
items[j] = items[j - 1];
sub_items[j] = sub_items[j - 1];
}
items[j] = x;
sub_items[j] = y;
}
}
/// comptime string hashing for the type names
pub fn typeId(comptime T: type) u32 {
comptime return hashStringFnv(u32, @typeName(T));
}
/// comptime string hashing for the type names
pub fn typeId64(comptime T: type) u64 {
comptime return hashStringFnv(u64, @typeName(T));
}
/// u32 Fowler-Noll-Vo string hash
pub fn hashString(comptime str: []const u8) u32 {
return hashStringFnv(u32, str);
}
/// Fowler–Noll–Vo string hash. ReturnType should be u32/u64
pub fn hashStringFnv(comptime ReturnType: type, comptime str: []const u8) ReturnType {
std.debug.assert(ReturnType == u32 or ReturnType == u64);
const prime = if (ReturnType == u32) @as(u32, 16777619) else @as(u64, 1099511628211);
var value = if (ReturnType == u32) @as(u32, 2166136261) else @as(u64, 14695981039346656037);
for (str) |c| {
value = (value ^ @intCast(u32, c)) *% prime;
}
return value;
}
/// comptime string hashing, djb2 by <NAME>. Fails on large strings.
pub fn hashStringDjb2(comptime str: []const u8) comptime_int {
var hash: comptime_int = 5381;
for (str) |c| {
hash = ((hash << 5) + hash) + @intCast(comptime_int, c);
}
return hash;
}
pub fn isComptime(comptime T: type) bool {
return switch (@typeInfo(T)) {
.ComptimeInt, .ComptimeFloat => true,
else => false,
};
}
test "ReverseSliceIterator" {
var slice = std.testing.allocator.alloc(usize, 10) catch unreachable;
defer std.testing.allocator.free(slice);
for (slice) |*item, i| {
item.* = i;
}
var iter = ReverseSliceIterator(usize).init(slice);
var i: usize = 9;
while (iter.next()) |val| {
std.testing.expectEqual(i, val);
if (i > 0) i -= 1;
}
} | src/ecs/ecs/utils.zig |
const std = @import("std");
const assert = std.debug.assert;
const builtin = std.builtin;
const mem = std.mem;
const net = std.net;
const os = std.os;
const linux = os.linux;
const testing = std.testing;
usingnamespace @import("tigerbeetle.zig");
pub fn main() !void {
var addr = try net.Address.parseIp4("127.0.0.1", config.port);
var connection = try net.tcpConnectToAddress(addr);
const fd = connection.handle;
defer os.close(fd);
var accounts = [_]Account{
Account{
.id = 1,
.custom = 0,
.flags = .{},
.unit = 2,
.debit_reserved = 0,
.debit_accepted = 0,
.credit_reserved = 0,
.credit_accepted = 0,
.debit_reserved_limit = 1_000_000,
.debit_accepted_limit = 1_000_000,
.credit_reserved_limit = 0,
.credit_accepted_limit = 0,
},
Account{
.id = 2,
.custom = 0,
.flags = .{},
.unit = 2,
.debit_reserved = 0,
.debit_accepted = 1_000_000_000,
.credit_reserved = 0,
.credit_accepted = 900_000,
.debit_reserved_limit = 0,
.debit_accepted_limit = 0,
.credit_reserved_limit = 1_000_000,
.credit_accepted_limit = 1_000_000,
},
};
try send(fd, .create_accounts, mem.asBytes(accounts[0..]), CreateAccountResults);
var transfers = [_]Transfer{Transfer{
.id = 4,
.debit_account_id = accounts[0].id,
.credit_account_id = accounts[1].id,
.custom_1 = 0,
.custom_2 = 0,
.custom_3 = 0,
.flags = .{},
.amount = 100,
.timeout = 0,
}};
try send(fd, .create_transfers, mem.asBytes(transfers[0..]), CreateTransferResults);
var commits = [_]Commit{Commit{
.id = transfers[0].id,
.custom_1 = 0,
.custom_2 = 0,
.custom_3 = 0,
.flags = .{ .accept = true },
}};
try send(fd, .commit_transfers, mem.asBytes(commits[0..]), CommitTransferResults);
var auto_commit_transfers = [_]Transfer{Transfer{
.id = 5,
.debit_account_id = accounts[0].id,
.credit_account_id = accounts[1].id,
.custom_1 = 0,
.custom_2 = 0,
.custom_3 = 0,
.flags = .{
.accept = true,
.auto_commit = true,
},
.amount = 100,
.timeout = 0,
}};
try send(fd, .create_transfers, mem.asBytes(auto_commit_transfers[0..]), CreateTransferResults);
}
var request_id: u128 = 0;
fn send(fd: os.fd_t, command: Command, data: []u8, Result: anytype) !void {
request_id += 1;
var request = NetworkHeader{
.id = request_id,
.command = command,
.size = @intCast(u32, @sizeOf(NetworkHeader) + data.len),
};
request.set_checksum_data(data[0..]);
request.set_checksum_meta();
const meta = mem.asBytes(&request);
assert((try os.sendto(fd, meta[0..], 0, null, 0)) == meta.len);
if (data.len > 0) {
assert((try os.sendto(fd, data[0..], 0, null, 0)) == data.len);
}
var recv: [1024 * 1024]u8 = undefined;
const recv_bytes = try os.recvfrom(fd, recv[0..], 0, null, null);
assert(recv_bytes >= @sizeOf(NetworkHeader));
var response = mem.bytesAsValue(NetworkHeader, recv[0..@sizeOf(NetworkHeader)]);
std.debug.print("\nACK {}:\n{}\n", .{ response.id, response });
assert(response.magic == Magic);
assert(response.valid_checksum_meta());
assert(response.valid_size());
assert(recv_bytes >= response.size);
const response_data = recv[@sizeOf(NetworkHeader)..response.size];
assert(response.valid_checksum_data(response_data));
for (mem.bytesAsSlice(Result, response_data)) |result| {
std.debug.print("{}\n", .{result});
}
} | src/toy.zig |
const std = @import("std");
const tools = @import("tools");
const with_trace = true;
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/day08.txt", run);
pub fn run(input: []const u8, gpa: std.mem.Allocator) tools.RunError![2][]const u8 {
const Afficheur = []const u8;
const Entry = struct {
patterns: [10]Afficheur,
output: [4]Afficheur,
};
var list0 = std.ArrayList(Entry).init(gpa);
defer list0.deinit();
{
try list0.ensureTotalCapacity(input.len / 80);
var it = std.mem.tokenize(u8, input, "\n");
while (it.next()) |line| {
var e: Entry = undefined;
var it2 = std.mem.tokenize(u8, line, "|");
{
const patterns = it2.next().?;
var it3 = std.mem.tokenize(u8, patterns, " ");
var i: u32 = 0;
while (it3.next()) |segment| : (i += 1) {
e.patterns[i] = segment;
}
}
{
const outputs = it2.next().?;
var it3 = std.mem.tokenize(u8, outputs, " ");
var i: u32 = 0;
while (it3.next()) |segment| : (i += 1) {
e.output[i] = segment;
}
}
try list0.append(e);
}
}
const ans1 = ans: {
var count: u32 = 0;
for (list0.items) |it| {
for (it.output) |o|
count += @boolToInt(o.len == 2 or o.len == 3 or o.len == 4 or o.len == 7);
}
break :ans count;
};
// occurences: A: 8, B: 6, C: 8, D: 7, E: 4, F: 9, G: 7
const models = [10][]const u8{
"abcefg", // 0
"cf", // 1
"acdeg", // 2
"acdfg", // 3
"bcdf", // 4
"abdfg", // 5
"abdefg", // 6
"acf", // 7
"abcdefg", // 8
"abcdfg", // 9
};
const matcher = comptime blk: {
const Matcher = struct {
digit_from_invariant: [256]u4,
// invariant en fonction l'ordre des chiffres et des segments
pub fn computeSymbolOccurences(self: *const @This(), patterns: []const []const u8) [7]u8 {
_ = self;
assert(patterns.len == 10);
var occurences = [1]u8{0} ** 7;
for (patterns) |p| {
for (p) |c| occurences[c - 'a'] += 1;
}
return occurences;
}
fn computeInvariant(pattern: []const u8, occurences: [7]u8) u8 {
var invariant: u8 = 0;
// +, * marchent aussi. ^ fait des valeurs plus petites
for (pattern) |c| invariant ^= occurences[c - 'a'];
invariant *= @intCast(u8, pattern.len);
return invariant;
}
pub fn readNumber(self: *const @This(), occurences: [7]u8, digits: []const []const u8) u32 {
var val: u32 = 0;
for (digits) |d| {
val = val * 10 + self.digit_from_invariant[
computeInvariant(d, occurences)
];
}
return val;
}
};
var matcher = Matcher{ .digit_from_invariant = undefined };
var invariant_collision = [1]bool{false} ** 256;
const occurences = matcher.computeSymbolOccurences(&models);
for (models) |m, digit| {
const invariant = Matcher.computeInvariant(m, occurences);
assert(!invariant_collision[invariant]);
invariant_collision[invariant] = true;
matcher.digit_from_invariant[invariant] = digit;
}
break :blk matcher;
};
const ans2 = ans: {
var sum: u64 = 0;
for (list0.items) |it| {
if (false) {
// old brute force attempt:
const dico = decode(models, it.patterns[0..]);
sum += read(models, dico, it.output[0..]);
} else {
// using invariant matching
const occurences = matcher.computeSymbolOccurences(it.patterns[0..]);
sum += matcher.readNumber(occurences, it.output[0..]);
}
}
break :ans sum;
};
return [_][]const u8{
try std.fmt.allocPrint(gpa, "{}", .{ans1}),
try std.fmt.allocPrint(gpa, "{}", .{ans2}),
};
}
// old brute force attempt:
pub fn indexOf(models: [10][]const u8, dico: [7]u8, pat: []const u8) ?u4 {
var buf: [7]u8 = undefined;
for (pat) |c, i| {
buf[i] = dico[c - 'a'];
}
std.sort.sort(u8, buf[0..pat.len], {}, comptime std.sort.asc(u8));
for (models) |m, digit| {
if (std.mem.eql(u8, m, buf[0..pat.len])) return @intCast(u4, digit);
} else return null;
}
pub fn decode(models: [10][]const u8, patterns: []const []const u8) [7]u8 {
var it = tools.generate_permutations(u8, "ABCDEFG");
var dico: [7]u8 = undefined;
while (it.next(&dico)) |_| {
var match: bool = true;
for (patterns) |p| {
match = match and indexOf(models, dico, p) != null;
}
if (match) return dico;
}
unreachable;
}
pub fn read(models: [10][]const u8, dico: [7]u8, digits: []const []const u8) u32 {
var val: u32 = 0;
for (digits) |d| {
val = val * 10 + indexOf(models, dico, d).?;
}
return val;
}
test {
const res = try run(
\\be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb | fdgacbe cefdb cefbgd gcbe
\\edbfga begcd cbg gc gcadebf fbgde acbgfd abcde gfcbed gfec | fcgedb cgb dgebacf gc
\\fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef | cg cg fdcagb cbg
\\fbegcd cbd adcefb dageb afcb bc aefdc ecdab fgdeca fcdbega | efabcd cedba gadfec cb
\\aecbfdg fbg gf bafeg dbefa fcge gcbea fcaegb dgceab fcbdga | gecf egdcabf bgf bfgea
\\fgeab ca afcebg bdacfeg cfaedg gcfdb baec bfadeg bafgc acf | gebdcfa ecba ca fadegcb
\\dbcfg fgd bdegcaf fgec aegbdf ecdfab fbedc dacgb gdcebf gf | cefg dcbef fcge gbcadfe
\\bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd | ed bcgafe cdgba cbgef
\\egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg | gbdfcae bgc cg cgb
\\gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc | fgae cfgab fg bagce
, std.testing.allocator);
defer std.testing.allocator.free(res[0]);
defer std.testing.allocator.free(res[1]);
try std.testing.expectEqualStrings("26", res[0]);
try std.testing.expectEqualStrings("61229", res[1]);
} | 2021/day08.zig |
const std = @import("std");
const warn = std.debug.warn;
const assert = std.debug.assert;
var g_u1: u1 = 0;
var pg_u1: *volatile u1 = &g_u1;
var g_i1: i1 = 0;
var pg_i1: *volatile i1 = &g_i1;
test "g_u1" {
assert(g_u1 == 0);
assert(pg_u1 == &g_u1);
pg_u1.* = 1;
assert(g_u1 == 1);
assert(@sizeOf(@typeOf(g_u1)) == 1);
assert(@typeOf(g_u1).bit_count == 1);
assert(@ptrToInt(pg_u1) != @ptrToInt(pg_i1));
}
test "g_i1" {
assert(g_i1 == 0);
assert(pg_i1 == &g_i1);
pg_i1.* = -1;
assert(g_i1 == -1);
assert(@sizeOf(@typeOf(g_i1)) == 1);
assert(@typeOf(g_i1).bit_count == 1);
assert(@ptrToInt(pg_u1) != @ptrToInt(pg_i1));
}
var g_u0: u0 = 0;
var pg_u0: *volatile u0 = &g_u0;
var g_i0: i0 = 0;
var pg_i0: *volatile i0 = &g_i0;
test "g_u0" {
assert(g_u0 == 0);
assert(pg_u0 == &g_u0);
pg_u0.* = 0;
assert(g_u0 == 0);
assert(@typeOf(g_u0).bit_count == 0);
assert(@sizeOf(@typeOf(g_u0)) == 0);
//assert(@ptrToInt(pg_u0) != @ptrToInt(pg_i0)); // Currently compile error
}
test "g_i0" {
assert(g_i0 == 0);
assert(pg_i0 == &g_i0);
pg_i0.* = 0;
assert(g_i0 == 0);
assert(@typeOf(g_i0).bit_count == 0);
assert(@sizeOf(@typeOf(g_i0)) == 0);
//assert(@ptrToInt(pg_u0) != @ptrToInt(pg_i0)); // Currently compile error
}
const StructU1 = struct {
f1_u1: u1,
};
const StructI1 = struct {
f1_i1: i1,
};
var g_StructU1 = StructU1 {
.f1_u1 = 0,
};
var pg_StructU1: *volatile StructU1 = &g_StructU1;
var g_StructI1 = StructI1 {
.f1_i1 = 0,
};
var pg_StructI1: *volatile StructI1 = &g_StructI1;
test "g_StructU1" {
assert(@ptrToInt(pg_StructU1) != @ptrToInt(pg_StructI1));
assert(g_StructU1.f1_u1 == 0);
assert(pg_StructU1 == &g_StructU1);
pg_StructU1.*.f1_u1 = 1;
assert(g_StructU1.f1_u1 == 1);
assert(@byteOffsetOf(@typeOf(g_StructU1), "f1_u1") == 0);
assert(@bitOffsetOf(@typeOf(g_StructU1), "f1_u1") == 0);
assert(@sizeOf(@typeOf(g_StructU1)) == 1);
assert(@typeOf(g_StructU1.f1_u1).bit_count == 1);
}
test "g_StructI1" {
assert(@ptrToInt(pg_StructU1) != @ptrToInt(pg_StructI1));
assert(g_StructI1.f1_i1 == 0);
assert(pg_StructI1 == &g_StructI1);
pg_StructI1.*.f1_i1 = -1;
assert(g_StructI1.f1_i1 == -1);
assert(@byteOffsetOf(@typeOf(g_StructI1), "f1_i1") == 0);
assert(@bitOffsetOf(@typeOf(g_StructI1), "f1_i1") == 0);
assert(@sizeOf(@typeOf(g_StructI1)) == 1);
assert(@typeOf(g_StructI1.f1_i1).bit_count == 1);
}
const Struct2U1 = struct {
f1_u1: u1,
f2_u1: u1,
};
const Struct2I1 = struct {
f1_i1: i1,
f2_i1: i1,
};
var g_Struct2U1 = Struct2U1 {
.f1_u1 = 0,
.f2_u1 = 0,
};
var pg_Struct2U1: *volatile Struct2U1 = &g_Struct2U1;
var g_Struct2I1 = Struct2I1 {
.f1_i1 = 0,
.f2_i1 = 0,
};
var pg_Struct2I1: *volatile Struct2I1 = &g_Struct2I1;
test "g_Struct2U1" {
assert(g_Struct2U1.f1_u1 == 0);
assert(g_Struct2U1.f2_u1 == 0);
assert(pg_Struct2U1 == &g_Struct2U1);
pg_Struct2U1.*.f1_u1 = 1;
pg_Struct2U1.*.f2_u1 = 1;
assert(g_Struct2U1.f1_u1 == 1);
assert(g_Struct2U1.f2_u1 == 1);
assert(@sizeOf(@typeOf(g_Struct2U1)) > 0);
assert(@typeOf(g_Struct2U1.f1_u1).bit_count == 1);
assert(@typeOf(g_Struct2U1.f2_u1).bit_count == 1);
assert(@ptrToInt(pg_Struct2U1) != @ptrToInt(pg_Struct2I1));
// byteOffsetOf is indeterminate for plain structs
assert(@bitOffsetOf(@typeOf(g_Struct2U1), "f1_u1") !=
@bitOffsetOf(@typeOf(g_Struct2U1), "f2_u1"));
}
test "g_Struct2I1" {
assert(g_Struct2I1.f1_i1 == 0);
assert(g_Struct2I1.f2_i1 == 0);
assert(pg_Struct2I1 == &g_Struct2I1);
pg_Struct2I1.*.f1_i1 = -1;
pg_Struct2I1.*.f2_i1 = -1;
assert(g_Struct2I1.f1_i1 == -1);
assert(g_Struct2I1.f2_i1 == -1);
assert(@sizeOf(@typeOf(g_Struct2I1)) > 0);
assert(@typeOf(g_Struct2I1.f1_i1).bit_count == 1);
assert(@typeOf(g_Struct2I1.f2_i1).bit_count == 1);
assert(@ptrToInt(pg_Struct2U1) != @ptrToInt(pg_Struct2I1));
// byteOffsetOf is indeterminate for plain structs
assert(@bitOffsetOf(@typeOf(g_Struct2I1), "f1_i1") !=
@bitOffsetOf(@typeOf(g_Struct2I1), "f2_i1"));
}
const PackedStruct2U1 = packed struct {
f1_u1: u1,
f2_u1: u1,
};
const PackedStruct2I1 = packed struct {
f1_i1: i1,
f2_i1: i1,
};
var g_PackedStruct2U1 = PackedStruct2U1 {
.f1_u1 = 0,
.f2_u1 = 0,
};
var pg_PackedStruct2U1: *volatile PackedStruct2U1 = &g_PackedStruct2U1;
var g_PackedStruct2I1 = PackedStruct2I1 {
.f1_i1 = 0,
.f2_i1 = 0,
};
var pg_PackedStruct2I1: *volatile PackedStruct2I1 = &g_PackedStruct2I1;
test "g_PackedStruct2U1" {
assert(g_PackedStruct2U1.f1_u1 == 0);
assert(g_PackedStruct2U1.f2_u1 == 0);
assert(pg_PackedStruct2U1 == &g_PackedStruct2U1);
pg_PackedStruct2U1.*.f1_u1 = 1;
pg_PackedStruct2U1.*.f2_u1 = 1;
assert(g_PackedStruct2U1.f1_u1 == 1);
assert(g_PackedStruct2U1.f2_u1 == 1);
assert(@sizeOf(@typeOf(g_PackedStruct2U1)) == 1);
assert(@typeOf(g_PackedStruct2U1.f1_u1).bit_count == 1);
assert(@typeOf(g_PackedStruct2U1.f2_u1).bit_count == 1);
assert(@ptrToInt(pg_PackedStruct2U1) != @ptrToInt(pg_PackedStruct2I1));
assert(@byteOffsetOf(@typeOf(g_PackedStruct2U1), "f1_u1") == 0);
assert(@byteOffsetOf(@typeOf(g_PackedStruct2U1), "f2_u1") == 0);
assert(@ptrToInt(&g_PackedStruct2U1.f1_u1) ==
@ptrToInt(&g_PackedStruct2U1.f2_u1));
assert(@bitOffsetOf(@typeOf(g_PackedStruct2U1), "f1_u1") == 0);
assert(@bitOffsetOf(@typeOf(g_PackedStruct2U1), "f2_u1") == 1);
}
test "g_PackedStruct2I1" {
assert(g_PackedStruct2I1.f1_i1 == 0);
assert(g_PackedStruct2I1.f2_i1 == 0);
assert(pg_PackedStruct2I1 == &g_PackedStruct2I1);
pg_PackedStruct2I1.*.f1_i1 = -1;
pg_PackedStruct2I1.*.f2_i1 = -1;
assert(g_PackedStruct2I1.f1_i1 == -1);
assert(g_PackedStruct2I1.f2_i1 == -1);
assert(@sizeOf(@typeOf(g_PackedStruct2I1)) == 1);
assert(@typeOf(g_PackedStruct2I1.f1_i1).bit_count == 1);
assert(@typeOf(g_PackedStruct2I1.f2_i1).bit_count == 1);
assert(@ptrToInt(pg_PackedStruct2U1) != @ptrToInt(pg_PackedStruct2I1));
assert(@byteOffsetOf(@typeOf(g_PackedStruct2I1), "f1_i1") == 0);
assert(@byteOffsetOf(@typeOf(g_PackedStruct2I1), "f2_i1") == 0);
assert(@bitOffsetOf(@typeOf(g_PackedStruct2I1), "f1_i1") == 0);
assert(@bitOffsetOf(@typeOf(g_PackedStruct2I1), "f2_i1") == 1);
}
const PackedStruct4Fields = packed struct {
f1: u1,
f2: u64,
f3: i1,
f4: u64,
};
var g_PackedStruct4Fields = PackedStruct4Fields {
.f1 = 0,
.f2 = 0,
.f3 = 0,
.f4 = 0,
};
var pg_PackedStruct4Fields: *volatile PackedStruct4Fields = &g_PackedStruct4Fields;
test "g_PackedStruct4Fields" {
assert(g_PackedStruct4Fields.f1 == 0);
assert(g_PackedStruct4Fields.f2 == 0);
assert(g_PackedStruct4Fields.f3 == 0);
assert(pg_PackedStruct4Fields == &g_PackedStruct4Fields);
pg_PackedStruct4Fields.*.f1 = 1;
pg_PackedStruct4Fields.*.f2 = 1;
pg_PackedStruct4Fields.*.f3 = -1;
assert(g_PackedStruct4Fields.f1 == 1);
assert(g_PackedStruct4Fields.f2 == 1);
assert(g_PackedStruct4Fields.f3 == -1);
assert(@sizeOf(@typeOf(g_PackedStruct4Fields)) == 17);
assert(@typeOf(g_PackedStruct4Fields.f1).bit_count == 1);
assert(@typeOf(g_PackedStruct4Fields.f2).bit_count == 64);
assert(@typeOf(g_PackedStruct4Fields.f3).bit_count == 1);
assert(@typeOf(g_PackedStruct4Fields.f4).bit_count == 64);
assert(@byteOffsetOf(@typeOf(g_PackedStruct4Fields), "f1") == 0);
assert(@byteOffsetOf(@typeOf(g_PackedStruct4Fields), "f2") == 0);
assert(@byteOffsetOf(@typeOf(g_PackedStruct4Fields), "f3") == 0);
assert(@byteOffsetOf(@typeOf(g_PackedStruct4Fields), "f4") == 0);
assert(@ptrToInt(&g_PackedStruct4Fields.f1) ==
@ptrToInt(&g_PackedStruct4Fields.f2));
assert(@ptrToInt(&g_PackedStruct4Fields.f2) ==
@ptrToInt(&g_PackedStruct4Fields.f3));
assert(@ptrToInt(&g_PackedStruct4Fields.f3) ==
@ptrToInt(&g_PackedStruct4Fields.f4));
assert(@bitOffsetOf(@typeOf(g_PackedStruct4Fields), "f1") == 0);
assert(@bitOffsetOf(@typeOf(g_PackedStruct4Fields), "f2") == 1);
assert(@bitOffsetOf(@typeOf(g_PackedStruct4Fields), "f3") == 65);
assert(@bitOffsetOf(@typeOf(g_PackedStruct4Fields), "f4") == 66);
} | xx.zig |
const std = @import("std");
const c = @import("c/c.zig");
const utils = @import("utils.zig");
const types = @import("types.zig");
pub const Event = union(enum) {
const Self = @This();
key: types.KeyEvent,
mouse: types.MouseEvent,
window_buffer_size: types.Coords,
menu: u32,
focus: bool,
pub fn fromInputRecord(ir: c.INPUT_RECORD) Self {
switch (ir.EventType) {
// NOTE: I'm unsure if this behavior is intentional or not but the KeyEvent.uChar union has two active fields at a time
c.KEY_EVENT => {
return Self{ .key = .{
.key = if (ir.Event.KeyEvent.uChar.AsciiChar == ir.Event.KeyEvent.uChar.UnicodeChar)
(if (ir.Event.KeyEvent.uChar.AsciiChar == 0)
(if (types.VirtualKey.fromValue(ir.Event.KeyEvent.wVirtualKeyCode)) |v|
types.Key{ .virtual_key = v }
else
types.Key{ .unknown = {} })
else
types.Key{ .ascii = ir.Event.KeyEvent.uChar.AsciiChar })
else
types.Key{ .unicode = ir.Event.KeyEvent.uChar.UnicodeChar },
.is_down = if (ir.Event.KeyEvent.bKeyDown == 0) false else true,
.control_keys = utils.fromUnsigned(types.ControlKeys, ir.Event.KeyEvent.dwControlKeyState),
} };
},
c.MOUSE_EVENT => {
var flags = utils.fromUnsigned(types.MouseFlags, ir.Event.MouseEvent.dwEventFlags);
return Self{ .mouse = .{
.abs_coords = @bitCast(types.Coords, ir.Event.MouseEvent.dwMousePosition),
.mouse_buttons = utils.fromUnsigned(types.MouseButtons, ir.Event.MouseEvent.dwButtonState),
.mouse_flags = flags,
.mouse_scroll_direction = if (flags.mouse_wheeled)
(if (ir.Event.MouseEvent.dwButtonState & 0xFF000000 == 0xFF000000)
types.MouseScrollDirection.down
else
types.MouseScrollDirection.up)
else if (flags.mouse_hwheeled)
(if (ir.Event.MouseEvent.dwButtonState & 0xFF000000 == 0xFF000000)
types.MouseScrollDirection.left
else
types.MouseScrollDirection.right)
else
null,
.control_keys = utils.fromUnsigned(types.ControlKeys, ir.Event.MouseEvent.dwControlKeyState),
} };
},
c.WINDOW_BUFFER_SIZE_EVENT => {
return Self{ .window_buffer_size = @bitCast(types.Coords, ir.Event.WindowBufferSizeEvent.dwSize) };
},
c.MENU_EVENT => {
return Self{ .menu = ir.Event.MenuEvent.dwCommandId };
},
c.FOCUS_EVENT => {
return Self{ .focus = if (ir.Event.FocusEvent.bSetFocus == 0) false else true };
},
else => std.debug.panic("Not implemented: {}!\n", .{ir.EventType}),
}
}
}; | src/events.zig |
const std = @import("std");
const Allocator = mem.Allocator;
const mem = std.mem;
const ast = std.zig.ast;
const Visib = @import("visib.zig").Visib;
const event = std.event;
const Value = @import("value.zig").Value;
const Token = std.zig.Token;
const errmsg = @import("errmsg.zig");
const Scope = @import("scope.zig").Scope;
const Compilation = @import("compilation.zig").Compilation;
pub const Decl = struct {
id: Id,
name: []const u8,
visib: Visib,
resolution: event.Future(Compilation.BuildError!void),
parent_scope: *Scope,
// TODO when we destroy the decl, deref the tree scope
tree_scope: *Scope.AstTree,
pub const Table = std.StringHashMap(*Decl);
pub fn cast(base: *Decl, comptime T: type) ?*T {
if (base.id != @field(Id, @typeName(T))) return null;
return @fieldParentPtr(T, "base", base);
}
pub fn isExported(base: *const Decl, tree: *ast.Tree) bool {
switch (base.id) {
Id.Fn => {
const fn_decl = @fieldParentPtr(Fn, "base", base);
return fn_decl.isExported(tree);
},
else => return false,
}
}
pub fn getSpan(base: *const Decl) errmsg.Span {
switch (base.id) {
Id.Fn => {
const fn_decl = @fieldParentPtr(Fn, "base", base);
const fn_proto = fn_decl.fn_proto;
const start = fn_proto.fn_token;
const end = fn_proto.name_token orelse start;
return errmsg.Span{
.first = start,
.last = end + 1,
};
},
else => @panic("TODO"),
}
}
pub fn findRootScope(base: *const Decl) *Scope.Root {
return base.parent_scope.findRoot();
}
pub const Id = enum {
Var,
Fn,
CompTime,
};
pub const Var = struct {
base: Decl,
};
pub const Fn = struct {
base: Decl,
value: Val,
fn_proto: *ast.Node.FnProto,
// TODO https://github.com/ziglang/zig/issues/683 and then make this anonymous
pub const Val = union(enum) {
Unresolved: void,
Fn: *Value.Fn,
FnProto: *Value.FnProto,
};
pub fn externLibName(self: Fn, tree: *ast.Tree) ?[]const u8 {
return if (self.fn_proto.extern_export_inline_token) |tok_index| x: {
const token = tree.tokens.at(tok_index);
break :x switch (token.id) {
Token.Id.Extern => tree.tokenSlicePtr(token),
else => null,
};
} else null;
}
pub fn isExported(self: Fn, tree: *ast.Tree) bool {
if (self.fn_proto.extern_export_inline_token) |tok_index| {
const token = tree.tokens.at(tok_index);
return token.id == Token.Id.Keyword_export;
} else {
return false;
}
}
};
pub const CompTime = struct {
base: Decl,
};
}; | src-self-hosted/decl.zig |
const std = @import("../std.zig");
const Cpu = std.Target.Cpu;
pub const Feature = enum {
@"64bit",
@"64bitregs",
altivec,
booke,
bpermd,
cmpb,
crbits,
crypto,
direct_move,
e500,
extdiv,
fcpsgn,
float128,
fpcvt,
fprnd,
fpu,
fre,
fres,
frsqrte,
frsqrtes,
fsqrt,
hard_float,
htm,
icbt,
invariant_function_descriptors,
isa_v30_instructions,
isel,
ldbrx,
lfiwax,
longcall,
mfocrf,
msync,
partword_atomics,
popcntd,
power8_altivec,
power8_vector,
power9_altivec,
power9_vector,
ppc_postra_sched,
ppc_prera_sched,
ppc4xx,
ppc6xx,
qpx,
recipprec,
secure_plt,
slow_popcntd,
spe,
stfiwx,
two_const_nr,
vectors_use_two_units,
vsx,
};
pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.@"64bit")] = .{
.llvm_name = "64bit",
.description = "Enable 64-bit instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.@"64bitregs")] = .{
.llvm_name = "64bitregs",
.description = "Enable 64-bit registers usage for ppc32 [beta]",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.altivec)] = .{
.llvm_name = "altivec",
.description = "Enable Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.booke)] = .{
.llvm_name = "booke",
.description = "Enable Book E instructions",
.dependencies = featureSet(&[_]Feature{
.icbt,
}),
};
result[@enumToInt(Feature.bpermd)] = .{
.llvm_name = "bpermd",
.description = "Enable the bpermd instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.cmpb)] = .{
.llvm_name = "cmpb",
.description = "Enable the cmpb instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crbits)] = .{
.llvm_name = "crbits",
.description = "Use condition-register bits individually",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crypto)] = .{
.llvm_name = "crypto",
.description = "Enable POWER8 Crypto instructions",
.dependencies = featureSet(&[_]Feature{
.power8_altivec,
}),
};
result[@enumToInt(Feature.direct_move)] = .{
.llvm_name = "direct-move",
.description = "Enable Power8 direct move instructions",
.dependencies = featureSet(&[_]Feature{
.vsx,
}),
};
result[@enumToInt(Feature.e500)] = .{
.llvm_name = "e500",
.description = "Enable E500/E500mc instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.extdiv)] = .{
.llvm_name = "extdiv",
.description = "Enable extended divide instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fcpsgn)] = .{
.llvm_name = "fcpsgn",
.description = "Enable the fcpsgn instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.float128)] = .{
.llvm_name = "float128",
.description = "Enable the __float128 data type for IEEE-754R Binary128.",
.dependencies = featureSet(&[_]Feature{
.vsx,
}),
};
result[@enumToInt(Feature.fpcvt)] = .{
.llvm_name = "fpcvt",
.description = "Enable fc[ft]* (unsigned and single-precision) and lfiwzx instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fprnd)] = .{
.llvm_name = "fprnd",
.description = "Enable the fri[mnpz] instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fpu)] = .{
.llvm_name = "fpu",
.description = "Enable classic FPU instructions",
.dependencies = featureSet(&[_]Feature{
.hard_float,
}),
};
result[@enumToInt(Feature.fre)] = .{
.llvm_name = "fre",
.description = "Enable the fre instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fres)] = .{
.llvm_name = "fres",
.description = "Enable the fres instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.frsqrte)] = .{
.llvm_name = "frsqrte",
.description = "Enable the frsqrte instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.frsqrtes)] = .{
.llvm_name = "frsqrtes",
.description = "Enable the frsqrtes instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fsqrt)] = .{
.llvm_name = "fsqrt",
.description = "Enable the fsqrt instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.hard_float)] = .{
.llvm_name = "hard-float",
.description = "Enable floating-point instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.htm)] = .{
.llvm_name = "htm",
.description = "Enable Hardware Transactional Memory instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.icbt)] = .{
.llvm_name = "icbt",
.description = "Enable icbt instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.invariant_function_descriptors)] = .{
.llvm_name = "invariant-function-descriptors",
.description = "Assume function descriptors are invariant",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.isa_v30_instructions)] = .{
.llvm_name = "isa-v30-instructions",
.description = "Enable instructions added in ISA 3.0.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.isel)] = .{
.llvm_name = "isel",
.description = "Enable the isel instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ldbrx)] = .{
.llvm_name = "ldbrx",
.description = "Enable the ldbrx instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.lfiwax)] = .{
.llvm_name = "lfiwax",
.description = "Enable the lfiwax instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.longcall)] = .{
.llvm_name = "longcall",
.description = "Always use indirect calls",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mfocrf)] = .{
.llvm_name = "mfocrf",
.description = "Enable the MFOCRF instruction",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.msync)] = .{
.llvm_name = "msync",
.description = "Has only the msync instruction instead of sync",
.dependencies = featureSet(&[_]Feature{
.booke,
}),
};
result[@enumToInt(Feature.partword_atomics)] = .{
.llvm_name = "partword-atomics",
.description = "Enable l[bh]arx and st[bh]cx.",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.popcntd)] = .{
.llvm_name = "popcntd",
.description = "Enable the popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.power8_altivec)] = .{
.llvm_name = "power8-altivec",
.description = "Enable POWER8 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.altivec,
}),
};
result[@enumToInt(Feature.power8_vector)] = .{
.llvm_name = "power8-vector",
.description = "Enable POWER8 vector instructions",
.dependencies = featureSet(&[_]Feature{
.power8_altivec,
.vsx,
}),
};
result[@enumToInt(Feature.power9_altivec)] = .{
.llvm_name = "power9-altivec",
.description = "Enable POWER9 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v30_instructions,
.power8_altivec,
}),
};
result[@enumToInt(Feature.power9_vector)] = .{
.llvm_name = "power9-vector",
.description = "Enable POWER9 vector instructions",
.dependencies = featureSet(&[_]Feature{
.isa_v30_instructions,
.power8_vector,
.power9_altivec,
}),
};
result[@enumToInt(Feature.ppc_postra_sched)] = .{
.llvm_name = "ppc-postra-sched",
.description = "Use PowerPC post-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc_prera_sched)] = .{
.llvm_name = "ppc-prera-sched",
.description = "Use PowerPC pre-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc4xx)] = .{
.llvm_name = "ppc4xx",
.description = "Enable PPC 4xx instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc6xx)] = .{
.llvm_name = "ppc6xx",
.description = "Enable PPC 6xx instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.qpx)] = .{
.llvm_name = "qpx",
.description = "Enable QPX instructions",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.recipprec)] = .{
.llvm_name = "recipprec",
.description = "Assume higher precision reciprocal estimates",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.secure_plt)] = .{
.llvm_name = "secure-plt",
.description = "Enable secure plt mode",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_popcntd)] = .{
.llvm_name = "slow-popcntd",
.description = "Has slow popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.spe)] = .{
.llvm_name = "spe",
.description = "Enable SPE instructions",
.dependencies = featureSet(&[_]Feature{
.hard_float,
}),
};
result[@enumToInt(Feature.stfiwx)] = .{
.llvm_name = "stfiwx",
.description = "Enable the stfiwx instruction",
.dependencies = featureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.two_const_nr)] = .{
.llvm_name = "two-const-nr",
.description = "Requires two constant Newton-Raphson computation",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vectors_use_two_units)] = .{
.llvm_name = "vectors-use-two-units",
.description = "Vectors use two units",
.dependencies = featureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vsx)] = .{
.llvm_name = "vsx",
.description = "Enable VSX instructions",
.dependencies = featureSet(&[_]Feature{
.altivec,
}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
}
break :blk result;
};
pub const cpu = struct {
pub const @"440" = Cpu{
.name = "440",
.llvm_name = "440",
.features = featureSet(&[_]Feature{
.booke,
.fres,
.frsqrte,
.icbt,
.isel,
.msync,
}),
};
pub const @"450" = Cpu{
.name = "450",
.llvm_name = "450",
.features = featureSet(&[_]Feature{
.booke,
.fres,
.frsqrte,
.icbt,
.isel,
.msync,
}),
};
pub const @"601" = Cpu{
.name = "601",
.llvm_name = "601",
.features = featureSet(&[_]Feature{
.fpu,
}),
};
pub const @"602" = Cpu{
.name = "602",
.llvm_name = "602",
.features = featureSet(&[_]Feature{
.fpu,
}),
};
pub const @"603" = Cpu{
.name = "603",
.llvm_name = "603",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"603e" = Cpu{
.name = "603e",
.llvm_name = "603e",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"603ev" = Cpu{
.name = "603ev",
.llvm_name = "603ev",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"604" = Cpu{
.name = "604",
.llvm_name = "604",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"604e" = Cpu{
.name = "604e",
.llvm_name = "604e",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"620" = Cpu{
.name = "620",
.llvm_name = "620",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"7400" = Cpu{
.name = "7400",
.llvm_name = "7400",
.features = featureSet(&[_]Feature{
.altivec,
.fres,
.frsqrte,
}),
};
pub const @"7450" = Cpu{
.name = "7450",
.llvm_name = "7450",
.features = featureSet(&[_]Feature{
.altivec,
.fres,
.frsqrte,
}),
};
pub const @"750" = Cpu{
.name = "750",
.llvm_name = "750",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const @"970" = Cpu{
.name = "970",
.llvm_name = "970",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fres,
.frsqrte,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const a2 = Cpu{
.name = "a2",
.llvm_name = "a2",
.features = featureSet(&[_]Feature{
.@"64bit",
.booke,
.cmpb,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.icbt,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.recipprec,
.slow_popcntd,
.stfiwx,
}),
};
pub const a2q = Cpu{
.name = "a2q",
.llvm_name = "a2q",
.features = featureSet(&[_]Feature{
.@"64bit",
.booke,
.cmpb,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.icbt,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.qpx,
.recipprec,
.slow_popcntd,
.stfiwx,
}),
};
pub const e500 = Cpu{
.name = "e500",
.llvm_name = "e500",
.features = featureSet(&[_]Feature{
.booke,
.icbt,
.isel,
}),
};
pub const e500mc = Cpu{
.name = "e500mc",
.llvm_name = "e500mc",
.features = featureSet(&[_]Feature{
.booke,
.icbt,
.isel,
.stfiwx,
}),
};
pub const e5500 = Cpu{
.name = "e5500",
.llvm_name = "e5500",
.features = featureSet(&[_]Feature{
.@"64bit",
.booke,
.icbt,
.isel,
.mfocrf,
.stfiwx,
}),
};
pub const g3 = Cpu{
.name = "g3",
.llvm_name = "g3",
.features = featureSet(&[_]Feature{
.fres,
.frsqrte,
}),
};
pub const g4 = Cpu{
.name = "g4",
.llvm_name = "g4",
.features = featureSet(&[_]Feature{
.altivec,
.fres,
.frsqrte,
}),
};
pub const @"g4+" = Cpu{
.name = "g4+",
.llvm_name = "g4+",
.features = featureSet(&[_]Feature{
.altivec,
.fres,
.frsqrte,
}),
};
pub const g5 = Cpu{
.name = "g5",
.llvm_name = "g5",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fres,
.frsqrte,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{
.hard_float,
}),
};
pub const ppc = Cpu{
.name = "ppc",
.llvm_name = "ppc",
.features = featureSet(&[_]Feature{
.hard_float,
}),
};
pub const ppc32 = Cpu{
.name = "ppc32",
.llvm_name = "ppc32",
.features = featureSet(&[_]Feature{
.hard_float,
}),
};
pub const ppc64 = Cpu{
.name = "ppc64",
.llvm_name = "ppc64",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fres,
.frsqrte,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const ppc64le = Cpu{
.name = "ppc64le",
.llvm_name = "ppc64le",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.bpermd,
.cmpb,
.crypto,
.direct_move,
.extdiv,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.htm,
.icbt,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.partword_atomics,
.popcntd,
.power8_altivec,
.power8_vector,
.recipprec,
.stfiwx,
.two_const_nr,
.vsx,
}),
};
pub const pwr3 = Cpu{
.name = "pwr3",
.llvm_name = "pwr3",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fres,
.frsqrte,
.mfocrf,
.stfiwx,
}),
};
pub const pwr4 = Cpu{
.name = "pwr4",
.llvm_name = "pwr4",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fres,
.frsqrte,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const pwr5 = Cpu{
.name = "pwr5",
.llvm_name = "pwr5",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const pwr5x = Cpu{
.name = "pwr5x",
.llvm_name = "pwr5x",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.mfocrf,
.stfiwx,
}),
};
pub const pwr6 = Cpu{
.name = "pwr6",
.llvm_name = "pwr6",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.cmpb,
.fcpsgn,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.lfiwax,
.mfocrf,
.recipprec,
.stfiwx,
}),
};
pub const pwr6x = Cpu{
.name = "pwr6x",
.llvm_name = "pwr6x",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.cmpb,
.fcpsgn,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.lfiwax,
.mfocrf,
.recipprec,
.stfiwx,
}),
};
pub const pwr7 = Cpu{
.name = "pwr7",
.llvm_name = "pwr7",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.bpermd,
.cmpb,
.extdiv,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.popcntd,
.recipprec,
.stfiwx,
.two_const_nr,
.vsx,
}),
};
pub const pwr8 = Cpu{
.name = "pwr8",
.llvm_name = "pwr8",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.bpermd,
.cmpb,
.crypto,
.direct_move,
.extdiv,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.htm,
.icbt,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.partword_atomics,
.popcntd,
.power8_altivec,
.power8_vector,
.recipprec,
.stfiwx,
.two_const_nr,
.vsx,
}),
};
pub const pwr9 = Cpu{
.name = "pwr9",
.llvm_name = "pwr9",
.features = featureSet(&[_]Feature{
.@"64bit",
.altivec,
.bpermd,
.cmpb,
.crypto,
.direct_move,
.extdiv,
.fcpsgn,
.fpcvt,
.fprnd,
.fre,
.fres,
.frsqrte,
.frsqrtes,
.fsqrt,
.htm,
.icbt,
.isa_v30_instructions,
.isel,
.ldbrx,
.lfiwax,
.mfocrf,
.partword_atomics,
.popcntd,
.power8_altivec,
.power8_vector,
.power9_altivec,
.power9_vector,
.ppc_postra_sched,
.ppc_prera_sched,
.recipprec,
.stfiwx,
.two_const_nr,
.vectors_use_two_units,
.vsx,
}),
};
};
/// All powerpc CPUs, sorted alphabetically by name.
/// TODO: Replace this with usage of `std.meta.declList`. It does work, but stage1
/// compiler has inefficient memory and CPU usage, affecting build times.
pub const all_cpus = &[_]*const Cpu{
&cpu.@"440",
&cpu.@"450",
&cpu.@"601",
&cpu.@"602",
&cpu.@"603",
&cpu.@"603e",
&cpu.@"603ev",
&cpu.@"604",
&cpu.@"604e",
&cpu.@"620",
&cpu.@"7400",
&cpu.@"7450",
&cpu.@"750",
&cpu.@"970",
&cpu.a2,
&cpu.a2q,
&cpu.e500,
&cpu.e500mc,
&cpu.e5500,
&cpu.g3,
&cpu.g4,
&cpu.@"g4+",
&cpu.g5,
&cpu.generic,
&cpu.ppc,
&cpu.ppc32,
&cpu.ppc64,
&cpu.ppc64le,
&cpu.pwr3,
&cpu.pwr4,
&cpu.pwr5,
&cpu.pwr5x,
&cpu.pwr6,
&cpu.pwr6x,
&cpu.pwr7,
&cpu.pwr8,
&cpu.pwr9,
}; | lib/std/target/powerpc.zig |
const builtin = @import("builtin");
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const Node = ast.Node;
const Token = std.zig.Token;
const Tree = ast.Tree;
const ast = std.zig.ast;
const mem = std.mem;
const parse = std.zig.parse;
const sort = std.sort.sort;
const warn = std.debug.warn;
pub const Object = struct {
parent: ?*Scope,
position: Token,
package: ?*Package,
name: []const u8,
id: []const u8,
order: usize,
color: Color,
sameIdFn: fn (self: *Object, pkg: *Package, name: []const u8) bool,
/// The start position for the scope that conains this object.
scope_position: Token,
pub const Map = std.AutoHashMap([]const u8, *Object);
pub const Var = struct {
object: Object,
bound: ?bool,
};
pub const Color = enum {
White,
Black,
Grey,
};
pub fn format(
self: *Object,
comptime fmt: []const u8,
comptime options: std.fmt.FormatOptions,
context: var,
comptime Errors: type,
output: fn (@typeOf(context), []const u8) Errors!void,
) Errors!void {
return self.formatFn(self, fmt, context, Errors, output);
}
fn sameIdFn(self: *Object, pkg: *Package, name: []const u8) bool {
return self.sameIdFn(self, pkg, name);
}
};
pub const Type = struct {
id: Id,
pub const Basic = struct {
base: Type,
id: builtin.TypeId,
name: []const u8,
};
pub const Array = struct {
length: usize,
element: *Type,
};
pub const Slice = struct {
element: *Type,
};
pub const Container = struct {
members: std.ArrayList(*Object.Var),
};
pub const Pointer = struct {
base_type: *Type,
};
pub const Id = enum {
Basic,
Array,
Slice,
Container,
Pointer,
Signature,
Mao,
Named,
};
pub fn format(
self: *const Type,
comptime fmt: []const u8,
comptime options: std.fmt.FormatOptions,
context: var,
comptime Errors: type,
output: fn (@typeOf(context), []const u8) Errors!void,
) Errors!void {
return self.defaultFormat(fmt, context, Errors, output);
}
pub fn defaultFormat(
self: *const Type,
comptime fmt: []const u8,
context: var,
comptime Errors: type,
output: fn (@typeOf(context), []const u8) Errors!void,
) Errors!void {
switch (self.id) {
.Basic => {
const basic_decl = @fieldParentPtr(Basic, "base", self);
try output(context, basic_decl.name);
},
else => unreachable,
}
}
};
pub const StringSlice = ArrayList([]const u8);
pub const Scope = struct {
parent: *Scope,
children: List,
elements: Object.Map,
token: ?Token,
is_func: bool,
pub const List = ArrayList(*Scope);
fn create(a: *Allocator, parent: ?*Scope) !*Scope {
var s = try a.create(Scope);
s.* = Scope{
.parent = parent,
.children = List.init(a),
.elements = Map.init(a),
.token = null,
.is_func = false,
};
return s;
}
fn addSymbol(
self: *Scope,
parent: ?*Scope,
name: []const u8,
node: *Node,
) !void {}
/// returns a scope's element names in sorted order.
fn names(self: *Scope, a: *Allocator) !StringSlice {
var ls = StringSlice.init(a);
var it = self.elements.iterator();
while (it.next()) |next| {
try ls.append(next.key);
}
sort([]const u8, ls.toSlice(), stringSortFn);
return ls;
}
// / returns an object with name that is is the scope, it reyurns null if
// the object doesn't exist.
pub fn lookup(self: *Scope, name: []const u8) ?*Object {
if (self.elements.get(name)) |kv| {
return kv.value;
}
return null;
}
fn stringSortFn(lhs: []const u8, rhs: []const u8) bool {
return mem.compare(u8, lhs, rhs) == .LessThan;
}
};
/// Package defines a repesentation of a zig source file.
pub const Package = struct {
name: []const u8,
tree: ?Tree,
scope: ?*Scope,
imports: ?List,
pub const List = std.ArrayList(*Package);
};
test "Type.format" {
const basic = Type.Basic{
.base = Type{
.id = .Basic,
},
.name = "basic_number",
.id = .Int,
};
var typ = &basic.base;
warn("{}\n", typ);
} | src/zig/types.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const testing = std.testing;
const expect = testing.expect;
usingnamespace @import("csv");
var default_buffer = [_]u8{0} ** 1024;
fn getTokenizer(file: std.fs.File, buffer: []u8, config: CsvConfig) !CsvTokenizer(std.fs.File.Reader) {
const reader = file.reader();
const csv = try CsvTokenizer(std.fs.File.Reader).init(reader, buffer, config);
return csv;
}
fn expectToken(comptime expected: CsvToken, maybe_actual: ?CsvToken) !void {
if (maybe_actual) |actual| {
if (@enumToInt(expected) != @enumToInt(actual)) {
std.log.warn("Expected {} but is {}\n", .{ expected, actual });
return error.TestFailed;
}
switch (expected) {
.field => {
testing.expectEqualStrings(expected.field, actual.field);
},
else => {},
}
} else {
std.log.warn("Expected {} but is {}\n", .{ expected, maybe_actual });
return error.TestFailed;
}
}
test "Create iterator for file reader" {
const file = try std.fs.cwd().openFile("test/resources/test-1.csv", .{});
defer file.close();
const csv = try getTokenizer(file, &default_buffer, .{});
}
test "Read single simple record from file" {
const file = try std.fs.cwd().openFile("test/resources/test-1.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, &default_buffer, .{});
try expectToken(CsvToken{ .field = "1" }, try csv.next());
try expectToken(CsvToken{ .field = "abc" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
expect((try csv.next()) == null);
}
test "Read multiple simple records from file" {
const file = try std.fs.cwd().openFile("test/resources/test-2.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, &default_buffer, .{});
try expectToken(CsvToken{ .field = "1" }, try csv.next());
try expectToken(CsvToken{ .field = "abc" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
try expectToken(CsvToken{ .field = "2" }, try csv.next());
try expectToken(CsvToken{ .field = "def ghc" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
expect((try csv.next()) == null);
}
test "Read quoted fields" {
const file = try std.fs.cwd().openFile("test/resources/test-4.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, &default_buffer, .{});
try expectToken(CsvToken{ .field = "1" }, try csv.next());
try expectToken(CsvToken{ .field = "def ghc" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
try expectToken(CsvToken{ .field = "2" }, try csv.next());
try expectToken(CsvToken{ .field = "abc \"def\"" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
expect((try csv.next()) == null);
}
test "Second read is necessary to obtain field" {
const file = try std.fs.cwd().openFile("test/resources/test-read-required-for-field.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, default_buffer[0..6], .{});
try expectToken(CsvToken{ .field = "12345" }, try csv.next());
try expectToken(CsvToken{ .field = "67890" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
expect((try csv.next()) == null);
}
test "File is empty" {
const file = try std.fs.cwd().openFile("test/resources/test-empty.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, &default_buffer, .{});
expect((try csv.next()) == null);
}
test "Field is longer than buffer" {
const file = try std.fs.cwd().openFile("test/resources/test-error-short-buffer.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, default_buffer[0..9], .{});
const field1 = csv.next();
if (field1) {
unreachable;
} else |err| {
expect(err == CsvError.ShortBuffer);
}
}
test "Quoted field is longer than buffer" {
const file = try std.fs.cwd().openFile("test/resources/test-error-short-buffer-quoted.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, default_buffer[0..10], .{});
const field1 = csv.next();
if (field1) {
unreachable;
} else |err| {
expect(err == CsvError.ShortBuffer);
}
}
test "Quoted field with double quotes is longer than buffer" {
const file = try std.fs.cwd().openFile("test/resources/test-error-short-buffer-quoted-with-double.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, default_buffer[0..11], .{});
const field1 = csv.next();
if (field1) {
unreachable;
} else |err| {
expect(err == CsvError.ShortBuffer);
}
}
test "Quoted field with double quotes can be read on retry" {
const file = try std.fs.cwd().openFile("test/resources/test-error-short-buffer-quoted-with-double.csv", .{});
defer file.close();
const csv = &try getTokenizer(file, default_buffer[0..14], .{});
try expectToken(CsvToken{ .field = "1234567890\"" }, try csv.next());
try expectToken(CsvToken{ .row_end = {} }, try csv.next());
expect((try csv.next()) == null);
}
// TODO test last line with new line and without | test/csv_tokenizer.zig |
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
usingnamespace @import("../parse.zig");
test "explicit doc" {
const source =
\\--- !tapi-tbd
\\tbd-version: 4
\\abc-version: 5
\\...
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
const directive = tree.tokens[doc.directive.?];
try testing.expectEqual(directive.id, .Literal);
try testing.expect(mem.eql(u8, "tapi-tbd", tree.source[directive.start..directive.end]));
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 5);
try testing.expectEqual(map.end.?, 14);
try testing.expectEqual(map.values.items.len, 2);
{
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "tbd-version", tree.source[key.start..key.end]));
const value = entry.value.cast(Node.Value).?;
const value_tok = tree.tokens[value.start.?];
try testing.expectEqual(value_tok.id, .Literal);
try testing.expect(mem.eql(u8, "4", tree.source[value_tok.start..value_tok.end]));
}
{
const entry = map.values.items[1];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "abc-version", tree.source[key.start..key.end]));
const value = entry.value.cast(Node.Value).?;
const value_tok = tree.tokens[value.start.?];
try testing.expectEqual(value_tok.id, .Literal);
try testing.expect(mem.eql(u8, "5", tree.source[value_tok.start..value_tok.end]));
}
}
test "leaf in quotes" {
const source =
\\key1: no quotes
\\key2: 'single quoted'
\\key3: "double quoted"
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.directive == null);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 0);
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
try testing.expectEqual(map.values.items.len, 3);
{
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(
u8,
"key1",
tree.source[key.start..key.end],
));
const value = entry.value.cast(Node.Value).?;
const start = tree.tokens[value.start.?];
const end = tree.tokens[value.end.?];
try testing.expectEqual(start.id, .Literal);
try testing.expectEqual(end.id, .Literal);
try testing.expect(mem.eql(
u8,
"no quotes",
tree.source[start.start..end.end],
));
}
}
test "nested maps" {
const source =
\\key1:
\\ key1_1 : value1_1
\\ key1_2 : value1_2
\\key2 : value2
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.directive == null);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 0);
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
try testing.expectEqual(map.values.items.len, 2);
{
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "key1", tree.source[key.start..key.end]));
const nested_map = entry.value.cast(Node.Map).?;
try testing.expectEqual(nested_map.start.?, 4);
try testing.expectEqual(nested_map.end.?, 16);
try testing.expectEqual(nested_map.values.items.len, 2);
{
const nested_entry = nested_map.values.items[0];
const nested_key = tree.tokens[nested_entry.key];
try testing.expectEqual(nested_key.id, .Literal);
try testing.expect(mem.eql(
u8,
"key1_1",
tree.source[nested_key.start..nested_key.end],
));
const nested_value = nested_entry.value.cast(Node.Value).?;
const nested_value_tok = tree.tokens[nested_value.start.?];
try testing.expectEqual(nested_value_tok.id, .Literal);
try testing.expect(mem.eql(
u8,
"value1_1",
tree.source[nested_value_tok.start..nested_value_tok.end],
));
}
{
const nested_entry = nested_map.values.items[1];
const nested_key = tree.tokens[nested_entry.key];
try testing.expectEqual(nested_key.id, .Literal);
try testing.expect(mem.eql(
u8,
"key1_2",
tree.source[nested_key.start..nested_key.end],
));
const nested_value = nested_entry.value.cast(Node.Value).?;
const nested_value_tok = tree.tokens[nested_value.start.?];
try testing.expectEqual(nested_value_tok.id, .Literal);
try testing.expect(mem.eql(
u8,
"value1_2",
tree.source[nested_value_tok.start..nested_value_tok.end],
));
}
}
{
const entry = map.values.items[1];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "key2", tree.source[key.start..key.end]));
const value = entry.value.cast(Node.Value).?;
const value_tok = tree.tokens[value.start.?];
try testing.expectEqual(value_tok.id, .Literal);
try testing.expect(mem.eql(
u8,
"value2",
tree.source[value_tok.start..value_tok.end],
));
}
}
test "map of list of values" {
const source =
\\ints:
\\ - 0
\\ - 1
\\ - 2
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 0);
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
try testing.expectEqual(map.values.items.len, 1);
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "ints", tree.source[key.start..key.end]));
const value = entry.value.cast(Node.List).?;
try testing.expectEqual(value.start.?, 4);
try testing.expectEqual(value.end.?, tree.tokens.len - 2);
try testing.expectEqual(value.values.items.len, 3);
{
const elem = value.values.items[0].cast(Node.Value).?;
const leaf = tree.tokens[elem.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "0", tree.source[leaf.start..leaf.end]));
}
{
const elem = value.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[elem.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "1", tree.source[leaf.start..leaf.end]));
}
{
const elem = value.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[elem.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "2", tree.source[leaf.start..leaf.end]));
}
}
test "map of list of maps" {
const source =
\\key1:
\\- key2 : value2
\\- key3 : value3
\\- key4 : value4
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 0);
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
try testing.expectEqual(map.values.items.len, 1);
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "key1", tree.source[key.start..key.end]));
const value = entry.value.cast(Node.List).?;
try testing.expectEqual(value.start.?, 3);
try testing.expectEqual(value.end.?, tree.tokens.len - 2);
try testing.expectEqual(value.values.items.len, 3);
{
const elem = value.values.items[0].cast(Node.Map).?;
const nested = elem.values.items[0];
const nested_key = tree.tokens[nested.key];
try testing.expectEqual(nested_key.id, .Literal);
try testing.expect(mem.eql(u8, "key2", tree.source[nested_key.start..nested_key.end]));
const nested_v = nested.value.cast(Node.Value).?;
const leaf = tree.tokens[nested_v.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "value2", tree.source[leaf.start..leaf.end]));
}
{
const elem = value.values.items[1].cast(Node.Map).?;
const nested = elem.values.items[0];
const nested_key = tree.tokens[nested.key];
try testing.expectEqual(nested_key.id, .Literal);
try testing.expect(mem.eql(u8, "key3", tree.source[nested_key.start..nested_key.end]));
const nested_v = nested.value.cast(Node.Value).?;
const leaf = tree.tokens[nested_v.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "value3", tree.source[leaf.start..leaf.end]));
}
{
const elem = value.values.items[2].cast(Node.Map).?;
const nested = elem.values.items[0];
const nested_key = tree.tokens[nested.key];
try testing.expectEqual(nested_key.id, .Literal);
try testing.expect(mem.eql(u8, "key4", tree.source[nested_key.start..nested_key.end]));
const nested_v = nested.value.cast(Node.Value).?;
const leaf = tree.tokens[nested_v.start.?];
try testing.expectEqual(leaf.id, .Literal);
try testing.expect(mem.eql(u8, "value4", tree.source[leaf.start..leaf.end]));
}
}
test "list of lists" {
const source =
\\- [name , hr, avg ]
\\- [<NAME> , 65, 0.278]
\\- [<NAME> , 63, 0.288]
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .list);
const list = doc.value.?.cast(Node.List).?;
try testing.expectEqual(list.start.?, 0);
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
try testing.expectEqual(list.values.items.len, 3);
{
try testing.expectEqual(list.values.items[0].tag, .list);
const nested = list.values.items[0].cast(Node.List).?;
try testing.expectEqual(nested.values.items.len, 3);
{
try testing.expectEqual(nested.values.items[0].tag, .value);
const value = nested.values.items[0].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(nested.values.items[1].tag, .value);
const value = nested.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(nested.values.items[2].tag, .value);
const value = nested.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
}
}
{
try testing.expectEqual(list.values.items[1].tag, .list);
const nested = list.values.items[1].cast(Node.List).?;
try testing.expectEqual(nested.values.items.len, 3);
{
try testing.expectEqual(nested.values.items[0].tag, .value);
const value = nested.values.items[0].cast(Node.Value).?;
const start = tree.tokens[value.start.?];
const end = tree.tokens[value.end.?];
try testing.expect(mem.eql(u8, "<NAME>", tree.source[start.start..end.end]));
}
{
try testing.expectEqual(nested.values.items[1].tag, .value);
const value = nested.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "65", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(nested.values.items[2].tag, .value);
const value = nested.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "0.278", tree.source[leaf.start..leaf.end]));
}
}
{
try testing.expectEqual(list.values.items[2].tag, .list);
const nested = list.values.items[2].cast(Node.List).?;
try testing.expectEqual(nested.values.items.len, 3);
{
try testing.expectEqual(nested.values.items[0].tag, .value);
const value = nested.values.items[0].cast(Node.Value).?;
const start = tree.tokens[value.start.?];
const end = tree.tokens[value.end.?];
try testing.expect(mem.eql(u8, "<NAME>", tree.source[start.start..end.end]));
}
{
try testing.expectEqual(nested.values.items[1].tag, .value);
const value = nested.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "63", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(nested.values.items[2].tag, .value);
const value = nested.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "0.288", tree.source[leaf.start..leaf.end]));
}
}
}
test "inline list" {
const source =
\\[name , hr, avg ]
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .list);
const list = doc.value.?.cast(Node.List).?;
try testing.expectEqual(list.start.?, 0);
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
try testing.expectEqual(list.values.items.len, 3);
{
try testing.expectEqual(list.values.items[0].tag, .value);
const value = list.values.items[0].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(list.values.items[1].tag, .value);
const value = list.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(list.values.items[2].tag, .value);
const value = list.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
}
}
test "inline list as mapping value" {
const source =
\\key : [
\\ name ,
\\ hr, avg ]
;
var tree = Tree.init(testing.allocator);
defer tree.deinit();
try tree.parse(source);
try testing.expectEqual(tree.docs.items.len, 1);
const doc = tree.docs.items[0].cast(Node.Doc).?;
try testing.expectEqual(doc.start.?, 0);
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
try testing.expect(doc.value != null);
try testing.expectEqual(doc.value.?.tag, .map);
const map = doc.value.?.cast(Node.Map).?;
try testing.expectEqual(map.start.?, 0);
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
try testing.expectEqual(map.values.items.len, 1);
const entry = map.values.items[0];
const key = tree.tokens[entry.key];
try testing.expectEqual(key.id, .Literal);
try testing.expect(mem.eql(u8, "key", tree.source[key.start..key.end]));
const list = entry.value.cast(Node.List).?;
try testing.expectEqual(list.start.?, 4);
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
try testing.expectEqual(list.values.items.len, 3);
{
try testing.expectEqual(list.values.items[0].tag, .value);
const value = list.values.items[0].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(list.values.items[1].tag, .value);
const value = list.values.items[1].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
}
{
try testing.expectEqual(list.values.items[2].tag, .value);
const value = list.values.items[2].cast(Node.Value).?;
const leaf = tree.tokens[value.start.?];
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
}
} | src/link/tapi/parse/test.zig |
const c = @import("main.zig").c;
const std = @import("std");
const assert = std.debug.assert;
const gui = @import("gui.zig");
// To check OpenGL for errors at runtime
const gl_safety_checks = true;
// Draw buffers for microui
const buffer_size: u32 = 16384;
var tex_buf = std.mem.zeroes([buffer_size * 8]f32);
var vert_buf = std.mem.zeroes([buffer_size * 8]f32);
var color_buf = std.mem.zeroes([buffer_size * 16]u8);
var index_buf = std.mem.zeroes([buffer_size * 6]u32);
// Window icon
var icon_loaded = false;
const icon_dat = @embedFile("../assets/icon.png");
var icon_surface: *(c.SDL_Surface) = undefined;
// Atlas
var atlas_loaded = false;
const atlas = @import("atlas.zig");
const atlas_dat = @embedFile("../assets/atlas.png");
var atlas_surface: *(c.SDL_Surface) = undefined;
// Window and OpenGL context
var ctx_gl: c.SDL_GLContext = undefined;
var window: *(c.SDL_Window) = undefined;
const window_flags: u32 = c.SDL_WINDOW_OPENGL | c.SDL_WINDOW_SHOWN | c.SDL_WINDOW_RESIZABLE;
const background_color: [4]f32 = .{ 14 / 255.0, 14 / 255.0, 14 / 255.0, 255.0 };
// Window info
var viewport_width: u16 = 800;
var viewport_height: u16 = 600;
var buf_idx: u32 = 0;
/// Initialize the renderer. This must be called before using any of the
/// interface functions. Behavior without a call to this func or calling this
/// more than once leads to non-deterministic behavior.
pub fn init() !void {
// Init the SDL library
if (c.SDL_Init(c.SDL_INIT_VIDEO) != 0) {
c.SDL_Log("Unable to initialize SDL: %s", c.SDL_GetError());
return error.SDLInitializationFailed;
}
errdefer c.SDL_Quit();
// Create a window
window = c.SDL_CreateWindow("Zig MicroUI Example", c.SDL_WINDOWPOS_UNDEFINED, c.SDL_WINDOWPOS_UNDEFINED, viewport_width, viewport_height, window_flags) orelse {
c.SDL_Log("Unable to create window: %s", c.SDL_GetError());
return error.SDLInitializationFailed;
};
errdefer c.SDL_DestroyWindow(window);
try readTexturePng(icon_dat, &icon_surface);
errdefer c.SDL_FreeSurface(icon_surface);
icon_loaded = true;
try readTexturePng(atlas_dat, &atlas_surface);
errdefer c.SDL_FreeSurface(atlas_surface);
assert(c.SDL_LockSurface(atlas_surface) == 0); // Makes pixel pointer valid
atlas_loaded = true;
// Set window icon
c.SDL_SetWindowIcon(window, icon_surface);
// Create a 2D context for the window
ctx_gl = c.SDL_GL_CreateContext(window) orelse {
c.SDL_Log("Unable to create GL context: %s", c.SDL_GetError());
return error.SDLInitializationFailed;
};
errdefer c.SDL_GL_DeleteContext(ctx_gl);
// Init OpenGL
c.glEnable(c.GL_BLEND);
c.glBlendFunc(c.GL_SRC_ALPHA, c.GL_ONE_MINUS_SRC_ALPHA);
c.glDisable(c.GL_CULL_FACE);
c.glDisable(c.GL_DEPTH_TEST);
c.glEnable(c.GL_TEXTURE_2D);
c.glEnableClientState(c.GL_VERTEX_ARRAY);
c.glEnableClientState(c.GL_TEXTURE_COORD_ARRAY);
c.glEnableClientState(c.GL_COLOR_ARRAY);
// Init texture
var texture_name: u32 = undefined;
c.glGenTextures(1, &texture_name);
c.glBindTexture(c.GL_TEXTURE_2D, texture_name);
c.glTexImage2D(c.GL_TEXTURE_2D, 0, c.GL_RGBA, atlas.width, atlas.height, 0, c.GL_RGBA, c.GL_UNSIGNED_BYTE, atlas_surface.pixels);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MIN_FILTER, c.GL_NEAREST);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MAG_FILTER, c.GL_NEAREST);
if (gl_safety_checks) {
assert(c.glGetError() == 0);
}
}
/// Performs cleanup of SDL etc... hence must be called before quitting.
pub fn deinit() void {
c.SDL_GL_DeleteContext(ctx_gl);
if (icon_loaded) {
c.SDL_FreeSurface(icon_surface);
}
if (atlas_loaded) {
c.SDL_FreeSurface(atlas_surface);
}
c.SDL_DestroyWindow(window);
c.SDL_Quit();
}
/// Handle window events. Returns true if the program should quit and false if
/// not.
pub fn handleEvents() bool {
// Handle SDL events
var e: c.SDL_Event = undefined;
while (c.SDL_PollEvent(&e) != 0) {
switch (e.type) {
c.SDL_QUIT => return true,
c.SDL_MOUSEMOTION => c.mu_input_mousemove(gui.ctx, e.motion.x, e.motion.y),
c.SDL_MOUSEWHEEL => c.mu_input_scroll(gui.ctx, 0, e.wheel.y * -30),
c.SDL_TEXTINPUT => c.mu_input_text(gui.ctx, &e.text.text),
c.SDL_MOUSEBUTTONDOWN, c.SDL_MOUSEBUTTONUP => {
const button = switch (e.button.button) {
c.SDL_BUTTON_LEFT => c.MU_MOUSE_LEFT,
c.SDL_BUTTON_RIGHT => c.MU_MOUSE_RIGHT,
c.SDL_BUTTON_MIDDLE => c.MU_MOUSE_MIDDLE,
else => 0,
};
if (button != 0 and e.type == c.SDL_MOUSEBUTTONDOWN) {
c.mu_input_mousedown(gui.ctx, e.button.x, e.button.y, button);
}
if (button != 0 and e.type == c.SDL_MOUSEBUTTONUP) {
c.mu_input_mouseup(gui.ctx, e.button.x, e.button.y, button);
}
},
c.SDL_KEYDOWN, c.SDL_KEYUP => {
var mu_char = switch (e.key.keysym.sym) {
c.SDLK_LSHIFT => c.MU_KEY_SHIFT,
c.SDLK_RSHIFT => c.MU_KEY_SHIFT,
c.SDLK_LCTRL => c.MU_KEY_CTRL,
c.SDLK_RCTRL => c.MU_KEY_CTRL,
c.SDLK_LALT => c.MU_KEY_ALT,
c.SDLK_RALT => c.MU_KEY_ALT,
c.SDLK_RETURN => c.MU_KEY_RETURN,
c.SDLK_BACKSPACE => c.MU_KEY_BACKSPACE,
else => 0,
};
if (mu_char != 0 and e.@"type" == c.SDL_KEYDOWN) {
c.mu_input_keydown(gui.ctx, mu_char);
}
if (mu_char != 0 and e.@"type" == c.SDL_KEYUP) {
c.mu_input_keyup(gui.ctx, mu_char);
}
},
c.SDL_WINDOWEVENT => {
if (e.window.event == c.SDL_WINDOWEVENT_SIZE_CHANGED) {
const width: u32 = @intCast(u32, e.window.data1);
const height: u32 = @intCast(u32, e.window.data2);
handleResize(width, height);
}
},
else => {},
}
}
return false;
}
pub fn drawRect(rect: c.mu_Rect, color: c.mu_Color) void {
pushQuad(rect, atlas.dict[atlas.white], color);
}
pub fn drawText(text: []const u8, pos: c.mu_Vec2, color: c.mu_Color) void {
var dst: c.mu_Rect = .{ .x = pos.x, .y = pos.y, .w = 0, .h = 0 };
for (text) |char| {
const chr: u8 = if (char < 127) char else 127;
const src: c.mu_Rect = atlas.dict[atlas.font + chr];
dst.w = src.w;
dst.h = src.h;
pushQuad(dst, src, color);
dst.x += dst.w;
}
}
pub fn drawIcon(id: u32, rect: c.mu_Rect, color: c.mu_Color) void {
const src: c.mu_Rect = atlas.dict[id];
const x: i32 = @intCast(i32, rect.x) + @divExact(rect.w - src.w, 2);
const y: i32 = @intCast(i32, rect.y) + @divExact(rect.h - src.h, 2);
pushQuad(c.mu_rect(x, y, src.w, src.h), src, color);
}
pub fn textWidth(text: []const u8) u16 {
var res: u16 = 0;
for (text) |char| {
const chr: u8 = if (char < 127) char else 127;
const width: c_int = atlas.dict[atlas.font + chr].w;
res += @intCast(u16, width);
}
return res;
}
pub fn textHeight() u16 {
return atlas.dict[atlas.font + 'a'].h;
}
pub fn rectClip(rect: c.mu_Rect) void {
flush();
c.glScissor(rect.x, viewport_height - (rect.y + rect.h), rect.w, rect.h);
}
/// Clear screen to default color
pub fn clear() void {
flush();
c.glClearColor(background_color[0], background_color[1], background_color[2], background_color[3]);
c.glClear(c.GL_COLOR_BUFFER_BIT);
}
/// Update screen with whatever was rendered in this frame
pub fn present() void {
flush();
c.SDL_GL_SwapWindow(window);
c.SDL_Delay(8); // Limit to ~120 fps
}
pub fn win_width() u16 {
return viewport_width;
}
pub fn win_height() u16 {
return viewport_height;
}
fn handleResize(width: u32, height: u32) void {
viewport_width = @intCast(u16, width);
viewport_height = @intCast(u16, height);
}
fn flush() void {
if (buf_idx == 0) {
return;
}
c.glViewport(0, 0, viewport_width, viewport_height);
c.glMatrixMode(c.GL_PROJECTION);
c.glPushMatrix();
c.glLoadIdentity();
c.glOrtho(0.0, @intToFloat(f64, viewport_width), @intToFloat(f64, viewport_height), 0.0, -1.0, 1.0);
c.glMatrixMode(c.GL_MODELVIEW);
c.glPushMatrix();
c.glLoadIdentity();
c.glTexCoordPointer(2, c.GL_FLOAT, 0, &tex_buf);
c.glVertexPointer(2, c.GL_FLOAT, 0, &vert_buf);
c.glColorPointer(4, c.GL_UNSIGNED_BYTE, 0, &color_buf);
c.glDrawElements(c.GL_TRIANGLES, @intCast(c_int, buf_idx * 6), c.GL_UNSIGNED_INT, &index_buf);
c.glMatrixMode(c.GL_MODELVIEW);
c.glPopMatrix();
c.glMatrixMode(c.GL_PROJECTION);
c.glPopMatrix();
buf_idx = 0;
}
fn readTextureBmp(bmp_data: []const u8, surface: **c.SDL_Surface) !void {
// Create a read only reader
var rwop: *(c.SDL_RWops) = c.SDL_RWFromConstMem(
@ptrCast(*const c_void, &bmp_data[0]),
@intCast(c_int, bmp_data.len),
) orelse {
c.SDL_Log("Unable to get RWFromConstMem: %s", c.SDL_GetError());
return error.SDLImgLoadFailed;
};
defer assert(c.SDL_RWclose(rwop) == 0);
// Create the surface
surface.* = c.SDL_LoadBMP_RW(rwop, 0) orelse {
c.SDL_Log("Unable to load bmp: %s", c.SDL_GetError());
return error.SDLImgLoadFailed;
};
errdefer c.SDL_FreeSurface(surface.*);
}
fn readTexturePng(png_data: []const u8, surface: **c.SDL_Surface) !void {
// Create a read only reader
var rwop: *(c.SDL_RWops) = c.SDL_RWFromConstMem(
@ptrCast(*const c_void, &png_data[0]),
@intCast(c_int, png_data.len),
) orelse {
c.SDL_Log("Unable to get RWFromConstMem: %s", c.SDL_GetError());
return error.SDLImgLoadFailed;
};
defer assert(c.SDL_RWclose(rwop) == 0);
// Create the surface
surface.* = c.IMG_LoadPNG_RW(rwop) orelse {
c.SDL_Log("Unable to load png: %s", c.SDL_GetError());
return error.SDLImgLoadFailed;
};
errdefer c.SDL_FreeSurface(surface.*);
}
fn pushQuad(dst: c.mu_Rect, src: c.mu_Rect, color: c.mu_Color) void {
if (buf_idx == buffer_size) {
flush();
}
const texvert_idx: u32 = buf_idx * 8;
const color_idx: u32 = buf_idx * 16;
const element_idx: u32 = buf_idx * 4;
const index_idx: u32 = buf_idx * 6;
buf_idx += 1;
// Update texture buffer
const x: f32 = @intToFloat(f32, src.x) / @intToFloat(f32, atlas.width);
const y: f32 = @intToFloat(f32, src.y) / @intToFloat(f32, atlas.height);
const w: f32 = @intToFloat(f32, src.w) / @intToFloat(f32, atlas.width);
const h: f32 = @intToFloat(f32, src.h) / @intToFloat(f32, atlas.height);
tex_buf[texvert_idx + 0] = x;
tex_buf[texvert_idx + 1] = y;
tex_buf[texvert_idx + 2] = x + w;
tex_buf[texvert_idx + 3] = y;
tex_buf[texvert_idx + 4] = x;
tex_buf[texvert_idx + 5] = y + h;
tex_buf[texvert_idx + 6] = x + w;
tex_buf[texvert_idx + 7] = y + h;
// Update vertex buffer
vert_buf[texvert_idx + 0] = @intToFloat(f32, dst.x);
vert_buf[texvert_idx + 1] = @intToFloat(f32, dst.y);
vert_buf[texvert_idx + 2] = @intToFloat(f32, dst.x + dst.w);
vert_buf[texvert_idx + 3] = @intToFloat(f32, dst.y);
vert_buf[texvert_idx + 4] = @intToFloat(f32, dst.x);
vert_buf[texvert_idx + 5] = @intToFloat(f32, dst.y + dst.h);
vert_buf[texvert_idx + 6] = @intToFloat(f32, dst.x + dst.w);
vert_buf[texvert_idx + 7] = @intToFloat(f32, dst.y + dst.h);
// Update color buffer
@memcpy(@ptrCast([*]u8, &color_buf[color_idx + 0]), @ptrCast([*]const u8, &color), 4);
@memcpy(@ptrCast([*]u8, &color_buf[color_idx + 4]), @ptrCast([*]const u8, &color), 4);
@memcpy(@ptrCast([*]u8, &color_buf[color_idx + 8]), @ptrCast([*]const u8, &color), 4);
@memcpy(@ptrCast([*]u8, &color_buf[color_idx + 12]), @ptrCast([*]const u8, &color), 4);
// Update index buffer
index_buf[index_idx + 0] = element_idx + 0;
index_buf[index_idx + 1] = element_idx + 1;
index_buf[index_idx + 2] = element_idx + 2;
index_buf[index_idx + 3] = element_idx + 2;
index_buf[index_idx + 4] = element_idx + 3;
index_buf[index_idx + 5] = element_idx + 1;
} | src/renderer.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const data = @embedFile("../inputs/day14.txt");
pub fn main() anyerror!void {
var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa_impl.deinit();
const gpa = gpa_impl.allocator();
return main_with_allocator(gpa);
}
pub fn main_with_allocator(allocator: Allocator) anyerror!void {
var polymer = try Polymer.parse(allocator, data[0..]);
defer polymer.deinit();
print("Part 1: {d}\n", .{try part1(allocator, polymer)});
print("Part 2: {d}\n", .{try part2(allocator, polymer)});
}
const Polymer = struct {
const Self = @This();
template: []const u8,
insertion_rules: std.AutoHashMap([2]u8, u8),
fn deinit(self: *Self) void {
self.insertion_rules.deinit();
}
fn parse(allocator: Allocator, input: []const u8) !Self {
var it = std.mem.split(u8, input, "\n\n");
const template = it.next().?;
var insertion_rules = std.AutoHashMap([2]u8, u8).init(allocator);
var lines = std.mem.tokenize(u8, it.next().?, "\n");
while (lines.next()) |line| {
var rule = std.mem.split(u8, line, " -> ");
const pair_str = rule.next().?;
const insert_str = rule.next().?;
const pair: [2]u8 = pair_str[0..2].*;
const insert: u8 = insert_str[0];
try insertion_rules.put(pair, insert);
}
return Self{
.template = template,
.insertion_rules = insertion_rules,
};
}
};
fn put_or_add(comptime K: type, comptime V: type, hm: *std.AutoHashMap(K, V), key: K, val: V) !void {
if (hm.getPtr(key)) |p| {
p.* += val;
} else {
try hm.put(key, val);
}
}
fn count_min_max(allocator: Allocator, polymer: Polymer, max_step: usize) !usize {
var pair_map = std.AutoHashMap([2]u8, usize).init(allocator);
defer pair_map.deinit();
var next_pair_map = std.AutoHashMap([2]u8, usize).init(allocator);
defer next_pair_map.deinit();
for (polymer.template) |c, i| {
if (i == 0) continue;
try put_or_add([2]u8, usize, &pair_map, [2]u8{ polymer.template[i - 1], c }, 1);
}
var step: usize = 0;
while (step < max_step) : (step += 1) {
next_pair_map.clearRetainingCapacity();
var it = pair_map.iterator();
while (it.next()) |e| {
const pair = e.key_ptr.*;
const count = e.value_ptr.*;
const insert = polymer.insertion_rules.get(pair).?;
const a = [2]u8{ pair[0], insert };
const b = [2]u8{ insert, pair[1] };
try put_or_add([2]u8, usize, &next_pair_map, a, count);
try put_or_add([2]u8, usize, &next_pair_map, b, count);
}
std.mem.swap(std.AutoHashMap([2]u8, usize), &pair_map, &next_pair_map);
}
var element_count = std.AutoHashMap(u8, usize).init(allocator);
defer element_count.deinit();
// Count the first char separately
try put_or_add(u8, usize, &element_count, polymer.template[0], 1);
{
var it = pair_map.iterator();
while (it.next()) |e| {
try put_or_add(u8, usize, &element_count, e.key_ptr.*[1], e.value_ptr.*);
}
}
var max_count: usize = 0;
var min_count: usize = std.math.maxInt(usize);
{
var it = element_count.valueIterator();
while (it.next()) |v| {
if (v.* > max_count) max_count = v.*;
if (v.* < min_count) min_count = v.*;
}
}
return max_count - min_count;
}
fn part1(allocator: Allocator, polymer: Polymer) !usize {
return count_min_max(allocator, polymer, 10);
}
fn part2(allocator: Allocator, polymer: Polymer) !usize {
return count_min_max(allocator, polymer, 40);
}
test "polymer" {
const input =
\\NNCB
\\
\\CH -> B
\\HH -> N
\\CB -> H
\\NH -> C
\\HB -> C
\\HC -> B
\\HN -> C
\\NN -> C
\\BH -> H
\\NC -> B
\\NB -> B
\\BN -> B
\\BB -> N
\\BC -> B
\\CC -> N
\\CN -> C
;
const allocator = std.testing.allocator;
var polymer = try Polymer.parse(allocator, input[0..]);
defer polymer.deinit();
try std.testing.expectEqual(@as(usize, 1588), try part1(allocator, polymer));
try std.testing.expectEqual(@as(usize, 2188189693529), try part2(allocator, polymer));
} | src/day14.zig |
const std = @import("std");
const c = @import("c.zig");
const commands = @import("commands.zig");
pub const fontname = "Ubuntu-14";
pub const Arg = union {
Int: i32,
UInt: u32,
float: f32,
StringList: []const []const u8,
String: []const u8,
};
const ActionDef = struct {
modifier: u32,
code: u64,
action: fn(window: u64, arg: Arg) void,
arg: Arg,
};
pub const COLOR = enum(u8) {
FOREGROUND_FOCUS_BG,
FOREGROUND_FOCUS_FG,
FOREGROUND_NOFOCUS,
BACKGROUND,
BLACK,
WHITE,
AMOUNT,
};
pub const COLOR_AMOUNT = @enumToInt(COLOR.AMOUNT);
pub const colors = [COLOR_AMOUNT][3]u8{
[_]u8{ 66, 50, 44 },
[_]u8{ 245, 108, 66 },
[_]u8{ 22, 22, 22 },
[_]u8{ 0, 0, 0 },
[_]u8{ 0, 0, 0 },
[_]u8{ 255, 255, 255 },
};
pub var gapsize: u32 = 8;
pub var borderWidth: i32 = 2;
pub var focusOnClick: bool = true;
pub var keys = [_]ActionDef{
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_q, .action = commands.windowClose, .arg = undefined},
ActionDef{ .modifier = c.Mod4Mask | c.ShiftMask, .code = c.XK_e, .action = commands.exit, .arg = undefined},
// Window Management
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_j, .action = commands.windowPrevious, .arg = Arg{.UInt=0}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_k, .action = commands.windowNext, .arg = Arg{.UInt=0}},
// Workspace Management
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_1, .action = commands.workspaceShow, .arg = Arg{.UInt=0}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_2, .action = commands.workspaceShow, .arg = Arg{.UInt=1}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_3, .action = commands.workspaceShow, .arg = Arg{.UInt=2}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_4, .action = commands.workspaceShow, .arg = Arg{.UInt=3}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_5, .action = commands.workspaceShow, .arg = Arg{.UInt=4}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_6, .action = commands.workspaceShow, .arg = Arg{.UInt=5}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_7, .action = commands.workspaceShow, .arg = Arg{.UInt=6}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_8, .action = commands.workspaceShow, .arg = Arg{.UInt=7}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_Tab, .action = commands.workspaceFocusPrevious, .arg = Arg{.UInt=0}},
// Screen selection
// TODO: my motior order is swapped
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_period, .action = commands.screenSelectByDelta, .arg = Arg{.Int=-1}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_comma, .action = commands.screenSelectByDelta, .arg = Arg{.Int=1}},
// Applications
// TODO: use environment variables for term, browser, launcher
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_p, .action = commands.run, .arg = Arg{.StringList=&[_][]const u8{"rofi", "-show", "run"}}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_Return, .action = commands.run, .arg = Arg{.StringList=&[_][]const u8{"alacritty"}}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_b, .action = commands.run, .arg = Arg{.StringList=&[_][]const u8{"chromium"}}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_m, .action = commands.run, .arg = Arg{.StringList=&[_][]const u8{"notify-send", "-t", "200", "test message"}}},
ActionDef{ .modifier = c.Mod4Mask, .code = c.XK_n, .action = commands.notify, .arg = Arg{.String="Test Message"}},
};
pub var buttons = [_]ActionDef{
ActionDef{ .modifier = c.Mod1Mask, .code = c.Button1, .action = commands.windowMove, .arg = Arg{.UInt=0}},
}; | src/config.zig |
const std = @import("std");
const debug = std.debug.print;
const testing = std.testing;
const kvstore = @import("kvstore.zig");
const io = @import("io.zig");
const config = @import("config.zig");
const utils = @import("utils.zig");
const findAllVariables = @import("parser_variables.zig").findAllVariables;
const expandVariables = @import("parser_variables.zig").expandVariables;
const expandFunctions = @import("parser_variables.zig").expandFunctions;
const getGlobalFunction = @import("parser_variables.zig").getGlobalFunction;
const expressionExtractor = @import("parser_expressions.zig").expressionExtractor;
const BracketPair = @import("parser_variables.zig").BracketPair;
const types = @import("types.zig");
const Entry = types.Entry;
const HttpMethod = types.HttpMethod;
const HttpHeader = types.HttpHeader;
const ExtractionEntry = types.ExtractionEntry;
const Console = @import("console.zig").Console;
const addUnsignedSigned = utils.addUnsignedSigned;
pub const errors = error{
ParseError,
InputSectionError,
OutputSectionError,
HeaderEntryError,
ExtractionEntryError,
InputPayloadError,
InputSectionNoSuchMethodError,
InputSectionUrlTooLongError,
BufferTooSmall,
NoSuchFunction,
};
pub const Parser = struct {
const Self = @This();
console: *const Console,
pub fn parseError(self: *Self, comptime text: []const u8, line_no: usize, col_no: usize, buf: []const u8, line: []const u8) void {
self.parseErrorArg(text, .{}, line_no, col_no, buf, line);
}
pub fn parseErrorArg(self: *Self, comptime text: []const u8, args: anytype, line_no: usize, col_no: usize, buf: []const u8, line: ?[]const u8) void {
const console = self.console;
_ = buf;
_ = col_no;
console.errorPrint(text, args);
if (line) |line_value| {
console.errorPrintNoPrefix("\n Line: {d}: {s}\n", .{ line_no + 1, line_value });
} else {
console.errorPrintNoPrefix("\n", .{});
}
}
/// data: the data to parse - all expansions etc must have been done before this.
/// result: pre-allocated struct to popuplate with parsed data
/// line_idx_offset: Which line_idx in the source file the data originates from. Used to
/// generate better parse errors.
pub fn parseContents(self: *Self, data: []const u8, result: *Entry, line_idx_offset: usize) errors!void {
const ParseState = enum {
Init,
InputSection,
InputPayloadSection,
OutputSection,
};
const ParserFunctions = struct {
fn isEmptyLineOrComment(line: []const u8) bool {
return (line.len == 0 or line[0] == '#');
}
fn parseInputSectionHeader(line: []const u8, _result: *Entry) !void {
var lit = std.mem.split(u8, line[0..], " ");
_ = lit.next(); // skip >
_result.method = HttpMethod.create(lit.next().?[0..]) catch return errors.InputSectionNoSuchMethodError;
const url = lit.next().?[0..];
_result.url.insertSlice(0, url) catch return errors.InputSectionUrlTooLongError;
}
fn parseOutputSectionHeader(line: []const u8, _result: *Entry) !void {
var lit = std.mem.split(u8, line, " ");
_ = lit.next(); // skip <
if (lit.next()) |http_code| {
_result.expected_http_code = std.fmt.parseInt(u64, http_code[0..], 10) catch return errors.OutputSectionError;
_result.expected_response_substring.insertSlice(0, std.mem.trim(u8, lit.rest()[0..], " ")) catch return errors.OutputSectionError;
} else {
return errors.OutputSectionError;
}
}
fn parseHeaderEntry(line: []const u8, _result: *Entry) !void {
var lit = std.mem.split(u8, line, ":");
if (lit.next()) |key| {
if (lit.next()) |value| {
_result.headers.append(try HttpHeader.create(key, value)) catch return errors.HeaderEntryError;
} else {
return error.HeaderEntryError;
}
} else {
return error.HeaderEntryError;
}
}
fn parseExtractionEntry(line: []const u8, _result: *Entry) !void {
var lit = std.mem.split(u8, line, "=");
if (lit.next()) |key| {
if (lit.next()) |value| {
_result.extraction_entries.append(try ExtractionEntry.create(key, value)) catch return errors.ExtractionEntryError;
} else {
return error.ExtractionEntryError;
}
} else {
return error.ExtractionEntryError;
}
}
fn parseInputPayloadLine(line: []const u8, _result: *Entry) !void {
_result.payload.appendSlice(line) catch return errors.InputPayloadError; // .Overflow
_result.payload.append('\n') catch return errors.InputPayloadError; // .Overflow
}
};
// Name is set based on file name - i.e: not handled here
// Tokenize by line ending. Check for first char being > and < to determine sections, then do section-specific parsing.
var state = ParseState.Init;
var it = std.mem.split(u8, data, io.getLineEnding(data));
var line_idx: usize = line_idx_offset;
while (it.next()) |line| : (line_idx += 1) {
// TBD: Refactor? State-names may be confusing.
switch (state) {
ParseState.Init => {
if (ParserFunctions.isEmptyLineOrComment(line)) continue;
if (line[0] == '>') {
state = ParseState.InputSection;
ParserFunctions.parseInputSectionHeader(line, result) catch |e| {
self.parseError("Could not parse input section header", line_idx, 0, data, line);
return e;
};
} else {
self.parseError("Expected input section header", line_idx, 0, data, line);
return errors.ParseError;
}
},
ParseState.InputSection => {
if (ParserFunctions.isEmptyLineOrComment(line)) continue;
if (line.len == 1 and line[0] == '-') {
state = ParseState.InputPayloadSection;
continue;
} else if (line[0] == '<') {
// Parse initial expected output section
state = ParseState.OutputSection;
ParserFunctions.parseOutputSectionHeader(line, result) catch |e| {
self.parseError("Could not parse output section header", line_idx, 0, data, line);
return e;
};
continue;
}
// Parse headers
ParserFunctions.parseHeaderEntry(line, result) catch |e| {
self.parseError("Could not parse header entry", line_idx, 0, data, line);
return e;
};
},
ParseState.InputPayloadSection => { // Optional section
if (line.len > 0 and line[0] == '<') blk: {
// Really ensure. We're in payload-land and have really no control of what the user would want to put in there
ParserFunctions.parseOutputSectionHeader(line, result) catch {
//parseError("Could not parse output section header", line_idx, 0, data, line);
//return e;
// Doesn't look like we've found a proper output section header. Keep parsing as payload
break :blk;
};
// If we get here it seems we've parsed ourself a propeper-ish output section header
// Check if payload has been added, and trim trailing newline
if (result.payload.slice().len > 0) {
_ = result.payload.pop();
}
// Parse initial expected output section
state = ParseState.OutputSection;
continue;
}
// Add each line verbatim to payload-buffer
ParserFunctions.parseInputPayloadLine(line, result) catch |e| {
self.parseErrorArg("Could not parse payload section - it's too big. Max payload size is {d}B", .{result.payload.capacity()}, line_idx, 0, data, line);
return e;
};
},
ParseState.OutputSection => {
if (ParserFunctions.isEmptyLineOrComment(line)) continue;
// Parse extraction_entries
ParserFunctions.parseExtractionEntry(line, result) catch |e| {
self.parseError("Could not parse extraction entry", line_idx, 0, data, line);
return e;
};
},
}
}
}
test "parseContents" {
var entry = Entry{};
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
const data =
\\> GET https://api.warnme.no/api/status
\\
\\Content-Type: application/json
\\Accept: application/json
\\
\\< 200 some regex here
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqual(entry.method, HttpMethod.GET);
try testing.expectEqualStrings(entry.url.slice(), "https://api.warnme.no/api/status");
try testing.expectEqual(entry.expected_http_code, 200);
try testing.expectEqualStrings(entry.expected_response_substring.slice(), "some regex here");
// Header-parsing:
try testing.expectEqual(entry.headers.slice().len, 2);
try testing.expectEqualStrings("Content-Type", entry.headers.get(0).name.slice());
try testing.expectEqualStrings("application/json", entry.headers.get(0).value.slice());
try testing.expectEqualStrings("Accept", entry.headers.get(1).name.slice());
try testing.expectEqualStrings("application/json", entry.headers.get(1).value.slice());
}
test "parseContents extracts to variables" {
var entry = Entry{};
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
const data =
\\> GET https://api.warnme.no/api/status
\\
\\Content-Type: application/json
\\Accept: application/json
\\
\\< 200 some regex here
\\myvar=regexwhichextractsvalue
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqual(@intCast(usize, 1), entry.extraction_entries.slice().len);
try testing.expectEqualStrings("myvar", entry.extraction_entries.get(0).name.slice());
try testing.expectEqualStrings("regexwhichextractsvalue", entry.extraction_entries.get(0).expression.slice());
}
test "parseContents supports JSON-payloads" {
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
{
var entry = Entry{};
const data =
\\> POST https://my/service
\\-
\\{"key":{"inner-key":[1,2,3]}}
\\< 200
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqualStrings(
\\{"key":{"inner-key":[1,2,3]}}
, entry.payload.constSlice());
}
{
var entry = Entry{};
const data =
\\> POST https://my/service
\\-
\\{"key":
\\
\\ {"inner-key":
\\ [1
\\ ,2,3]
\\}}
\\< 200
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqualStrings(
\\{"key":
\\
\\ {"inner-key":
\\ [1
\\ ,2,3]
\\}}
, entry.payload.constSlice());
}
}
test "parseContents supports XML-payloads" {
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
var entry = Entry{};
const data =
\\> POST https://my/service
\\-
\\<SOAP-ENV:Envelope
\\ xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
\\ SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
\\ <SOAP-ENV:Body>
\\ <m:GetLastTradePrice xmlns:m="Some-URI">
\\ <symbol>DIS</symbol>
\\ </m:GetLastTradePrice>
\\ </SOAP-ENV:Body>
\\</SOAP-ENV:Envelope>
\\< 200
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqualStrings(
\\<SOAP-ENV:Envelope
\\ xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
\\ SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
\\ <SOAP-ENV:Body>
\\ <m:GetLastTradePrice xmlns:m="Some-URI">
\\ <symbol>DIS</symbol>
\\ </m:GetLastTradePrice>
\\ </SOAP-ENV:Body>
\\</SOAP-ENV:Envelope>
, entry.payload.constSlice());
}
// test "parseContents supports binary-payloads?" {
// }
/// buffer must be big enough to store the expanded variables. TBD: Manage on heap?
pub fn expandVariablesAndFunctions(comptime S: usize, buffer: *std.BoundedArray(u8, S), maybe_variables_sets: ?[]*kvstore.KvStore) !void {
if (buffer.slice().len == 0) return;
const MAX_VARIABLES = 64;
const SortBracketsFunc = struct {
pub fn byDepthDesc(context: void, a: BracketPair, b: BracketPair) bool {
_ = context;
return a.depth > b.depth;
}
};
var pairs = try findAllVariables(buffer.buffer.len, MAX_VARIABLES, buffer);
std.sort.sort(BracketPair, pairs.slice(), {}, SortBracketsFunc.byDepthDesc);
if(maybe_variables_sets) |variables_sets| for (variables_sets) |variables| {
expandVariables(buffer.buffer.len, MAX_VARIABLES, buffer, &pairs, variables) catch |e| switch(e) {
//error.NoSuchVariableFound => {}, // This is OK, as we don't know which variable_set the variable to expand may be in
else => return e
};
};
try expandFunctions(buffer.buffer.len, MAX_VARIABLES, buffer, &pairs);
}
test "expandVariablesAndFunctions" {
var variables = kvstore.KvStore{};
var variables_sets = [_]*kvstore.KvStore{&variables};
try variables.add("key", "value");
{
var testbuf = try std.BoundedArray(u8, 1024).fromSlice("");
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, variables_sets[0..]);
try testing.expectEqualStrings("", testbuf.slice());
}
{
var testbuf = try std.BoundedArray(u8, 1024).fromSlice("hey");
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, variables_sets[0..]);
try testing.expectEqualStrings("hey", testbuf.slice());
}
{
var testbuf = try std.BoundedArray(u8, 1024).fromSlice("{{key}}");
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, variables_sets[0..]);
try testing.expectEqualStrings("value", testbuf.slice());
}
{
var testbuf = try std.BoundedArray(u8, 1024).fromSlice("{{key}}{{key}}");
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, variables_sets[0..]);
try testing.expectEqualStrings("valuevalue", testbuf.slice());
}
{
var testbuf = try std.BoundedArray(u8, 1024).fromSlice("woop {{key}} doop");
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, variables_sets[0..]);
try testing.expectEqualStrings("woop value doop", testbuf.slice());
}
}
test "bug: variable-expansions fail for long values" {
var variables = kvstore.KvStore{};
try variables.add("my_token", "valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue");
var testbuf = try std.BoundedArray(u8, 8 * 1024).fromSlice(
\\Authorization: bearer {{my_token}}
\\Cookie: RandomSecurityToken={{my_token}}; SomeOtherRandomCookie={{my_token}}
\\RandomSecurityToken: {{my_token}}
);
try expandVariablesAndFunctions(testbuf.buffer.len, &testbuf, ([_]*kvstore.KvStore{&variables})[0..]);
try testing.expectEqualStrings(
\\Authorization: bearer valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue
\\Cookie: RandomSecurityToken=valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue; SomeOtherRandomCookie=valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue
\\RandomSecurityToken: valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue
, testbuf.slice());
}
test "substitution advanced tests" {
var str = try std.BoundedArray(u8, 1024).fromSlice(
\\{{s1_var}}
\\{{s1_var2}}
\\{{myfunc({{s3_var}}:{{s2_var}})}}
\\{{s2_var}}
\\{{s3_var}}
);
var str_expected =
\\s1varlongervaluehere
\\
\\s3varlongervaluehere:
\\
\\s3varlongervaluehere
;
var s1 = kvstore.KvStore{};
var s2 = kvstore.KvStore{};
var s3 = kvstore.KvStore{};
try s1.add("s1_var", "s1varlongervaluehere");
try s1.add("s1_var2", "");
try s2.add("s2_var", "");
try s3.add("s3_var", "s3varlongervaluehere");
var sets = [_]*kvstore.KvStore{&s1, &s2, &s3};
try expandVariablesAndFunctions(str.buffer.len, &str, sets[0..]);
try testing.expectEqualStrings(str_expected, str.slice());
}
test "parseContents ignores comments" {
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
var entry = Entry{};
const data =
\\> GET https://api.warnme.no/api/status
\\
\\# Content-Type: application/json
\\# Accept: application/json
\\
\\< 200 some regex here
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expect(entry.headers.slice().len == 0);
}
test "parseContents shall extract payload" {
var console = Console.initNull();
var parser = Parser {
.console = &console,
};
var entry = Entry{};
const data =
\\> GET https://api.warnme.no/api/status
\\
\\Content-Type: application/json
\\Accept: application/json
\\
\\-
\\Payload goes here
\\and here
\\< 200 some regex here
\\
;
try parser.parseContents(data, &entry, 0);
try testing.expectEqualStrings("Payload goes here\nand here", entry.payload.slice());
}
/////////////////////////////////
// Playbook handling
/////////////////////////////////
pub const PlaybookSegmentType = enum { Unknown, TestInclude, EnvInclude, TestRaw, EnvRaw };
pub const SegmentMetadata = union(PlaybookSegmentType) {
Unknown: void,
TestInclude: struct {
repeats: u32,
},
EnvInclude: void,
TestRaw: void,
EnvRaw: void,
};
pub const PlaybookSegment = struct {
line_start: u64,
segment_type: PlaybookSegmentType = .Unknown,
slice: []const u8 = undefined, // Slice into raw buffer
meta: SegmentMetadata = undefined,
};
/// Parses a playbook-file into a list of segments. Each segment must then be further processed according to the segment-type
pub fn parsePlaybook(buf: []const u8, result: []PlaybookSegment) usize {
var main_it = std.mem.split(u8, buf, io.getLineEnding(buf));
var line_idx: u64 = 0;
var seg_idx: u64 = 0;
while (main_it.next()) |line| : (line_idx += 1) {
if (line.len == 0) continue; // ignore blank lines
if (line[0] == '#') continue; // ignore comments
// Top level evaluation
switch (line[0]) {
'@' => {
// Got file inclusion segment
var sub_it = std.mem.split(u8, line[1..], "*");
var path = std.mem.trim(u8, sub_it.next().?, " "); // expected to be there, otherwise error
if (std.mem.endsWith(u8, path, config.FILE_EXT_TEST)) {
var meta_raw = sub_it.next(); // may be null
var repeats: u32 = 1;
if (meta_raw) |meta| {
repeats = std.fmt.parseInt(u32, std.mem.trim(u8, meta, " "), 10) catch {
return 1;
};
}
result[seg_idx] = .{
.line_start = line_idx,
.segment_type = .TestInclude,
.slice = path,
.meta = .{
.TestInclude = .{
.repeats = repeats,
},
},
};
seg_idx += 1;
} else if (std.mem.endsWith(u8, path, config.FILE_EXT_ENV)) {
result[seg_idx] = .{ .line_start = line_idx, .segment_type = .EnvInclude, .slice = path };
seg_idx += 1;
}
},
'>' => {
// Parse "in-filed" test
// This parses until we find start of another known segment type
// This chunk will later be properly validated when attempted parsed
// Strategy: store pointer to start, iterate until end, store pointer to end, create slice from pointers
var buf_start = @ptrToInt(buf.ptr);
var chunk_line_start = line_idx;
var start_idx = @ptrToInt(line.ptr) - buf_start;
var end_idx: ?u64 = null;
// Parse until next >, @ or eof
chunk_blk: while (main_it.next()) |line2| {
line_idx += 1;
// Check the following line, spin until we've reached another segment
if (main_it.rest().len == 0) break; // EOF
switch (main_it.rest()[0]) {
'>', '@' => {
end_idx = @ptrToInt(&line2[line2.len - 1]) - buf_start; // line2.len-1?
result[seg_idx] = .{
.line_start = chunk_line_start,
.segment_type = .TestRaw,
.slice = buf[start_idx .. end_idx.? + 1],
};
seg_idx += 1;
break :chunk_blk;
},
else => {},
}
}
if (end_idx == null) {
// Reached end of file
end_idx = @ptrToInt(&buf[buf.len - 1]) - buf_start;
result[seg_idx] = .{
.line_start = chunk_line_start,
.segment_type = .TestRaw,
.slice = buf[start_idx .. end_idx.? + 1],
};
seg_idx += 1;
}
},
else => {
if (std.mem.indexOf(u8, line, "=") != null) {
result[seg_idx] = .{ .line_start = line_idx, .segment_type = .EnvRaw, .slice = line[0..] };
seg_idx += 1;
} else {
// Unsupported
unreachable;
}
},
}
}
return seg_idx;
}
};
test "parse playbook single test fileref" {
const buf =
\\@some/test.pi
\\
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 1), segments.len);
try testing.expectEqual(Parser.PlaybookSegmentType.TestInclude, segments.get(0).segment_type);
try testing.expectEqualStrings("some/test.pi", segments.get(0).slice);
}
test "parse playbook test filerefs can have repeats" {
const buf =
\\@some/test.pi*10
\\
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 1), segments.len);
try testing.expectEqual(@intCast(usize, 10), segments.get(0).meta.TestInclude.repeats);
}
test "parse playbook fileref and envref" {
const buf =
\\@some/test.pi
\\@some/.env
\\
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 2), segments.len);
try testing.expectEqual(Parser.PlaybookSegmentType.EnvInclude, segments.get(1).segment_type);
try testing.expectEqualStrings("some/.env", segments.get(1).slice);
}
test "parse playbook single raw var" {
const buf =
\\MY_ENV=somevalue
\\
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 1), segments.len);
try testing.expectEqual(Parser.PlaybookSegmentType.EnvRaw, segments.get(0).segment_type);
try testing.expectEqualStrings("MY_ENV=somevalue", segments.get(0).slice);
}
test "parse playbook raw test" {
const buf =
\\> GET https://my.service/api
\\< 200
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 1), segments.len);
try testing.expectEqual(Parser.PlaybookSegmentType.TestRaw, segments.get(0).segment_type);
try testing.expectEqualStrings("> GET https://my.service/api\n< 200", segments.get(0).slice);
}
test "parse playbook two raw tests, one with extraction-expressions" {
const buf =
\\> GET https://my.service/api
\\< 200
\\> GET https://my.service/api2
\\< 200
\\RESPONSE=()
;
var segments = utils.initBoundedArray(Parser.PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 2), segments.len);
try testing.expectEqual(Parser.PlaybookSegmentType.TestRaw, segments.get(0).segment_type);
try testing.expectEqualStrings("> GET https://my.service/api\n< 200", segments.get(0).slice);
try testing.expectEqualStrings("> GET https://my.service/api2\n< 200\nRESPONSE=()", segments.get(1).slice);
}
test "parse super complex playbook" {
const PlaybookSegmentType = Parser.PlaybookSegmentType;
const PlaybookSegment = Parser.PlaybookSegment;
const buf_complex_playbook_example =
\\# Exploration of integrated tests in playbooks
\\# Can rely on newline+> to indicate new tests.
\\# Can allow for a set of variables defined at top before first test as well.
\\# The format should allow combination of file-references as well as inline definitions
\\# Syntax (proposal):
\\# Include file directive starts with @
\\# If file-ext matches test-file then allow for repeat-counts as well
\\# If file-ext matches .env then treat as envs
\\# If file-ext matches playbook-file then include playbook? TBD. Must avoid recursion-issues and such. Not pri. Pr now: report as error
\\# Included tests starts with a line with '>' and ends with a line with either '@' (new include) or new '>' (new test). Otherwise treated exactly as regular test-files. Repeat-control?
\\# If line not inside inline-test, and not starts with @, check for = and if match treat as variable definition
\\# Otherwise: syntax error
\\#
\\# Load env from file
\\@myservice/.env
\\# Define env in-file
\\MY_ENV=Woop
\\
\\# Refer to external test
\\@generic/01-oidc-auth.pi
\\
\\# Refer to external test with repeats
\\@myservice/01-getentries.pi * 50
\\
\\# Inline-test 1
\\> GET https://my.service/api/health
\\Accept: application/json
\\Cookie: SecureToken={{oidc_token}}
\\< 200 OK
\\# Store entire response:
\\EXTRACTED_ENTRY=()
\\
\\# Refer to external test inbetween inlines
\\@myservice/01-getentries.pi * 50
\\
\\# Another inline-test
\\> GET https://my.service/api/health
\\Accept: application/json
\\Cookie: SecureToken={{oidc_token}}
\\< 200
;
var segments = utils.initBoundedArray(PlaybookSegment, 128);
try segments.resize(Parser.parsePlaybook(buf_complex_playbook_example, segments.unusedCapacitySlice()));
try testing.expectEqual(@intCast(usize, 7), segments.len);
try testing.expectEqual(PlaybookSegmentType.EnvInclude, segments.get(0).segment_type);
try testing.expectEqual(PlaybookSegmentType.EnvRaw, segments.get(1).segment_type);
try testing.expectEqual(PlaybookSegmentType.TestInclude, segments.get(2).segment_type);
try testing.expectEqual(PlaybookSegmentType.TestInclude, segments.get(3).segment_type);
try testing.expectEqual(PlaybookSegmentType.TestRaw, segments.get(4).segment_type);
try testing.expectEqual(PlaybookSegmentType.TestInclude, segments.get(5).segment_type);
try testing.expectEqual(PlaybookSegmentType.TestRaw, segments.get(6).segment_type);
}
/// TEST/DEBUG
fn dumpUnresolvedBracketPairsForBuffer(buf: []const u8, brackets: []const BracketPair) void {
for (brackets) |pair, i| {
if (pair.resolved) continue;
debug("{d}: [{d}-{d}, {d}]: {s}\n", .{i, pair.start, pair.end, pair.depth, buf[pair.start..pair.end+1]});
}
} | src/parser.zig |
// Copyright (C) 2014-2021 <NAME> <EMAIL>
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// The person recognize Mars as a free planet and that no Earth-based
// government has authority or sovereignty over Martian activities.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// twinsort 1.1.3.3
// https://github.com/scandum/twinsort/blob/938c11f10b7f0d9ab40022481560bd0a5479dba0/twinsort.h
const std = @import("std");
/// tailSort is a bottom-up merge sort.
pub fn tailSort(
allocator: std.mem.Allocator,
comptime T: anytype,
items: []T,
context: anytype,
lessThan: fn (@TypeOf(context), a: T, b: T) bool,
) !void {
if (items.len < 2) return;
try tailMerge(allocator, usize, items, context, lessThan, 1);
}
pub fn twinSort(
allocator: std.mem.Allocator,
comptime T: anytype,
items: []T,
context: anytype,
lessThan: fn (@TypeOf(context), a: T, b: T) bool,
) !void {
if (twinSwap(T, items, context, lessThan) == 0) {
try tailMerge(allocator, T, items, context, lessThan, 2);
}
}
/// Turn the array into sorted blocks of 2 elements.
/// Detect and sort reverse order runs. So `6 5 4 3 2 1` becomes `1 2 3 4 5 6`
/// rather than `5 6 3 4 1 2`.
fn twinSwap(comptime T: anytype, items: []T, context: anytype, lessThan: fn (context: @TypeOf(context), a: T, b: T) bool) usize {
var index: usize = 0;
var start: usize = undefined;
var end: usize = items.len - 2;
while (index <= end) {
if (lessThan(context, items[index], items[index + 1])) {
index += 2;
continue;
}
start = index;
index += 2;
while (true) {
if (index > end) {
if (start == 0) {
if (items.len % 2 == 0 or items[index - 1] > items[index]) {
// the entire slice was reversed
end = items.len - 1;
while (start < end) {
std.mem.swap(T, &items[start], &items[end]);
start += 1;
end -= 1;
}
return 1;
}
}
break;
}
if (lessThan(context, items[index + 1], items[index])) {
if (lessThan(context, items[index], items[index - 1])) {
index += 2;
continue;
}
std.mem.swap(T, &items[index], &items[index + 1]);
}
break;
}
end = index - 1;
while (start < end) {
std.mem.swap(T, &items[start], &items[end]);
start += 1;
end -= 1;
}
end = items.len - 2;
index += 2;
}
return 0;
}
/// Bottom up merge sort. It copies the right block to swap, next merges
/// starting at the tail ends of the two sorted blocks.
/// Can be used stand alone. Uses at most nmemb / 2 swap memory.
fn tailMerge(
allocator: std.mem.Allocator,
comptime T: anytype,
items: []T,
context: anytype,
lessThan: fn (@TypeOf(context), a: T, b: T) bool,
b: u2,
) !void {
var c: isize = undefined;
var c_max: isize = undefined;
var d: isize = undefined;
var d_max: isize = undefined;
var e: isize = undefined;
var block: isize = b;
var swap = try allocator.alloc(T, items.len / 2);
defer allocator.free(swap);
while (block < items.len) {
var offset: isize = 0;
while (offset + block < items.len) : (offset += block * 2) {
e = offset + block - 1;
if (!lessThan(context, items[@intCast(usize, e) + 1], items[@intCast(usize, e)])) continue;
if (offset + block * 2 < items.len) {
c_max = 0 + block;
d_max = offset + block * 2;
} else {
c_max = 0 + @intCast(isize, items.len) - (offset + block);
d_max = 0 + @intCast(isize, items.len);
}
d = d_max - 1;
while (!lessThan(context, items[@intCast(usize, d)], items[@intCast(usize, e)])) {
d_max -= 1;
d -= 1;
c_max -= 1;
}
c = 0;
d = offset + block;
while (c < c_max) {
swap[@intCast(usize, c)] = items[@intCast(usize, d)];
c += 1;
d += 1;
}
c -= 1;
d = offset + block - 1;
e = d_max - 1;
if (!lessThan(context, items[@intCast(usize, offset + block)], items[@intCast(usize, offset)])) {
items[@intCast(usize, e)] = items[@intCast(usize, d)];
e -= 1;
d -= 1;
while (c >= 0) {
while (lessThan(context, swap[@intCast(usize, c)], items[@intCast(usize, d)])) {
items[@intCast(usize, e)] = items[@intCast(usize, d)];
e -= 1;
d -= 1;
}
items[@intCast(usize, e)] = swap[@intCast(usize, c)];
e -= 1;
c -= 1;
}
} else {
items[@intCast(usize, e)] = items[@intCast(usize, d)];
e -= 1;
d -= 1;
while (d >= offset) {
while (!lessThan(context, swap[@intCast(usize, c)], items[@intCast(usize, d)])) {
items[@intCast(usize, e)] = swap[@intCast(usize, c)];
e -= 1;
c -= 1;
}
items[@intCast(usize, e)] = items[@intCast(usize, d)];
e -= 1;
d -= 1;
}
while (c >= 0) {
items[@intCast(usize, e)] = swap[@intCast(usize, c)];
e -= 1;
c -= 1;
}
}
}
block *= 2;
}
}
test "tailSort - ascending" {
var input = [_]usize{ 6, 5, 4, 3, 7, 2, 1, 9, 3 };
const exp = [_]usize{ 1, 2, 3, 3, 4, 5, 6, 7, 9 };
try tailSort(std.testing.allocator, usize, &input, {}, comptime std.sort.asc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
}
test "tailSort - descending" {
var input = [_]usize{ 6, 5, 4, 3, 7, 2, 1, 9, 3 };
const exp = [_]usize{ 9, 7, 6, 5, 4, 3, 3, 2, 1 };
try tailSort(std.testing.allocator, usize, &input, {}, comptime std.sort.desc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
}
test "twinSort - ascending" {
var input = [_]usize{ 6, 5, 4, 3, 7, 2, 1, 9, 3 };
const exp = [_]usize{ 1, 2, 3, 3, 4, 5, 6, 7, 9 };
try twinSort(std.testing.allocator, usize, &input, {}, comptime std.sort.asc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
}
test "twinSort - descending" {
var input = [_]usize{ 6, 5, 4, 3, 7, 2, 1, 9, 3 };
const exp = [_]usize{ 9, 7, 6, 5, 4, 3, 3, 2, 1 };
try twinSort(std.testing.allocator, usize, &input, {}, comptime std.sort.desc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
}
test "twinSwap - ascending" {
var input = [_]usize{ 6, 5, 4, 3, 2, 1 };
const exp = [_]usize{ 1, 2, 3, 4, 5, 6 };
_ = twinSwap(usize, &input, {}, comptime std.sort.asc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
}
test "twinSwap - descending" {
var input = [_]usize{ 1, 2, 3, 4, 5, 6 };
var exp = [_]usize{ 6, 5, 4, 3, 2, 1 };
_ = twinSwap(usize, &input, {}, comptime std.sort.desc(usize));
try std.testing.expectEqualSlices(usize, &exp, &input);
} | src/twin.zig |
const gllparser = @import("../gllparser/gllparser.zig");
const Error = gllparser.Error;
const Parser = gllparser.Parser;
const ParserContext = gllparser.Context;
const Result = gllparser.Result;
const NodeName = gllparser.NodeName;
const ResultStream = gllparser.ResultStream;
const Literal = @import("../parser/literal.zig").Literal;
const LiteralValue = @import("../parser/literal.zig").Value;
const std = @import("std");
const testing = std.testing;
const mem = std.mem;
pub fn Context(comptime Payload: type, comptime Value: type) type {
return []const *Parser(Payload, Value);
}
pub const Ownership = enum {
borrowed,
owned,
copy,
};
/// Matches one of the given `input` parsers, supporting ambiguous and unambiguous grammars.
///
/// The `input` parsers must remain alive for as long as the `OneOfAmbiguous` parser will be used.
///
/// In the case of a non-ambiguous `OneOfAmbiguous` grammar of `Parser1 | Parser2`, the combinator will
/// yield:
///
/// ```
/// stream(Parser1Value)
/// ```
///
/// Or:
///
/// ```
/// stream(Parser2Value)
/// ```
///
/// In the case of an ambiguous grammar `Parser1 | Parser2` where either parser can produce three
/// different parse paths, it will yield:
///
/// ```
/// stream(
/// Parser1Value1,
/// Parser1Value2,
/// Parser1Value3,
/// Parser2Value1,
/// Parser2Value2,
/// Parser2Value3,
/// )
/// ```
///
pub fn OneOfAmbiguous(comptime Payload: type, comptime Value: type) type {
return struct {
parser: Parser(Payload, Value) = Parser(Payload, Value).init(parse, nodeName, deinit, countReferencesTo),
input: Context(Payload, Value),
ownership: Ownership,
const Self = @This();
pub fn init(allocator: mem.Allocator, input: Context(Payload, Value), ownership: Ownership) !*Parser(Payload, Value) {
var self = Self{ .input = input, .ownership = ownership };
if (ownership == .copy) {
const Elem = std.meta.Elem(@TypeOf(input));
var copy = try allocator.alloc(Elem, input.len);
std.mem.copy(Elem, copy, input);
self.input = copy;
self.ownership = .owned;
}
return try self.parser.heapAlloc(allocator, self);
}
pub fn initStack(input: Context(Payload, Value), ownership: Ownership) Self {
if (ownership == Ownership.copy) unreachable;
return Self{ .input = input, .ownership = ownership };
}
pub fn deinit(parser: *Parser(Payload, Value), allocator: mem.Allocator, freed: ?*std.AutoHashMap(usize, void)) void {
const self = @fieldParentPtr(Self, "parser", parser);
for (self.input) |in_parser| {
in_parser.deinit(allocator, freed);
}
if (self.ownership == .owned) allocator.free(self.input);
}
pub fn countReferencesTo(parser: *const Parser(Payload, Value), other: usize, freed: *std.AutoHashMap(usize, void)) usize {
const self = @fieldParentPtr(Self, "parser", parser);
if (@ptrToInt(parser) == other) return 1;
var count: usize = 0;
for (self.input) |in_parser| {
count += in_parser.countReferencesTo(other, freed);
}
return count;
}
pub fn nodeName(parser: *const Parser(Payload, Value), node_name_cache: *std.AutoHashMap(usize, NodeName)) Error!u64 {
const self = @fieldParentPtr(Self, "parser", parser);
var v = std.hash_map.hashString("OneOfAmbiguous");
for (self.input) |in_parser| {
v +%= try in_parser.nodeName(node_name_cache);
}
return v;
}
pub fn parse(parser: *const Parser(Payload, Value), in_ctx: *const ParserContext(Payload, Value)) callconv(.Async) !void {
const self = @fieldParentPtr(Self, "parser", parser);
var ctx = in_ctx.with(self.input);
defer ctx.results.close();
var buffer = try ResultStream(Result(Value)).init(ctx.allocator, ctx.key);
defer buffer.deinit();
for (self.input) |in_parser| {
const child_node_name = try in_parser.nodeName(&in_ctx.memoizer.node_name_cache);
var child_ctx = try in_ctx.initChild(Value, child_node_name, ctx.offset);
defer child_ctx.deinitChild();
if (!child_ctx.existing_results) try in_parser.parse(&child_ctx);
var sub = child_ctx.subscribe();
while (sub.next()) |next| {
try buffer.add(next.toUnowned());
}
}
buffer.close();
var gotValues: usize = 0;
var gotErrors: usize = 0;
var sub = buffer.subscribe(ctx.key, ctx.path, Result(Value).initError(ctx.offset, "matches only the empty language"));
while (sub.next()) |next| {
switch (next.result) {
.err => gotErrors += 1,
else => gotValues += 1,
}
}
if (gotValues > 0) {
// At least one parse path succeeded, so discard all error'd parse paths.
//
// TODO(slimsag): would the client not want to enumerate error'd paths that made some
// progress?
var sub2 = buffer.subscribe(ctx.key, ctx.path, Result(Value).initError(ctx.offset, "matches only the empty language"));
while (sub2.next()) |next| {
switch (next.result) {
.err => {},
else => try ctx.results.add(next),
}
}
return;
}
// All parse paths failed, so return a nice error.
//
// TODO(slimsag): include names of expected input parsers
//
// TODO(slimsag): collect and return the furthest error if a parse path made
// progress and failed.
try ctx.results.add(Result(Value).initError(ctx.offset, "expected OneOfAmbiguous"));
}
};
}
// Confirms that the following grammar works as expected:
//
// ```ebnf
// Grammar = "ello" | "world" ;
// ```
//
test "oneof" {
nosuspend {
const allocator = testing.allocator;
const Payload = void;
const ctx = try ParserContext(Payload, LiteralValue).init(allocator, "elloworld", {});
defer ctx.deinit();
const parsers: []*Parser(Payload, LiteralValue) = &.{
(try Literal(Payload).init(allocator, "ello")).ref(),
(try Literal(Payload).init(allocator, "world")).ref(),
};
var helloOrWorld = try OneOfAmbiguous(Payload, LiteralValue).init(allocator, parsers, .borrowed);
defer helloOrWorld.deinit(allocator, null);
try helloOrWorld.parse(&ctx);
var sub = ctx.subscribe();
var first = sub.next().?;
try testing.expectEqual(Result(LiteralValue).init(4, .{ .value = "ello" }).toUnowned(), first);
try testing.expect(sub.next() == null); // stream closed
}
}
// Confirms that the following grammar works as expected:
//
// ```ebnf
// Grammar = "ello" | "elloworld" ;
// ```
//
test "oneof_ambiguous" {
nosuspend {
const allocator = testing.allocator;
const Payload = void;
const ctx = try ParserContext(Payload, LiteralValue).init(allocator, "elloworld", {});
defer ctx.deinit();
const parsers: []*Parser(Payload, LiteralValue) = &.{ (try Literal(Payload).init(allocator, "ello")).ref(), (try Literal(Payload).init(allocator, "elloworld")).ref() };
var helloOrWorld = try OneOfAmbiguous(Payload, LiteralValue).init(allocator, parsers, .borrowed);
defer helloOrWorld.deinit(allocator, null);
try helloOrWorld.parse(&ctx);
var sub = ctx.subscribe();
var r1 = sub.next().?;
try testing.expectEqual(@as(usize, 4), r1.offset);
try testing.expectEqualStrings("ello", r1.result.value.value);
var r2 = sub.next().?;
try testing.expectEqual(@as(usize, 9), r2.offset);
try testing.expectEqualStrings("elloworld", r2.result.value.value);
try testing.expect(sub.next() == null); // stream closed
}
} | src/combn/combinator/oneof_ambiguous.zig |
const api = switch (cfg.platform) {
.web => @import("gfx_web.zig"),
.win => @compileError("Not yet implemented!"),
};
const cfg = @import("cfg.zig");
const std = @import("std");
pub const ContextDesc = struct {
surface_desc: SurfaceDesc,
adapter_desc: AdapterDesc = .{},
device_desc: DeviceDesc = .{},
swapchain_size: Extent3d,
};
pub const Context = struct {
instance: Instance,
surface: Surface,
adapter: Adapter,
device: Device,
swapchain: Swapchain,
swapchain_format: TextureFormat,
clear_color: Color,
depth_texture: Texture,
depth_texture_format: TextureFormat,
depth_texture_view: TextureView,
pub fn init(desc: ContextDesc) !Context {
var instance = try Instance.init();
var surface = try instance.initSurface(desc.surface_desc);
var adapter = try instance.initAdapter(desc.adapter_desc);
var device = try adapter.initDevice(desc.device_desc);
const swapchain_format = try surface.getPreferredFormat();
const swapchain = try device.initSwapchain(&surface, .{
.size = desc.swapchain_size,
.format = swapchain_format,
});
const clear_color = .{ .r = 0.32, .g = 0.1, .b = 0.18, .a = 1.0 };
const depth_texture_format = .depth24plus;
var depth_texture = try device.initTexture(.{
.size = desc.swapchain_size,
.format = depth_texture_format,
.usage = .{ .render_attachment = true },
});
const depth_texture_view = try device.initTextureView(.{
.texture = &depth_texture,
.format = depth_texture_format,
});
return Context{
.instance = instance,
.surface = surface,
.adapter = adapter,
.device = device,
.swapchain = swapchain,
.swapchain_format = swapchain_format,
.clear_color = clear_color,
.depth_texture = depth_texture,
.depth_texture_format = depth_texture_format,
.depth_texture_view = depth_texture_view,
};
}
pub fn deinit(ctx: *Context) void {
ctx.device.deinitTextureView(&ctx.depth_texture_view);
ctx.device.deinitTexture(&ctx.depth_texture);
ctx.device.deinitSwapchain(&ctx.swapchain);
ctx.adapter.deinitDevice(&ctx.device);
ctx.instance.deinitAdapter(&ctx.adapter);
ctx.instance.deinitSurface(&ctx.surface);
ctx.instance.deinit();
}
};
pub const Instance = struct {
impl: api.Instance,
pub fn init() !Instance {
return Instance{ .impl = try api.Instance.init() };
}
pub fn deinit(instance: *Instance) void {
instance.impl.deinit();
}
pub fn initSurface(instance: *Instance, desc: SurfaceDesc) !Surface {
return Surface{ .impl = try instance.impl.initSurface(desc) };
}
pub fn deinitSurface(instance: *Instance, surface: *Surface) void {
instance.impl.deinitSurface(&surface.impl);
}
pub fn initAdapter(instance: *Instance, desc: AdapterDesc) !Adapter {
return Adapter{ .impl = try instance.impl.initAdapter(desc) };
}
pub fn deinitAdapter(instance: *Instance, adapter: *Adapter) void {
instance.impl.deinitAdapter(&adapter.impl);
}
};
const CanvasWindowInfo = struct {
canvas_id: []const u8,
};
const SurfaceWindowInfo: type = switch (cfg.platform) {
.web => CanvasWindowInfo,
else => @compileError("Unsupported platform!"),
};
pub const SurfaceDesc = struct {
window_info: SurfaceWindowInfo,
};
pub const Surface = struct {
impl: api.Surface,
pub fn getPreferredFormat(surface: *Surface) !TextureFormat {
return try surface.impl.getPreferredFormat();
}
};
pub const PowerPreference = enum {
low_power,
high_performance,
};
pub const AdapterDesc = struct {
impl: api.AdapterDesc = .{},
pub fn setPowerPreference(desc: *AdapterDesc, power_preference: PowerPreference) void {
desc.impl.setPowerPreference(power_preference);
}
pub fn setForceFallbackAdapter(desc: *AdapterDesc, force_fallback_adapter: bool) void {
desc.impl.setForceFallbackAdapter(force_fallback_adapter);
}
};
pub const Adapter = struct {
impl: api.Adapter,
pub fn initDevice(adapter: *Adapter, desc: DeviceDesc) !Device {
return Device{ .impl = try adapter.impl.initDevice(desc) };
}
pub fn deinitDevice(adapter: *Adapter, device: *Device) void {
adapter.impl.deinitDevice(&device.impl);
}
};
pub const FeatureName = enum {
depth_clip_control,
depth24unorm_stencil8,
depth32float_stencil8,
timestamp_query,
pipeline_statistics_query,
texture_compression_bc,
texture_compression_etc2,
texture_compression_astc,
indirect_first_instance,
};
pub const Limits = struct {
max_texture_dimension_1d: ?u32 = null,
max_texture_dimension_2d: ?u32 = null,
max_texture_dimension_3d: ?u32 = null,
max_texture_array_layers: ?u32 = null,
max_bind_groups: ?u32 = null,
max_dynamic_uniform_buffers_per_pipeline_layout: ?u32 = null,
max_dynamic_storage_buffers_per_pipeline_layout: ?u32 = null,
max_sampled_textures_per_shader_stage: ?u32 = null,
max_samplers_per_shader_stage: ?u32 = null,
max_storage_buffers_per_shader_stage: ?u32 = null,
max_storage_textures_per_shader_stage: ?u32 = null,
max_uniform_buffers_per_shader_stage: ?u32 = null,
max_uniform_buffer_binding_size: ?u32 = null,
max_storage_buffer_binding_size: ?u32 = null,
min_uniform_buffer_offset_alignment: ?u32 = null,
min_storage_buffer_offset_alignment: ?u32 = null,
max_vertex_buffers: ?u32 = null,
max_vertex_attributes: ?u32 = null,
max_vertex_buffer_array_stride: ?u32 = null,
max_inter_stage_shader_components: ?u32 = null,
max_compute_workgroup_storage_size: ?u32 = null,
max_compute_invocations_per_workgroup: ?u32 = null,
max_compute_workgroup_size_x: ?u32 = null,
max_compute_workgroup_size_y: ?u32 = null,
max_compute_workgroup_size_z: ?u32 = null,
max_compute_workgroups_per_dimension: ?u32 = null,
};
pub const DeviceDesc = struct {
impl: api.DeviceDesc = .{},
pub fn setRequiredFeatures(desc: *DeviceDesc, required_features: []const FeatureName) void {
desc.impl.setRequiredFeatures(required_features);
}
pub fn setRequiredLimits(desc: *DeviceDesc, required_limits: Limits) void {
desc.impl.setRequiredLimits(required_limits);
}
};
pub const Device = struct {
impl: api.Device,
pub fn initSwapchain(device: *Device, surface: *Surface, desc: SwapchainDesc) !Swapchain {
return Swapchain{ .impl = try device.impl.initSwapchain(&surface.impl, desc) };
}
pub fn deinitSwapchain(device: *Device, swapchain: *Swapchain) void {
device.impl.deinitSwapchain(&swapchain.impl);
}
pub fn initShader(device: *Device, data: []const u8) !Shader {
return Shader{ .impl = try device.impl.initShader(data) };
}
pub fn deinitShader(device: *Device, shader: *Shader) void {
device.impl.deinitShader(&shader.impl);
}
pub fn initBuffer(device: *Device, desc: BufferDesc) !Buffer {
return Buffer{ .impl = try device.impl.initBuffer(desc) };
}
pub fn initBufferSlice(device: *Device, slice: anytype, usage: BufferUsage) !Buffer {
const bytes = std.mem.sliceAsBytes(slice);
return try device.initBuffer(.{ .size = bytes.len, .usage = usage, .data = bytes });
}
pub fn deinitBuffer(device: *Device, buffer: *Buffer) void {
device.impl.deinitBuffer(&buffer.impl);
}
pub fn initTexture(device: *Device, desc: TextureDesc) !Texture {
return Texture{ .impl = try device.impl.initTexture(desc) };
}
pub fn deinitTexture(device: *Device, texture: *Texture) void {
device.impl.deinitTexture(&texture.impl);
}
pub fn initTextureView(device: *Device, desc: TextureViewDesc) !TextureView {
return TextureView{ .impl = try device.impl.initTextureView(desc) };
}
pub fn deinitTextureView(device: *Device, texture_view: *TextureView) void {
device.impl.deinitTextureView(&texture_view.impl);
}
pub fn initSampler(device: *Device, desc: SamplerDesc) !Sampler {
return Sampler{ .impl = try device.impl.initSampler(desc) };
}
pub fn deinitSampler(device: *Device, sampler: *Sampler) void {
device.impl.deinitSampler(&sampler.impl);
}
pub fn initBindGroupLayout(device: *Device, desc: BindGroupLayoutDesc) !BindGroupLayout {
return BindGroupLayout{ .impl = try device.impl.initBindGroupLayout(desc) };
}
pub fn deinitBindGroupLayout(device: *Device, bind_group_layout: *BindGroupLayout) void {
device.impl.deinitBindGroupLayout(&bind_group_layout.impl);
}
pub fn initBindGroup(device: *Device, desc: BindGroupDesc) !BindGroup {
return BindGroup{ .impl = try device.impl.initBindGroup(desc) };
}
pub fn deinitBindGroup(device: *Device, bind_group: *BindGroup) void {
device.impl.deinitBindGroup(&bind_group.impl);
}
pub fn initPipelineLayout(device: *Device, desc: PipelineLayoutDesc) !PipelineLayout {
return PipelineLayout{ .impl = try device.impl.initPipelineLayout(desc) };
}
pub fn deinitPipelineLayout(device: *Device, pipeline_layout: *PipelineLayout) void {
device.impl.deinitPipelineLayout(&pipeline_layout.impl);
}
pub fn initRenderPipeline(device: *Device, desc: RenderPipelineDesc) !RenderPipeline {
return RenderPipeline{ .impl = try device.impl.initRenderPipeline(desc) };
}
pub fn deinitRenderPipeline(device: *Device, render_pipeline: *RenderPipeline) void {
device.impl.deinitRenderPipeline(&render_pipeline.impl);
}
pub fn initCommandEncoder(device: *Device) !CommandEncoder {
return CommandEncoder{ .impl = try device.impl.initCommandEncoder() };
}
pub fn getQueue(device: *Device) Queue {
return Queue{ .impl = device.impl.getQueue() };
}
};
pub const Extent3d = struct {
width: u32,
height: u32,
depth_or_array_layers: u32 = 1,
};
pub const SwapchainDesc = struct {
size: Extent3d,
format: TextureFormat,
};
pub const Swapchain = struct {
impl: api.Swapchain,
pub fn getCurrentTextureView(swapchain: *Swapchain) !TextureView {
return TextureView{ .impl = try swapchain.impl.getCurrentTextureView() };
}
pub fn present(swapchain: *Swapchain) !void {
try swapchain.impl.present();
}
};
pub const ShaderStage = packed struct {
vertex: bool = false,
fragment: bool = false,
compute: bool = false,
};
pub const Shader = struct {
impl: api.Shader,
};
pub const BufferUsage = packed struct {
map_read: bool = false,
map_write: bool = false,
copy_src: bool = false,
copy_dst: bool = false,
index: bool = false,
vertex: bool = false,
uniform: bool = false,
storage: bool = false,
indirect: bool = false,
query_resolve: bool = false,
};
pub const whole_size = std.math.maxInt(usize);
pub const BufferDesc = struct {
size: usize,
usage: BufferUsage,
data: ?[]const u8 = null,
};
pub const Buffer = struct {
impl: api.Buffer,
};
pub const TextureFormat = enum {
r8unorm,
r8snorm,
r8uint,
r8sint,
r16uint,
r16sint,
r16float,
rg8unorm,
rg8snorm,
rg8uint,
rg8sint,
r32float,
r32uint,
r32sint,
rg16uint,
rg16sint,
rg16float,
rgba8unorm,
rgba8unorm_srgb,
rgba8snorm,
rgba8uint,
rgba8sint,
bgra8unorm,
bgra8unorm_srgb,
rgb10a2unorm,
rg11b10ufloat,
rgb9e5ufloat,
rg32float,
rg32uint,
rg32sint,
rgba16uint,
rgba16sint,
rgba16float,
rgba32float,
rgba32uint,
rgba32sint,
stencil8,
depth16unorm,
depth24plus,
depth24plus_stencil8,
depth24unorm_stencil8,
depth32float,
depth32float_stencil8,
bc1_rgba_unorm,
bc1_rgba_unorm_srgb,
bc2_rgba_unorm,
bc2_rgba_unorm_srgb,
bc3_rgba_unorm,
bc3_rgba_unorm_srgb,
bc4_r_unorm,
bc4_r_snorm,
bc5_rg_unorm,
bc5_rg_snorm,
bc6h_rgb_ufloat,
bc6h_rgb_float,
bc7_rgba_unorm,
bc7_rgba_unorm_srgb,
etc2_rgb8unorm,
etc2_rgb8unorm_srgb,
etc2_rgb8a1unorm,
etc2_rgb8a1unorm_srgb,
etc2_rgba8unorm,
etc2_rgba8unorm_srgb,
eac_r11unorm,
eac_r11snorm,
eac_rg11unorm,
eac_rg11snorm,
astc_4x4_unorm,
astc_4x4_unorm_srgb,
astc_5x4_unorm,
astc_5x4_unorm_srgb,
astc_5x5_unorm,
astc_5x5_unorm_srgb,
astc_6x5_unorm,
astc_6x5_unorm_srgb,
astc_6x6_unorm,
astc_6x6_unorm_srgb,
astc_8x5_unorm,
astc_8x5_unorm_srgb,
astc_8x6_unorm,
astc_8x6_unorm_srgb,
astc_8x8_unorm,
astc_8x8_unorm_srgb,
astc_10x5_unorm,
astc_10x5_unorm_srgb,
astc_10x6_unorm,
astc_10x6_unorm_srgb,
astc_10x8_unorm,
astc_10x8_unorm_srgb,
astc_10x10_unorm,
astc_10x10_unorm_srgb,
astc_12x10_unorm,
astc_12x10_unorm_srgb,
astc_12x12_unorm,
astc_12x12_unorm_srgb,
};
pub const TextureUsage = packed struct {
copy_src: bool = false,
copy_dst: bool = false,
texture_binding: bool = false,
storage_binding: bool = false,
render_attachment: bool = false,
};
pub const TextureViewDimension = enum {
@"1d",
@"2d",
@"2d_array",
cube,
cube_array,
@"3d",
};
pub const TextureDesc = struct {
size: Extent3d,
format: TextureFormat,
usage: TextureUsage,
dimension: TextureViewDimension = .@"2d",
mip_level_count: u32 = 1,
sample_count: u32 = 1,
};
pub const Texture = struct {
impl: api.Texture,
};
pub const TextureAspect = enum {
all,
stencil_only,
depth_only,
};
pub const TextureViewDesc = struct {
texture: *Texture,
format: TextureFormat,
dimension: TextureViewDimension = .@"2d",
aspect: TextureAspect = .all,
base_mip_level: u32 = 0,
mip_level_count: u32 = 1,
base_array_layer: u32 = 0,
array_layer_count: u32 = 1,
};
pub const TextureView = struct {
impl: api.TextureView,
};
pub const AddressMode = enum {
clamp_to_edge,
repeat,
mirror_repeat,
};
pub const FilterMode = enum {
nearest,
linear,
};
pub const SamplerDesc = struct {
address_mode_u: AddressMode = .clamp_to_edge,
address_mode_v: AddressMode = .clamp_to_edge,
address_mode_w: AddressMode = .clamp_to_edge,
mag_filter: FilterMode = .nearest,
min_filter: FilterMode = .nearest,
mipmap_filter: FilterMode = .nearest,
lod_min_clamp: f32 = 0.0,
lod_max_clamp: f32 = 32.0,
max_anisotropy: u16 = 1,
compare: ?CompareFunction = null,
};
pub const Sampler = struct {
impl: api.Sampler,
};
pub const BufferBindingType = enum {
uniform,
storage,
read_only_storage,
};
pub const BufferBindingLayout = struct {
@"type": BufferBindingType = .uniform,
has_dynamic_offset: bool = false,
min_binding_size: usize = 0,
};
pub const TextureSampleType = enum {
float,
unfilterable_float,
depth,
sint,
uint,
};
pub const TextureBindingLayout = struct {
sample_type: TextureSampleType = .float,
view_dimension: TextureViewDimension = .@"2d",
multisampled: bool = false,
};
pub const StorageTextureAccess = enum {
write_only,
};
pub const StorageTextureBindingLayout = struct {
format: TextureFormat,
access: StorageTextureAccess = .write_only,
view_dimension: TextureViewDimension = .@"2d",
};
pub const SamplerBindingType = enum {
filtering,
non_filtering,
comparison,
};
pub const SamplerBindingLayout = struct {
@"type": SamplerBindingType = .filtering,
};
pub const BindGroupLayoutEntry = struct {
binding: u32,
visibility: ShaderStage,
buffer: ?BufferBindingLayout = null,
texture: ?TextureBindingLayout = null,
storage_texture: ?StorageTextureBindingLayout = null,
sampler: ?SamplerBindingLayout = null,
};
pub const BindGroupLayoutDesc = struct {
entries: []const BindGroupLayoutEntry,
};
pub const BindGroupLayout = struct {
impl: api.BindGroupLayout,
};
pub const BufferBinding = struct {
buffer: *const Buffer,
offset: usize = 0,
size: usize = whole_size,
};
pub const BindingResource = union(enum) {
buffer_binding: BufferBinding,
texture_view: *const TextureView,
sampler: *const Sampler,
};
pub const BindGroupEntry = struct {
binding: u32,
resource: BindingResource,
};
pub const BindGroupDesc = struct {
layout: *const BindGroupLayout,
entries: []const BindGroupEntry,
};
pub const BindGroup = struct {
impl: api.BindGroup,
};
pub const PipelineLayoutDesc = struct {
bind_group_layouts: []const BindGroupLayout,
};
pub const PipelineLayout = struct {
impl: api.PipelineLayout,
};
pub const VertexFormat = enum {
uint8x2,
uint8x4,
sint8x2,
sint8x4,
unorm8x2,
unorm8x4,
snorm8x2,
snorm8x4,
uint16x2,
uint16x4,
sint16x2,
sint16x4,
unorm16x2,
unorm16x4,
snorm16x2,
snorm16x4,
float16x2,
float16x4,
float32,
float32x2,
float32x3,
float32x4,
uint32,
uint32x2,
uint32x3,
uint32x4,
sint32,
sint32x2,
sint32x3,
sint32x4,
};
pub const VertexAttribute = struct {
format: VertexFormat,
offset: usize,
shader_location: u32,
};
pub const VertexStepMode = enum {
vertex,
instance,
};
pub const VertexBufferLayout = struct {
array_stride: usize,
step_mode: VertexStepMode = .vertex,
attributes: []const VertexAttribute,
};
pub const VertexState = struct {
module: *const Shader,
entry_point: []const u8,
buffers: []const VertexBufferLayout = &.{},
};
pub fn getVertexBufferLayoutStruct(
comptime Type: type,
comptime step_mode: VertexStepMode,
comptime base_location: u32,
) VertexBufferLayout {
comptime var types: []const type = &.{};
inline for (@typeInfo(Type).Struct.fields) |field| {
types = types ++ &[_]type{field.field_type};
}
return getVertexBufferLayoutTypes(types, step_mode, base_location);
}
pub fn getVertexBufferLayoutTypes(
comptime types: []const type,
comptime step_mode: VertexStepMode,
comptime base_location: u32,
) VertexBufferLayout {
comptime var attributes: []const VertexAttribute = &.{};
comptime var offset: usize = 0;
comptime var location: u32 = base_location;
inline for (types) |Type| {
attributes = attributes ++ &[_]VertexAttribute{
.{ .format = getVertexFormat(Type), .offset = offset, .shader_location = location },
};
if (offset % @sizeOf(Type) != 0) {
@compileError("Invalid alignment for vertex buffer layout!");
}
offset += @sizeOf(Type);
location += 1;
}
return VertexBufferLayout{
.array_stride = offset,
.step_mode = step_mode,
.attributes = attributes,
};
}
fn getVertexFormat(comptime Type: type) VertexFormat {
return switch (@typeInfo(Type)) {
.Int, .ComptimeInt, .Float, .ComptimeFloat => getVertexFormatWithLen(Type, 1),
.Array => |A| getVertexFormatWithLen(A.child, A.len),
.Vector => |V| getVertexFormatWithLen(V.child, V.len),
.Struct => |S| block: {
if (S.fields.len == 0 or S.fields.len > 4) {
@compileError("Invalid number of fields for vertex attribute!");
}
const field_type = S.fields[0].field_type;
if (@typeInfo(field_type) != .Int and @typeInfo(field_type) != .Float) {
@compileError("Vertex attribute structs must be composed of ints or floats!");
}
inline for (S.fields) |field| {
if (field.field_type != field_type) {
@compileError("Vertex attribute fields must be homogenous!");
}
}
break :block getVertexFormatWithLen(field_type, S.fields.len);
},
else => @compileError("Invalid vertex attribute type " ++ @typeName(Type) ++ "!"),
};
}
fn getVertexFormatWithLen(comptime Type: type, len: comptime_int) VertexFormat {
return switch (@typeInfo(Type)) {
.Int => |I| switch (I.signedness) {
.signed => switch (I.bits) {
8 => switch (len) {
2 => .sint8x2,
4 => .sint8x4,
else => @compileError("Invalid len for vertex attribute!"),
},
16 => switch (len) {
2 => .sint16x2,
4 => .sint16x4,
else => @compileError("Invalid len for vertex attribute!"),
},
32 => switch (len) {
1 => .sint32,
2 => .sint32x2,
3 => .sint32x3,
4 => .sint32x4,
else => @compileError("Invalid len for vertex attribute!"),
},
else => @compileError("Invalid bit size for vertex attribute!"),
},
.unsigned => switch (I.bits) {
8 => switch (len) {
2 => .uint8x2,
4 => .uint8x4,
else => @compileError("Invalid len for vertex attribute!"),
},
16 => switch (len) {
2 => .uint16x2,
4 => .uint16x4,
else => @compileError("Invalid len for vertex attribute!"),
},
32 => switch (len) {
1 => .uint32,
2 => .uint32x2,
3 => .uint32x3,
4 => .uint32x4,
else => @compileError("Invalid len for vertex attribute!"),
},
else => @compileError("Invalid bit size for vertex attribute!"),
},
},
.Float => |F| switch (F.bits) {
16 => switch (len) {
2 => .float16x2,
4 => .float16x4,
else => @compileError("Invalid len for vertex attribute"),
},
32 => switch (len) {
1 => .float32,
2 => .float32x2,
3 => .float32x3,
4 => .float32x4,
else => @compileError("Invalid len for vertex attribute"),
},
else => @compileError("Invalid bit size for vertex attribute!"),
},
else => @compileError("Invalid vertex attribute type " ++ @typeName(Type) ++ "!"),
};
}
pub const PrimitiveTopology = enum {
point_list,
line_list,
line_strip,
triangle_list,
triangle_strip,
};
pub const FrontFace = enum {
ccw,
cw,
};
pub const CullMode = enum {
none,
front,
back,
};
pub const IndexFormat = enum {
uint16,
uint32,
};
pub const PrimitiveState = struct {
topology: PrimitiveTopology = .triangle_list,
front_face: FrontFace = .ccw,
cull_mode: CullMode = .none,
strip_index_format: ?IndexFormat = null,
};
pub const CompareFunction = enum {
never,
less,
less_equal,
greater,
greater_equal,
equal,
not_equal,
always,
};
pub const StencilOperation = enum {
keep,
zero,
replace,
invert,
increment_clamp,
decrement_clamp,
increment_wrap,
decrement_wrap,
};
pub const StencilFaceState = struct {
compare: CompareFunction = .always,
fail_op: StencilOperation = .keep,
depth_fail_op: StencilOperation = .keep,
pass_op: StencilOperation = .keep,
};
pub const DepthStencilState = struct {
format: TextureFormat,
depth_write_enabled: bool = false,
depth_compare: CompareFunction = .always,
depth_bias: i32 = 0,
depth_bias_clamp: f32 = 0.0,
depth_bias_slope_scale: f32 = 0.0,
stencil_front: StencilFaceState = .{},
stencil_back: StencilFaceState = .{},
stencil_read_mask: u32 = 0xFFFFFFFF,
stencil_write_mask: u32 = 0xFFFFFFFF,
};
pub const MultisampleState = struct {
count: u32 = 1,
mask: u32 = 0xFFFFFFFF,
alpha_to_coverage_enabled: bool = false,
};
pub const BlendOperation = enum {
add,
subtract,
reverse_subtract,
min,
max,
};
pub const BlendFactor = enum {
zero,
one,
src,
one_minus_src,
src_alpha,
one_minus_src_alpha,
dst,
one_minus_dst,
dst_alpha,
one_minus_dst_alpha,
src_alpha_saturated,
constant,
one_minus_constant,
};
pub const BlendComponent = struct {
operation: BlendOperation = .add,
src_factor: BlendFactor = .one,
dst_factor: BlendFactor = .zero,
};
pub const BlendState = struct {
color: BlendComponent = .{},
alpha: BlendComponent = .{},
};
pub const ColorWrite = packed struct {
red: bool = false,
green: bool = false,
blue: bool = false,
alpha: bool = false,
pub const all = ColorWrite{ .red = true, .green = true, .blue = true, .alpha = true };
};
pub const ColorTargetState = struct {
format: TextureFormat,
blend: BlendState = .{},
write_mask: ColorWrite = ColorWrite.all,
};
pub const FragmentState = struct {
module: *const Shader,
entry_point: []const u8,
targets: []const ColorTargetState,
};
pub const RenderPipelineDesc = struct {
impl: api.RenderPipelineDesc = .{},
pub fn setPipelineLayout(
desc: *RenderPipelineDesc,
pipeline_layout: *const PipelineLayout,
) void {
desc.impl.setPipelineLayout(pipeline_layout);
}
pub fn setVertexState(desc: *RenderPipelineDesc, vertex_state: VertexState) void {
desc.impl.setVertexState(vertex_state);
}
pub fn setPrimitiveState(desc: *RenderPipelineDesc, primitive_state: PrimitiveState) void {
desc.impl.setPrimitiveState(primitive_state);
}
pub fn setDepthStencilState(
desc: *RenderPipelineDesc,
depth_stencil_state: DepthStencilState,
) void {
desc.impl.setDepthStencilState(depth_stencil_state);
}
pub fn setMultisampleState(
desc: *RenderPipelineDesc,
multisample_state: MultisampleState,
) void {
desc.impl.setMultisampleState(multisample_state);
}
pub fn setFragmentState(desc: *RenderPipelineDesc, fragment_state: FragmentState) void {
desc.impl.setFragmentState(fragment_state);
}
};
pub const RenderPipeline = struct {
impl: api.RenderPipeline,
};
pub const CommandEncoder = struct {
impl: api.CommandEncoder,
pub fn beginRenderPass(encoder: *CommandEncoder, desc: RenderPassDesc) !RenderPass {
return RenderPass{ .impl = try encoder.impl.beginRenderPass(desc) };
}
pub fn finish(encoder: *CommandEncoder) !CommandBuffer {
return CommandBuffer{ .impl = try encoder.impl.finish() };
}
};
pub const CommandBuffer = struct {
impl: api.CommandBuffer,
};
pub const LoadOp = enum {
load,
clear,
};
pub const StoreOp = enum {
store,
discard,
};
pub const Color = struct {
r: f32,
g: f32,
b: f32,
a: f32,
};
pub const ColorAttachment = struct {
view: *const TextureView,
resolve_target: ?*const TextureView = null,
load_op: LoadOp,
store_op: StoreOp,
clear_value: Color = Color{ .r = 0.0, .g = 0.0, .b = 0.0, .a = 1.0 },
};
pub const DepthStencilAttachment = struct {
view: *const TextureView,
depth_clear_value: f32 = 0.0,
depth_load_op: ?LoadOp = null,
depth_store_op: ?StoreOp = null,
depth_read_only: bool = false,
stencil_clear_value: u32 = 0,
stencil_load_op: ?LoadOp = null,
stencil_store_op: ?StoreOp = null,
stencil_read_only: bool = false,
};
pub const RenderPassDesc = struct {
impl: api.RenderPassDesc = .{},
pub fn setColorAttachments(
desc: *RenderPassDesc,
color_attachments: []const ColorAttachment,
) void {
desc.impl.setColorAttachments(color_attachments);
}
pub fn setDepthStencilAttachment(
desc: *RenderPassDesc,
depth_stencil_attachment: DepthStencilAttachment,
) void {
desc.impl.setDepthStencilAttachment(depth_stencil_attachment);
}
};
pub const RenderPass = struct {
impl: api.RenderPass,
pub fn setPipeline(render_pass: *RenderPass, render_pipeline: *const RenderPipeline) !void {
try render_pass.impl.setPipeline(&render_pipeline.impl);
}
pub fn setBindGroup(
render_pass: *RenderPass,
group_index: u32,
group: *const BindGroup,
dynamic_offsets: ?[]const u32,
) !void {
try render_pass.impl.setBindGroup(group_index, &group.impl, dynamic_offsets);
}
pub fn setVertexBuffer(
render_pass: *RenderPass,
slot: u32,
buffer: *const Buffer,
offset: u32,
size: usize,
) !void {
try render_pass.impl.setVertexBuffer(slot, &buffer.impl, offset, size);
}
pub fn setIndexBuffer(
render_pass: *RenderPass,
buffer: *const Buffer,
index_format: IndexFormat,
offset: u32,
size: usize,
) !void {
try render_pass.impl.setIndexBuffer(&buffer.impl, index_format, offset, size);
}
pub fn draw(
render_pass: *RenderPass,
vertex_count: usize,
instance_count: usize,
first_vertex: usize,
first_instance: usize,
) !void {
try render_pass.impl.draw(vertex_count, instance_count, first_vertex, first_instance);
}
pub fn drawIndexed(
render_pass: *RenderPass,
index_count: usize,
instance_count: usize,
first_index: usize,
base_vertex: i32,
first_instance: usize,
) !void {
try render_pass.impl.drawIndexed(
index_count,
instance_count,
first_index,
base_vertex,
first_instance,
);
}
pub fn end(render_pass: *RenderPass) !void {
try render_pass.impl.end();
}
};
pub const Queue = struct {
impl: api.Queue,
pub fn writeBuffer(
queue: *Queue,
buffer: *const Buffer,
buffer_offset: usize,
data: []const u8,
data_offset: usize,
) !void {
try queue.impl.writeBuffer(&buffer.impl, buffer_offset, data, data_offset);
}
pub fn submit(queue: *Queue, buffers: []const CommandBuffer) !void {
try queue.impl.submit(buffers);
}
}; | src/gfx.zig |
const ctz = @import("count0bits.zig");
const testing = @import("std").testing;
fn test__ctzti2(a: u128, expected: i32) !void {
var x = @bitCast(i128, a);
var result = ctz.__ctzti2(x);
try testing.expectEqual(expected, result);
}
test "ctzti2" {
try test__ctzti2(0x00000000_00000000_00000000_00000001, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000002, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000003, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000004, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000005, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000006, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000007, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000008, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000009, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000000A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000000B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000000C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000000D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000000E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000000F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000010, 4);
try test__ctzti2(0x00000000_00000000_00000000_00000011, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000012, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000013, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000014, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000015, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000016, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000017, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000018, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000019, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000001A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000001B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000001C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000001D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000001E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000001F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000020, 5);
try test__ctzti2(0x00000000_00000000_00000000_00000021, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000022, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000023, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000024, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000025, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000026, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000027, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000028, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000029, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000002A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000002B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000002C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000002D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000002E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000002F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000030, 4);
try test__ctzti2(0x00000000_00000000_00000000_00000031, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000032, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000033, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000034, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000035, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000036, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000037, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000038, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000039, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000003A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000003B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000003C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000003D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000003E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000003F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000040, 6);
try test__ctzti2(0x00000000_00000000_00000000_00000041, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000042, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000043, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000044, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000045, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000046, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000047, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000048, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000049, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000004A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000004B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000004C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000004D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000004E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000004F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000050, 4);
try test__ctzti2(0x00000000_00000000_00000000_00000051, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000052, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000053, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000054, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000055, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000056, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000057, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000058, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000059, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000005A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000005B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000005C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000005D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000005E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000005F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000060, 5);
try test__ctzti2(0x00000000_00000000_00000000_00000061, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000062, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000063, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000064, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000065, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000066, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000067, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000068, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000069, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000006A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000006B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000006C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000006D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000006E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000006F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000070, 4);
try test__ctzti2(0x00000000_00000000_00000000_00000071, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000072, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000073, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000074, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000075, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000076, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000077, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000078, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000079, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000007A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000007B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000007C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000007D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000007E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000007F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000080, 7);
try test__ctzti2(0x00000000_00000000_00000000_00000081, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000082, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000083, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000084, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000085, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000086, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000087, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000088, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000089, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000008A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000008B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000008C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000008D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000008E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000008F, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000090, 4);
try test__ctzti2(0x00000000_00000000_00000000_00000091, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000092, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000093, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000094, 2);
try test__ctzti2(0x00000000_00000000_00000000_00000095, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000096, 1);
try test__ctzti2(0x00000000_00000000_00000000_00000097, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000098, 3);
try test__ctzti2(0x00000000_00000000_00000000_00000099, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000009A, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000009B, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000009C, 2);
try test__ctzti2(0x00000000_00000000_00000000_0000009D, 0);
try test__ctzti2(0x00000000_00000000_00000000_0000009E, 1);
try test__ctzti2(0x00000000_00000000_00000000_0000009F, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000A0, 5);
try test__ctzti2(0x00000000_00000000_00000000_000000A1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000A2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000A3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000A4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000A5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000A6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000A7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000A8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000A9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000AA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000AB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000AC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000AD, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000AE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000AF, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000B0, 4);
try test__ctzti2(0x00000000_00000000_00000000_000000B1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000B2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000B3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000B4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000B5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000B6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000B7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000B8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000B9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000BA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000BB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000BC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000BD, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000BE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000BF, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000C0, 6);
try test__ctzti2(0x00000000_00000000_00000000_000000C1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000C2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000C3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000C4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000C5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000C6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000C7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000C8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000C9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000CA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000CB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000CC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000CD, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000CE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000CF, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000D0, 4);
try test__ctzti2(0x00000000_00000000_00000000_000000D1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000D2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000D3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000D4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000D5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000D6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000D7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000D8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000D9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000DA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000DB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000DC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000DD, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000DE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000DF, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000E0, 5);
try test__ctzti2(0x00000000_00000000_00000000_000000E1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000E2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000E3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000E4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000E5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000E6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000E7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000E8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000E9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000EA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000EB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000EC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000ED, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000EE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000EF, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000F0, 4);
try test__ctzti2(0x00000000_00000000_00000000_000000F1, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000F2, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000F3, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000F4, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000F5, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000F6, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000F7, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000F8, 3);
try test__ctzti2(0x00000000_00000000_00000000_000000F9, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000FA, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000FB, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000FC, 2);
try test__ctzti2(0x00000000_00000000_00000000_000000FD, 0);
try test__ctzti2(0x00000000_00000000_00000000_000000FE, 1);
try test__ctzti2(0x00000000_00000000_00000000_000000FF, 0);
try test__ctzti2(0x00000000_00000000_00000000_00000000, 128);
try test__ctzti2(0x80000000_00000000_00000000_00000000, 127);
try test__ctzti2(0x40000000_00000000_00000000_00000000, 126);
try test__ctzti2(0x20000000_00000000_00000000_00000000, 125);
try test__ctzti2(0x10000000_00000000_00000000_00000000, 124);
try test__ctzti2(0x08000000_00000000_00000000_00000000, 123);
try test__ctzti2(0x04000000_00000000_00000000_00000000, 122);
try test__ctzti2(0x02000000_00000000_00000000_00000000, 121);
try test__ctzti2(0x01000000_00000000_00000000_00000000, 120);
try test__ctzti2(0x00800000_00000000_00000000_00000000, 119);
try test__ctzti2(0x00400000_00000000_00000000_00000000, 118);
try test__ctzti2(0x00200000_00000000_00000000_00000000, 117);
try test__ctzti2(0x00100000_00000000_00000000_00000000, 116);
try test__ctzti2(0x00080000_00000000_00000000_00000000, 115);
try test__ctzti2(0x00040000_00000000_00000000_00000000, 114);
try test__ctzti2(0x00020000_00000000_00000000_00000000, 113);
try test__ctzti2(0x00010000_00000000_00000000_00000000, 112);
try test__ctzti2(0x00008000_00000000_00000000_00000000, 111);
try test__ctzti2(0x00004000_00000000_00000000_00000000, 110);
try test__ctzti2(0x00002000_00000000_00000000_00000000, 109);
try test__ctzti2(0x00001000_00000000_00000000_00000000, 108);
try test__ctzti2(0x00000800_00000000_00000000_00000000, 107);
try test__ctzti2(0x00000400_00000000_00000000_00000000, 106);
try test__ctzti2(0x00000200_00000000_00000000_00000000, 105);
try test__ctzti2(0x00000100_00000000_00000000_00000000, 104);
try test__ctzti2(0x00000080_00000000_00000000_00000000, 103);
try test__ctzti2(0x00000040_00000000_00000000_00000000, 102);
try test__ctzti2(0x00000020_00000000_00000000_00000000, 101);
try test__ctzti2(0x00000010_00000000_00000000_00000000, 100);
try test__ctzti2(0x00000008_00000000_00000000_00000000, 99);
try test__ctzti2(0x00000004_00000000_00000000_00000000, 98);
try test__ctzti2(0x00000002_00000000_00000000_00000000, 97);
try test__ctzti2(0x00000001_00000000_00000000_00000000, 96);
try test__ctzti2(0x00000000_80000000_00000000_00000000, 95);
try test__ctzti2(0x00000000_40000000_00000000_00000000, 94);
try test__ctzti2(0x00000000_20000000_00000000_00000000, 93);
try test__ctzti2(0x00000000_10000000_00000000_00000000, 92);
try test__ctzti2(0x00000000_08000000_00000000_00000000, 91);
try test__ctzti2(0x00000000_04000000_00000000_00000000, 90);
try test__ctzti2(0x00000000_02000000_00000000_00000000, 89);
try test__ctzti2(0x00000000_01000000_00000000_00000000, 88);
try test__ctzti2(0x00000000_00800000_00000000_00000000, 87);
try test__ctzti2(0x00000000_00400000_00000000_00000000, 86);
try test__ctzti2(0x00000000_00200000_00000000_00000000, 85);
try test__ctzti2(0x00000000_00100000_00000000_00000000, 84);
try test__ctzti2(0x00000000_00080000_00000000_00000000, 83);
try test__ctzti2(0x00000000_00040000_00000000_00000000, 82);
try test__ctzti2(0x00000000_00020000_00000000_00000000, 81);
try test__ctzti2(0x00000000_00010000_00000000_00000000, 80);
try test__ctzti2(0x00000000_00008000_00000000_00000000, 79);
try test__ctzti2(0x00000000_00004000_00000000_00000000, 78);
try test__ctzti2(0x00000000_00002000_00000000_00000000, 77);
try test__ctzti2(0x00000000_00001000_00000000_00000000, 76);
try test__ctzti2(0x00000000_00000800_00000000_00000000, 75);
try test__ctzti2(0x00000000_00000400_00000000_00000000, 74);
try test__ctzti2(0x00000000_00000200_00000000_00000000, 73);
try test__ctzti2(0x00000000_00000100_00000000_00000000, 72);
try test__ctzti2(0x00000000_00000080_00000000_00000000, 71);
try test__ctzti2(0x00000000_00000040_00000000_00000000, 70);
try test__ctzti2(0x00000000_00000020_00000000_00000000, 69);
try test__ctzti2(0x00000000_00000010_00000000_00000000, 68);
try test__ctzti2(0x00000000_00000008_00000000_00000000, 67);
try test__ctzti2(0x00000000_00000004_00000000_00000000, 66);
try test__ctzti2(0x00000000_00000002_00000000_00000000, 65);
try test__ctzti2(0x00000000_00000001_00000000_00000000, 64);
try test__ctzti2(0x00000000_00000000_80000000_00000000, 63);
try test__ctzti2(0x00000000_00000000_40000000_00000000, 62);
try test__ctzti2(0x00000000_00000000_20000000_00000000, 61);
try test__ctzti2(0x00000000_00000000_10000000_00000000, 60);
try test__ctzti2(0x00000000_00000000_08000000_00000000, 59);
try test__ctzti2(0x00000000_00000000_04000000_00000000, 58);
try test__ctzti2(0x00000000_00000000_02000000_00000000, 57);
try test__ctzti2(0x00000000_00000000_01000000_00000000, 56);
try test__ctzti2(0x00000000_00000000_00800000_00000000, 55);
try test__ctzti2(0x00000000_00000000_00400000_00000000, 54);
try test__ctzti2(0x00000000_00000000_00200000_00000000, 53);
try test__ctzti2(0x00000000_00000000_00100000_00000000, 52);
try test__ctzti2(0x00000000_00000000_00080000_00000000, 51);
try test__ctzti2(0x00000000_00000000_00040000_00000000, 50);
try test__ctzti2(0x00000000_00000000_00020000_00000000, 49);
try test__ctzti2(0x00000000_00000000_00010000_00000000, 48);
try test__ctzti2(0x00000000_00000000_00008000_00000000, 47);
try test__ctzti2(0x00000000_00000000_00004000_00000000, 46);
try test__ctzti2(0x00000000_00000000_00002000_00000000, 45);
try test__ctzti2(0x00000000_00000000_00001000_00000000, 44);
try test__ctzti2(0x00000000_00000000_00000800_00000000, 43);
try test__ctzti2(0x00000000_00000000_00000400_00000000, 42);
try test__ctzti2(0x00000000_00000000_00000200_00000000, 41);
try test__ctzti2(0x00000000_00000000_00000100_00000000, 40);
try test__ctzti2(0x00000000_00000000_00000080_00000000, 39);
try test__ctzti2(0x00000000_00000000_00000040_00000000, 38);
try test__ctzti2(0x00000000_00000000_00000020_00000000, 37);
try test__ctzti2(0x00000000_00000000_00000010_00000000, 36);
try test__ctzti2(0x00000000_00000000_00000008_00000000, 35);
try test__ctzti2(0x00000000_00000000_00000004_00000000, 34);
try test__ctzti2(0x00000000_00000000_00000002_00000000, 33);
try test__ctzti2(0x00000000_00000000_00000001_00000000, 32);
try test__ctzti2(0x00000000_00000000_00000000_80000000, 31);
try test__ctzti2(0x00000000_00000000_00000000_40000000, 30);
try test__ctzti2(0x00000000_00000000_00000000_20000000, 29);
try test__ctzti2(0x00000000_00000000_00000000_10000000, 28);
try test__ctzti2(0x00000000_00000000_00000000_08000000, 27);
try test__ctzti2(0x00000000_00000000_00000000_04000000, 26);
try test__ctzti2(0x00000000_00000000_00000000_02000000, 25);
try test__ctzti2(0x00000000_00000000_00000000_01000000, 24);
try test__ctzti2(0x00000000_00000000_00000000_00800000, 23);
try test__ctzti2(0x00000000_00000000_00000000_00400000, 22);
try test__ctzti2(0x00000000_00000000_00000000_00200000, 21);
try test__ctzti2(0x00000000_00000000_00000000_00100000, 20);
try test__ctzti2(0x00000000_00000000_00000000_00080000, 19);
try test__ctzti2(0x00000000_00000000_00000000_00040000, 18);
try test__ctzti2(0x00000000_00000000_00000000_00020000, 17);
try test__ctzti2(0x00000000_00000000_00000000_00010000, 16);
try test__ctzti2(0x00000000_00000000_00000000_00008000, 15);
try test__ctzti2(0x00000000_00000000_00000000_00004000, 14);
try test__ctzti2(0x00000000_00000000_00000000_00002000, 13);
try test__ctzti2(0x00000000_00000000_00000000_00001000, 12);
try test__ctzti2(0x00000000_00000000_00000000_00000800, 11);
try test__ctzti2(0x00000000_00000000_00000000_00000400, 10);
try test__ctzti2(0x00000000_00000000_00000000_00000200, 9);
try test__ctzti2(0x00000000_00000000_00000000_00000100, 8);
} | lib/std/special/compiler_rt/ctzti2_test.zig |
const std = @import("std");
const mach = @import("mach");
const gpu = @import("gpu");
compute_pipeline: gpu.ComputePipeline,
render_pipeline: gpu.RenderPipeline,
sprite_vertex_buffer: gpu.Buffer,
particle_buffers: [2]gpu.Buffer,
particle_bind_groups: [2]gpu.BindGroup,
sim_param_buffer: gpu.Buffer,
frame_counter: usize,
const App = @This();
const num_particle = 1500;
var sim_params = [_]f32{
0.04, // .delta_T
0.1, // .rule_1_distance
0.025, // .rule_2_distance
0.025, // .rule_3_distance
0.02, // .rule_1_scale
0.05, // .rule_2_scale
0.005, // .rule_3_scale
};
pub fn init(app: *App, engine: *mach.Engine) !void {
const sprite_shader_module = engine.gpu_driver.device.createShaderModule(&.{
.label = "sprite shader module",
.code = .{ .wgsl = @embedFile("sprite.wgsl") },
});
const update_sprite_shader_module = engine.gpu_driver.device.createShaderModule(&.{
.label = "update sprite shader module",
.code = .{ .wgsl = @embedFile("updateSprites.wgsl") },
});
const instanced_particles_attributes = [_]gpu.VertexAttribute{
.{
// instance position
.shader_location = 0,
.offset = 0,
.format = .float32x2,
},
.{
// instance velocity
.shader_location = 1,
.offset = 2 * 4,
.format = .float32x2,
},
};
const vertex_buffer_attributes = [_]gpu.VertexAttribute{
.{
// vertex positions
.shader_location = 2,
.offset = 0,
.format = .float32x2,
},
};
const render_pipeline = engine.gpu_driver.device.createRenderPipeline(&gpu.RenderPipeline.Descriptor{
.vertex = .{
.module = sprite_shader_module,
.entry_point = "vert_main",
.buffers = &[_]gpu.VertexBufferLayout{
.{
// instanced particles buffer
.array_stride = 4 * 4,
.step_mode = .instance,
.attribute_count = instanced_particles_attributes.len,
.attributes = &instanced_particles_attributes,
},
.{
// vertex buffer
.array_stride = 2 * 4,
.step_mode = .vertex,
.attribute_count = vertex_buffer_attributes.len,
.attributes = &vertex_buffer_attributes,
},
},
},
.fragment = &gpu.FragmentState{ .module = sprite_shader_module, .entry_point = "frag_main", .targets = &[_]gpu.ColorTargetState{
.{
.format = engine.gpu_driver.swap_chain_format,
},
} },
});
const compute_pipeline = engine.gpu_driver.device.createComputePipeline(&gpu.ComputePipeline.Descriptor{ .compute = gpu.ProgrammableStageDescriptor{
.module = update_sprite_shader_module,
.entry_point = "main",
} });
const vert_buffer_data = [_]f32{
-0.01, -0.02, 0.01,
-0.02, 0.0, 0.02,
};
const sprite_vertex_buffer = engine.gpu_driver.device.createBuffer(&gpu.Buffer.Descriptor{
.usage = .{ .vertex = true, .copy_dst = true },
.size = vert_buffer_data.len * @sizeOf(f32),
});
engine.gpu_driver.device.getQueue().writeBuffer(sprite_vertex_buffer, 0, f32, &vert_buffer_data);
const sim_param_buffer = engine.gpu_driver.device.createBuffer(&gpu.Buffer.Descriptor{
.usage = .{ .uniform = true, .copy_dst = true },
.size = sim_params.len * @sizeOf(f32),
});
engine.gpu_driver.device.getQueue().writeBuffer(sim_param_buffer, 0, f32, &sim_params);
var initial_particle_data: [num_particle * 4]f32 = undefined;
var rng = std.rand.DefaultPrng.init(0);
const random = rng.random();
var i: usize = 0;
while (i < num_particle) : (i += 1) {
initial_particle_data[4 * i + 0] = 2 * (random.float(f32) - 0.5);
initial_particle_data[4 * i + 1] = 2 * (random.float(f32) - 0.5);
initial_particle_data[4 * i + 2] = 2 * (random.float(f32) - 0.5) * 0.1;
initial_particle_data[4 * i + 3] = 2 * (random.float(f32) - 0.5) * 0.1;
}
var particle_buffers: [2]gpu.Buffer = undefined;
var particle_bind_groups: [2]gpu.BindGroup = undefined;
i = 0;
while (i < 2) : (i += 1) {
particle_buffers[i] = engine.gpu_driver.device.createBuffer(&gpu.Buffer.Descriptor{
.usage = .{
.vertex = true,
.copy_dst = true,
.storage = true,
},
.size = initial_particle_data.len * @sizeOf(f32),
});
engine.gpu_driver.device.getQueue().writeBuffer(particle_buffers[i], 0, f32, &initial_particle_data);
}
i = 0;
while (i < 2) : (i += 1) {
particle_bind_groups[i] = engine.gpu_driver.device.createBindGroup(&gpu.BindGroup.Descriptor{ .layout = compute_pipeline.getBindGroupLayout(0), .entries = &[_]gpu.BindGroup.Entry{
gpu.BindGroup.Entry.buffer(0, sim_param_buffer, 0, sim_params.len * @sizeOf(f32)),
gpu.BindGroup.Entry.buffer(1, particle_buffers[i], 0, initial_particle_data.len * @sizeOf(f32)),
gpu.BindGroup.Entry.buffer(2, particle_buffers[(i + 1) % 2], 0, initial_particle_data.len * @sizeOf(f32)),
} });
}
app.compute_pipeline = compute_pipeline;
app.render_pipeline = render_pipeline;
app.sprite_vertex_buffer = sprite_vertex_buffer;
app.particle_buffers = particle_buffers;
app.particle_bind_groups = particle_bind_groups;
app.sim_param_buffer = sim_param_buffer;
app.frame_counter = 0;
}
pub fn deinit(_: *App, _: *mach.Engine) void {}
pub fn update(app: *App, engine: *mach.Engine) !bool {
const back_buffer_view = engine.gpu_driver.swap_chain.?.getCurrentTextureView();
const color_attachment = gpu.RenderPassColorAttachment{
.view = back_buffer_view,
.resolve_target = null,
.clear_value = std.mem.zeroes(gpu.Color),
.load_op = .clear,
.store_op = .store,
};
const render_pass_descriptor = gpu.RenderPassEncoder.Descriptor{ .color_attachments = &[_]gpu.RenderPassColorAttachment{
color_attachment,
} };
sim_params[0] = @floatCast(f32, engine.delta_time);
engine.gpu_driver.device.getQueue().writeBuffer(app.sim_param_buffer, 0, f32, &sim_params);
const command_encoder = engine.gpu_driver.device.createCommandEncoder(null);
{
const pass_encoder = command_encoder.beginComputePass(null);
pass_encoder.setPipeline(app.compute_pipeline);
pass_encoder.setBindGroup(0, app.particle_bind_groups[app.frame_counter % 2], null);
pass_encoder.dispatch(@floatToInt(u32, @ceil(@as(f32, num_particle) / 64)), 1, 1);
pass_encoder.end();
pass_encoder.release();
}
{
const pass_encoder = command_encoder.beginRenderPass(&render_pass_descriptor);
pass_encoder.setPipeline(app.render_pipeline);
pass_encoder.setVertexBuffer(0, app.particle_buffers[(app.frame_counter + 1) % 2], 0, num_particle * 4 * @sizeOf(f32));
pass_encoder.setVertexBuffer(1, app.sprite_vertex_buffer, 0, 6 * @sizeOf(f32));
pass_encoder.draw(3, num_particle, 0, 0);
pass_encoder.end();
pass_encoder.release();
}
app.frame_counter += 1;
if (app.frame_counter % 60 == 0) {
std.debug.print("Frame {}\n", .{app.frame_counter});
}
var command = command_encoder.finish(null);
command_encoder.release();
engine.gpu_driver.device.getQueue().submit(&.{command});
command.release();
engine.gpu_driver.swap_chain.?.present();
back_buffer_view.release();
return true;
} | examples/boids/main.zig |
const builtin = @import("builtin");
const arm_m = @import("arm_m");
const tzmcfi_monitor = @import("tzmcfi-monitor");
const port = @import("ports/" ++ @import("build_options").BOARD ++ "/secure.zig");
// ----------------------------------------------------------------------------
const exports = @import("monitor/exports.zig");
// ----------------------------------------------------------------------------
const stringToEnum = @import("std").meta.stringToEnum;
// ----------------------------------------------------------------------------
// Pass build options to `tzmcfi`, which picks them up via `@import("root")`
// See `src/monitor/options.zig`.
pub const TC_ENABLE_PROFILER = @import("build_options").ENABLE_PROFILE;
pub const TC_ABORTING_SHADOWSTACK = @import("build_options").ABORTING_SHADOWSTACK;
pub const TC_SHADOW_EXC_STACK_TYPE = stringToEnum(
tzmcfi_monitor.ShadowExcStackType,
@import("build_options").SHADOW_EXC_STACK_TYPE
).?;
pub const TC_LOG_LEVEL = @import("build_options").LOG_LEVEL;
var cur_warn_handler: ?exports.WarnHandler = null;
// Implements `exports.TCXInitializeMonitor`
export fn TCXInitializeMonitor(warn_handler: exports.WarnHandler) void {
cur_warn_handler = warn_handler;
tzmcfi_monitor.setWarnHandler(monitorWarnHandler);
tzmcfi_monitor.TCInitialize(port.VTOR_NS);
}
fn monitorWarnHandler(_: void, msg: []const u8) error{}!void {
if (cur_warn_handler) |warn_handler| {
warn_handler(@ptrCast([*]const u8, &msg[0]), msg.len);
}
}
/// The global panic handler. (The compiler looks for `pub fn panic` in the root
/// source file. See `zig/std/special/panic.zig`.)
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
@setCold(true);
tzmcfi_monitor.log(.Critical, "panic: {}\r\n", .{msg});
@breakpoint();
unreachable;
}
// `tzmcfi` hooks
// ----------------------------------------------------------------------------
pub fn tcSetShadowStackGuard(stack_start: usize, stack_end: usize) void {
const mpu = arm_m.mpu;
const Mpu = arm_m.Mpu;
mpu.regRnr().* = 0;
// `stack_start - 32 .. stack_start`, overlapping the region 2
mpu.regRbar().* = (stack_start - 32) | Mpu.RBAR_AP_RW_ANY;
mpu.regRlar().* = (stack_start - 32) | Mpu.RLAR_EN;
// `stack_end .. stack_end + 32`, overlapping the region 2
mpu.regRbarA(1).* = stack_end | Mpu.RBAR_AP_RW_ANY;
mpu.regRlarA(1).* = stack_end | Mpu.RLAR_EN;
}
pub fn tcResetShadowStackGuard() void {
@panic("tcResetShadowStackGuard: not implemented");
} | examples/monitor.zig |
usingnamespace @import("common.zig");
pub const cpu_mesh: CpuMesh = .{
.index_size = @sizeOf(@TypeOf(indices)),
.geom_size =
@sizeOf(@TypeOf(positions)) +
@sizeOf(@TypeOf(colors)) +
@sizeOf(@TypeOf(normals)),
.index_count = indices.len,
.vertex_count = positions.len,
.indices = &indices,
.positions = &positions,
.colors = &colors,
.normals = &normals,
};
// -------------- Data only below this point ------------------
const indices = [_]u16{
0, 1, 2, 2, 1, 3, // Front
4, 5, 6, 6, 5, 7, // Back
8, 9, 10, 10, 9, 11, // Right
12, 13, 14, 14, 13, 15, // Left
16, 17, 18, 18, 17, 19, // Top
20, 21, 22, 22, 21, 23, // Bottom
};
const positions = [_]Float3{
// front
.{-1, -1, -1}, // point blue
.{ 1, -1, -1}, // point magenta
.{-1, 1, -1}, // point cyan
.{ 1, 1, -1}, // point white
// back
.{ 1, -1, 1}, // point red
.{-1, -1, 1}, // point black
.{ 1, 1, 1}, // point yellow
.{-1, 1, 1}, // point green
// right
.{ 1, -1, -1}, // point magenta
.{ 1, -1, 1}, // point red
.{ 1, 1, -1}, // point white
.{ 1, 1, 1}, // point yellow
// left
.{-1, -1, 1}, // point black
.{-1, -1, -1}, // point blue
.{-1, 1, 1}, // point green
.{-1, 1, -1}, // point cyan
// top
.{-1, 1, -1}, // point cyan
.{ 1, 1, -1}, // point white
.{-1, 1, 1}, // point green
.{ 1, 1, 1}, // point yellow
// bottom
.{-1, -1, 1}, // point black
.{ 1, -1, 1}, // point red
.{-1, -1, -1}, // point blue
.{ 1, -1, -1} // point magenta
};
const colors = [_]Float3{
// front
.{0, 0, 1}, // blue
.{1, 0, 1}, // magenta
.{0, 1, 1}, // cyan
.{1, 1, 1}, // white
// back
.{1, 0, 0}, // red
.{0, 0, 0}, // black
.{1, 1, 0}, // yellow
.{0, 1, 0}, // green
// right
.{1, 0, 1}, // magenta
.{1, 0, 0}, // red
.{1, 1, 1}, // white
.{1, 1, 0}, // yellow
// left
.{0, 0, 0}, // black
.{0, 0, 1}, // blue
.{0, 1, 0}, // green
.{0, 1, 1}, // cyan
// top
.{0, 1, 1}, // cyan
.{1, 1, 1}, // white
.{0, 1, 0}, // green
.{1, 1, 0}, // yellow
// bottom
.{0, 0, 0}, // black
.{1, 0, 0}, // red
.{0, 0, 1}, // blue
.{1, 0, 1} // magenta
};
const normals = [_]Float3{
// front
.{ 0, 0, 1}, // forward
.{ 0, 0, 1}, // forward
.{ 0, 0, 1}, // forward
.{ 0, 0, 1}, // forward
// back
.{ 0, 0, -1}, // backbard
.{ 0, 0, -1}, // backbard
.{ 0, 0, -1}, // backbard
.{ 0, 0, -1}, // backbard
// right
.{ 1, 0, 0}, // right
.{ 1, 0, 0}, // right
.{ 1, 0, 0}, // right
.{ 1, 0, 0}, // right
// left
.{-1, 0, 0}, // left
.{-1, 0, 0}, // left
.{-1, 0, 0}, // left
.{-1, 0, 0}, // left
// top
.{ 0, 1, 0}, // up
.{ 0, 1, 0}, // up
.{ 0, 1, 0}, // up
.{ 0, 1, 0}, // up
// bottom
.{ 0, -1, 0}, // down
.{ 0, -1, 0}, // down
.{ 0, -1, 0}, // down
.{ 0, -1, 0} // down
}; | src/cube.zig |
const rom = @import("../rom.zig");
const script = @import("../script.zig");
const std = @import("std");
const builtin = std.builtin;
const mem = std.mem;
const li32 = rom.int.li32;
const lu16 = rom.int.lu16;
const lu32 = rom.int.lu32;
pub fn getScriptOffsets(data: []const u8) []const li32 {
var len: usize = 0;
while (true) : (len += 1) {
const rest = data[len * 4 ..];
if (rest.len < 4 or (rest[0] == 0x13 and rest[1] == 0xfd))
break;
}
return mem.bytesAsSlice(li32, data[0 .. len * 4]);
}
pub const CommandDecoder = script.CommandDecoder(Command, struct {
fn isEnd(cmd: Command) bool {
switch (cmd.tag) {
.end,
.jump,
.end_function,
=> return true,
else => return false,
}
}
}.isEnd);
pub fn expectNext(decoder: *CommandDecoder, tag: Command.Kind) ?*Command {
const command = (decoder.next() catch return null) orelse return null;
if (command.tag != tag)
return null;
return command;
}
// https://pastebin.com/QPrYmFwY
pub const Command = packed struct {
tag: Kind,
_data: Data,
/// HACK: Zig crashes when trying to access `_data` during code generation. This
/// seem to happen because &cmd.data gives a bit aligned pointer, which then
/// does not get properly handled in codegen. This function works around this
/// by manually skipping the tag field to get the data field.
pub fn data(cmd: *Command) *Data {
const bytes = mem.asBytes(cmd);
return mem.bytesAsValue(Data, bytes[@sizeOf(Kind)..][0..@sizeOf(Data)]);
}
pub fn toZigUnion(cmd: *Command) Union {
inline for (@typeInfo(Kind).Enum.fields) |field| {
if (cmd.tag == @field(Kind, field.name))
return @unionInit(Union, field.name, &@field(cmd.data(), field.name));
}
unreachable;
}
const Union = blk: {
const info = @typeInfo(Data).Union;
var fields: [info.fields.len]builtin.TypeInfo.UnionField = undefined;
for (info.fields) |field, i| {
fields[i] = .{
.name = field.name,
.field_type = *field.field_type,
.alignment = @alignOf(*anyopaque),
};
}
break :blk @Type(builtin.TypeInfo{ .Union = .{
.layout = .Auto,
.tag_type = Kind,
.fields = &fields,
.decls = &.{},
} });
};
const Data = packed union {
nop1: void,
nop2: void,
end: void,
return_after_delay: Arg1(lu16),
call_routine: CallRoutine,
end_function: Arg1(lu16),
logic06: Arg1(lu16),
logic07: Arg1(lu16),
compare_to: CompareTo,
store_var: StoreVar,
clear_var: ClearVar,
unknown_0b: Unknown_0B,
unknown_0c: Unknown_0C,
unknown_0d: Unknown_0D,
unknown_0e: Unknown_0E,
unknown_0f: Unknown_0F,
store_flag: StoreFlag,
condition: Condition,
unknown_12: Unknown_12,
unknown_13: Unknown_13,
unknown_14: Unknown_14,
unknown_16: Unknown_16,
unknown_17: Unknown_17,
compare: Compare,
call_std: CallStd,
return_std: void,
jump: Jump,
@"if": If,
unknown_21: Unknown_21,
unknown_22: Unknown_22,
set_flag: SetFlag,
clear_flag: ClearFlag,
set_var_flag_status: SetVarFlagStatus,
set_var_26: SetVar26,
set_var_27: SetVar27,
set_var_eq_val: SetVarEqVal,
set_var_29: SetVar29,
set_var_2a: SetVar2A,
set_var_2b: SetVar2B,
dir_vars: Arg2(lu16, lu16),
unknown_2d: Unknown_2D,
lock_all: void,
unlock_all: void,
wait_moment: void,
wait_button: void,
musical_message: MusicalMessage,
event_grey_message: EventGreyMessage,
close_musical_message: void,
closed_event_grey_message: void,
bubble_message: BubbleMessage,
close_bubble_message: void,
show_message_at: ShowMessageAt,
close_show_message_at: void,
message: Message,
message2: Message2,
close_message_k_p: void,
close_message_k_p2: void,
money_box: MoneyBox,
close_money_box: void,
update_money_box: void,
bordered_message: BorderedMessage,
close_bordered_message: void,
paper_message: PaperMessage,
close_paper_message: void,
yes_no: YesNo,
message3: Message3,
double_message: DoubleMessage,
angry_message: AngryMessage,
close_angry_message: void,
set_var_hero: SetVarHero,
set_var_item: SetVarItem,
unknown_4e: unknown_4E,
set_var_item2: SetVarItem2,
set_var_item3: SetVarItem3,
set_var_move: SetVarMove,
set_var_bag: SetVarBag,
set_var_party_poke: SetVarPartyPoke,
set_var_party_poke2: SetVarPartyPoke2,
set_var_unknown: SetVar_Unknown,
set_var_type: SetVarType,
set_var_poke: SetVarPoke,
set_var_poke2: SetVarPoke2,
set_var_location: SetVarLocation,
set_var_poke_nick: SetVarPokeNick,
set_var_unknown2: SetVar_Unknown2,
set_var_store_value5_c: SetVarStoreValue5C,
set_var_musical_info: SetVarMusicalInfo,
set_var_nations: SetVarNations,
set_var_activities: SetVarActivities,
set_var_power: SetVarPower,
set_var_trainer_type: SetVarTrainerType,
set_var_trainer_type2: SetVarTrainerType2,
set_var_general_word: SetVarGeneralWord,
apply_movement: ApplyMovement,
wait_movement: void,
store_hero_position: StoreHeroPosition,
unknown_67: Unknown_67,
store_hero_position2: StoreHeroPosition2,
store_npc_position: StoreNPCPosition,
unknown_6a: Unknown_6A,
add_npc: AddNPC,
remove_npc: RemoveNPC,
set_o_w_position: SetOWPosition,
unknown_6e: Arg1(lu16),
unknown_6f: Arg1(lu16),
unknown_70: Unknown_70,
unknown_71: Unknown_71,
unknown_72: Unknown_72,
unknown_73: Unknown_73,
face_player: void,
release: Release,
release_all: void,
lock_77: Lock,
unknown_78: Unknown_78,
unknown_79: Unknown_79,
move_npc_to: MoveNPCTo,
unknown_7c: Unknown_7C,
unknown_7d: Unknown_7D,
teleport_up_npc: TeleportUpNPC,
unknown_7f: Unknown_7F,
unknown_80: Arg1(lu16),
unknown_81: void,
unknown_82: Unknown_82,
set_var83: SetVar83,
set_var84: SetVar84,
single_trainer_battle: SingleTrainerBattle,
double_trainer_battle: DoubleTrainerBattle,
unknown_87: Unknown_87,
unknown_88: Unknown_88,
unknown_8a: Unknown_8A,
play_trainer_music: PlayTrainerMusic,
end_battle: void,
store_battle_result: StoreBattleResult,
unknown_179: void,
unknown_17a: void,
unknown_17b: Arg1(lu16),
unknown_17c: Arg1(lu16),
set_status_cg: Arg1(lu16),
show_cg: Arg1(lu16),
call_screen_animation: Arg1(lu16),
disable_trainer: void,
d_var90: DVar90,
d_var92: DVar92,
d_var93: DVar93,
trainer_battle: TrainerBattle,
deactivate_trainer_i_d: DeactivateTrainerID,
unknown_96: Unknown_96,
store_active_trainer_i_d: StoreActiveTrainerID,
change_music: ChangeMusic,
fade_to_default_music: void,
unknown_9f: void,
unknown_a2: Unknown_A2,
unknown_a3: Arg1(lu16),
unknown_a4: Arg1(lu16),
unknown_a5: Unknown_A5,
play_sound: PlaySound,
wait_sound_a7: void,
wait_sound: void,
play_fanfare: PlayFanfare,
wait_fanfare: void,
play_cry: PlayCry,
wait_cry: void,
set_text_script_message: SetTextScriptMessage,
close_multi: void,
unknown_b1: void,
multi2: Multi2,
fade_screen: FadeScreen,
reset_screen: ResetScreen,
screen_b5: Screen_B5,
take_item: TakeItem,
check_item_bag_space: CheckItemBagSpace,
check_item_bag_number: CheckItemBagNumber,
store_item_count: StoreItemCount,
unknown_ba: Unknown_BA,
unknown_bb: Unknown_BB,
unknown_bc: Arg1(lu16),
warp: Warp,
teleport_warp: TeleportWarp,
fall_warp: FallWarp,
fast_warp: FastWarp,
union_warp: void,
teleport_warp2: TeleportWarp2,
surf_animation: void,
special_animation: Arg1(lu16),
special_animation2: SpecialAnimation2,
call_animation: CallAnimation,
store_random_number: StoreRandomNumber,
store_var_item: Arg1(lu16),
store_var_cd: Arg1(lu16),
store_var_ce: Arg1(lu16),
store_var_cf: Arg1(lu16),
store_date: StoreDate,
store_d1: Store_D1,
store_d2: Arg1(lu16),
store_d3: Arg1(lu16),
store_birth_day: StoreBirthDay,
store_badge: StoreBadge,
set_badge: SetBadge,
store_badge_number: StoreBadgeNumber,
store_version: Arg1(lu16),
store_gender: Arg1(lu16),
activate_key_item: Arg1(lu16),
unknown_f9: Arg1(lu16),
take_money: TakeMoney,
check_money: CheckMoney,
store_party_species: Arg2(lu16, lu16),
store_pokemon_form_number: Arg2(lu16, lu16),
store_party_number_minimum: StorePartyNumberMinimum,
give_pokemon_1: GivePokemon1,
give_pokemon_2: GivePokemon2,
give_pokemon_3: GivePokemon3,
badge_animation: Arg1(lu16),
unknown_125: Arg4(lu16, lu16, lu16, lu16),
unknown_127: Arg4(lu16, lu16, lu16, lu16),
unknown_128: Arg1(lu16),
unknown_129: Arg2(lu16, lu16),
unknown_12A: Arg1(lu16),
unknown_12D: Arg4(lu16, lu16, lu16, lu16),
unknown_134: void,
unknown_13F: void,
stop_camera_event: void,
lock_camera: void,
move_camera: MoveCamera,
unknown_144: Arg1(lu16),
end_camera_event: void,
start_pokemon_musical: Arg2(u8, lu16),
check_pokemon_musical_functions: Arg3(u8, lu16, lu16),
pokemon_menu_musical_functions: Arg4(lu16, lu16, lu16, lu16),
choose_pokemon_musical: Arg2(lu16, lu16),
unknown_182: Arg1(lu16),
unknown_186: Arg1(lu16),
unknown_187: Arg1(lu16),
unknown_188: Arg1(lu16),
unknown_189: Arg1(lu16),
unknown_1D8: Arg2(lu16, lu16),
unknown_1C2: Arg2(lu16, lu16),
end_event_bc: void,
store_trainer_id: Arg2(lu16, lu16),
unknown_1C7: void,
store_var_message: Arg2(lu16, lu16),
boot_p_c_sound: void,
unknown_136: Arg1(lu16),
check_wireless: Arg1(lu16),
release_camera: void,
reset_camera: ResetCamera,
call_end: void,
call_start: void,
liberty_ship_anm: Arg2(lu16, lu16),
open_interpoke: Arg2(lu16, lu16),
wild_battle: WildBattle,
wild_battle_store_result: WildBattleStoreResult,
screen_function: void,
fade_from_black: void,
fade_into_black: void,
fade_from_white: void,
fade_into_white: void,
unknown_1b5: void,
unknown_1b7: Arg1(lu16),
unknown_1b8: Arg1(lu16),
unknown_1EA: Arg4(lu16, lu16, lu16, lu16),
switch_ow_position: SwitchOwPosition,
dream_world_function: Arg4(lu16, lu16, lu16, lu16),
dream_world_function2: Arg4(lu16, lu16, lu16, lu16),
show_dream_world_furniture: Arg2(lu16, lu16),
check_item_interesting_bag: Arg2(lu16, lu16),
unknown_229: Arg2(lu16, lu16),
check_send_save_cg: Arg2(lu16, lu16),
unknown_246: Arg1(lu16),
unknown_24c: Arg1(lu16),
lock_24f: void,
give_pokemon_4: GivePokemon4,
};
pub const Kind = enum(u16) {
nop1 = lu16.init(0x00).value(),
nop2 = lu16.init(0x01).value(),
end = lu16.init(0x02).value(),
return_after_delay = lu16.init(0x03).value(),
call_routine = lu16.init(0x04).value(),
end_function = lu16.init(0x05).value(),
logic06 = lu16.init(0x06).value(),
logic07 = lu16.init(0x07).value(),
compare_to = lu16.init(0x08).value(),
store_var = lu16.init(0x09).value(),
clear_var = lu16.init(0x0A).value(),
unknown_0b = lu16.init(0x0B).value(),
unknown_0c = lu16.init(0x0C).value(),
unknown_0d = lu16.init(0x0D).value(),
unknown_0e = lu16.init(0x0E).value(),
unknown_0f = lu16.init(0x0F).value(),
store_flag = lu16.init(0x10).value(),
condition = lu16.init(0x11).value(),
unknown_12 = lu16.init(0x12).value(),
unknown_13 = lu16.init(0x13).value(),
unknown_14 = lu16.init(0x14).value(),
unknown_16 = lu16.init(0x16).value(),
unknown_17 = lu16.init(0x17).value(),
compare = lu16.init(0x19).value(),
call_std = lu16.init(0x1C).value(),
return_std = lu16.init(0x1D).value(),
jump = lu16.init(0x1E).value(),
@"if" = lu16.init(0x1F).value(),
unknown_21 = lu16.init(0x21).value(),
unknown_22 = lu16.init(0x22).value(),
set_flag = lu16.init(0x23).value(),
clear_flag = lu16.init(0x24).value(),
set_var_flag_status = lu16.init(0x25).value(),
set_var_26 = lu16.init(0x26).value(),
set_var_27 = lu16.init(0x27).value(),
set_var_eq_val = lu16.init(0x28).value(),
set_var_29 = lu16.init(0x29).value(),
set_var_2a = lu16.init(0x2A).value(),
set_var_2b = lu16.init(0x2B).value(),
dir_vars = lu16.init(0x2C).value(),
unknown_2d = lu16.init(0x2D).value(),
lock_all = lu16.init(0x2E).value(),
unlock_all = lu16.init(0x2F).value(),
wait_moment = lu16.init(0x30).value(),
wait_button = lu16.init(0x32).value(),
musical_message = lu16.init(0x33).value(),
event_grey_message = lu16.init(0x34).value(),
close_musical_message = lu16.init(0x35).value(),
closed_event_grey_message = lu16.init(0x36).value(),
bubble_message = lu16.init(0x38).value(),
close_bubble_message = lu16.init(0x39).value(),
show_message_at = lu16.init(0x3A).value(),
close_show_message_at = lu16.init(0x3B).value(),
message = lu16.init(0x3C).value(),
message2 = lu16.init(0x3D).value(),
close_message_k_p = lu16.init(0x3E).value(),
close_message_k_p2 = lu16.init(0x3F).value(),
money_box = lu16.init(0x40).value(),
close_money_box = lu16.init(0x41).value(),
update_money_box = lu16.init(0x42).value(),
bordered_message = lu16.init(0x43).value(),
close_bordered_message = lu16.init(0x44).value(),
paper_message = lu16.init(0x45).value(),
close_paper_message = lu16.init(0x46).value(),
yes_no = lu16.init(0x47).value(),
message3 = lu16.init(0x48).value(),
double_message = lu16.init(0x49).value(),
angry_message = lu16.init(0x4A).value(),
close_angry_message = lu16.init(0x4B).value(),
set_var_hero = lu16.init(0x4C).value(),
set_var_item = lu16.init(0x4D).value(),
unknown_4e = lu16.init(0x4E).value(),
set_var_item2 = lu16.init(0x4F).value(),
set_var_item3 = lu16.init(0x50).value(),
set_var_move = lu16.init(0x51).value(),
set_var_bag = lu16.init(0x52).value(),
set_var_party_poke = lu16.init(0x53).value(),
set_var_party_poke2 = lu16.init(0x54).value(),
set_var_unknown = lu16.init(0x55).value(),
set_var_type = lu16.init(0x56).value(),
set_var_poke = lu16.init(0x57).value(),
set_var_poke2 = lu16.init(0x58).value(),
set_var_location = lu16.init(0x59).value(),
set_var_poke_nick = lu16.init(0x5A).value(),
set_var_unknown2 = lu16.init(0x5B).value(),
set_var_store_value5_c = lu16.init(0x5C).value(),
set_var_musical_info = lu16.init(0x5D).value(),
set_var_nations = lu16.init(0x5E).value(),
set_var_activities = lu16.init(0x5F).value(),
set_var_power = lu16.init(0x60).value(),
set_var_trainer_type = lu16.init(0x61).value(),
set_var_trainer_type2 = lu16.init(0x62).value(),
set_var_general_word = lu16.init(0x63).value(),
apply_movement = lu16.init(0x64).value(),
wait_movement = lu16.init(0x65).value(),
store_hero_position = lu16.init(0x66).value(),
unknown_67 = lu16.init(0x67).value(),
store_hero_position2 = lu16.init(0x68).value(),
store_npc_position = lu16.init(0x69).value(),
unknown_6a = lu16.init(0x6A).value(),
add_npc = lu16.init(0x6B).value(),
remove_npc = lu16.init(0x6C).value(),
set_o_w_position = lu16.init(0x6D).value(),
unknown_6e = lu16.init(0x6E).value(),
unknown_6f = lu16.init(0x6F).value(),
unknown_70 = lu16.init(0x70).value(),
unknown_71 = lu16.init(0x71).value(),
unknown_72 = lu16.init(0x72).value(),
unknown_73 = lu16.init(0x73).value(),
face_player = lu16.init(0x74).value(),
release = lu16.init(0x75).value(),
release_all = lu16.init(0x76).value(),
lock_77 = lu16.init(0x77).value(),
unknown_78 = lu16.init(0x78).value(),
unknown_79 = lu16.init(0x79).value(),
move_npc_to = lu16.init(0x7B).value(),
unknown_7c = lu16.init(0x7C).value(),
unknown_7d = lu16.init(0x7D).value(),
teleport_up_npc = lu16.init(0x7E).value(),
unknown_7f = lu16.init(0x7F).value(),
unknown_80 = lu16.init(0x80).value(),
unknown_81 = lu16.init(0x81).value(),
unknown_82 = lu16.init(0x82).value(),
set_var83 = lu16.init(0x83).value(),
set_var84 = lu16.init(0x84).value(),
single_trainer_battle = lu16.init(0x85).value(),
double_trainer_battle = lu16.init(0x86).value(),
unknown_87 = lu16.init(0x87).value(),
unknown_88 = lu16.init(0x88).value(),
unknown_8a = lu16.init(0x8A).value(),
play_trainer_music = lu16.init(0x8B).value(),
end_battle = lu16.init(0x8C).value(),
store_battle_result = lu16.init(0x8D).value(),
disable_trainer = lu16.init(0x8E).value(),
d_var90 = lu16.init(0x90).value(),
d_var92 = lu16.init(0x92).value(),
d_var93 = lu16.init(0x93).value(),
trainer_battle = lu16.init(0x94).value(),
deactivate_trainer_i_d = lu16.init(0x95).value(),
unknown_96 = lu16.init(0x96).value(),
store_active_trainer_i_d = lu16.init(0x97).value(),
change_music = lu16.init(0x98).value(),
fade_to_default_music = lu16.init(0x9E).value(),
unknown_9f = lu16.init(0x9F).value(),
unknown_a2 = lu16.init(0xA2).value(),
unknown_a3 = lu16.init(0xA3).value(),
unknown_a4 = lu16.init(0xA4).value(),
unknown_a5 = lu16.init(0xA5).value(),
play_sound = lu16.init(0xA6).value(),
wait_sound_a7 = lu16.init(0xA7).value(),
wait_sound = lu16.init(0xA8).value(),
play_fanfare = lu16.init(0xA9).value(),
wait_fanfare = lu16.init(0xAA).value(),
play_cry = lu16.init(0xAB).value(),
wait_cry = lu16.init(0xAC).value(),
set_text_script_message = lu16.init(0xAF).value(),
close_multi = lu16.init(0xB0).value(),
unknown_b1 = lu16.init(0xB1).value(),
multi2 = lu16.init(0xB2).value(),
fade_screen = lu16.init(0xB3).value(),
reset_screen = lu16.init(0xB4).value(),
screen_b5 = lu16.init(0xB5).value(),
take_item = lu16.init(0xB6).value(),
check_item_bag_space = lu16.init(0xB7).value(),
check_item_bag_number = lu16.init(0xB8).value(),
store_item_count = lu16.init(0xB9).value(),
unknown_ba = lu16.init(0xBA).value(),
unknown_bb = lu16.init(0xBB).value(),
unknown_bc = lu16.init(0xBC).value(),
warp = lu16.init(0xBE).value(),
teleport_warp = lu16.init(0xBF).value(),
fall_warp = lu16.init(0xC1).value(),
fast_warp = lu16.init(0xC2).value(),
union_warp = lu16.init(0xC3).value(),
teleport_warp2 = lu16.init(0xC4).value(),
surf_animation = lu16.init(0xC5).value(),
special_animation = lu16.init(0xC6).value(),
special_animation2 = lu16.init(0xC7).value(),
call_animation = lu16.init(0xC8).value(),
store_random_number = lu16.init(0xCB).value(),
store_var_item = lu16.init(0xCC).value(),
store_var_cd = lu16.init(0xCD).value(),
store_var_ce = lu16.init(0xCE).value(),
store_var_cf = lu16.init(0xCF).value(),
store_date = lu16.init(0xD0).value(),
store_d1 = lu16.init(0xD1).value(),
store_d2 = lu16.init(0xD2).value(),
store_d3 = lu16.init(0xD3).value(),
store_birth_day = lu16.init(0xD4).value(),
store_badge = lu16.init(0xD5).value(),
set_badge = lu16.init(0xD6).value(),
store_badge_number = lu16.init(0xD7).value(),
store_version = lu16.init(0xE0).value(),
store_gender = lu16.init(0xE1).value(),
activate_key_item = lu16.init(0xE7).value(),
unknown_f9 = lu16.init(0xF9).value(),
take_money = lu16.init(0xFA).value(),
check_money = lu16.init(0xFB).value(),
store_party_species = lu16.init(0xFE).value(),
store_pokemon_form_number = lu16.init(0xFF).value(),
store_party_number_minimum = lu16.init(0x103).value(),
give_pokemon_1 = lu16.init(0x10C).value(),
give_pokemon_2 = lu16.init(0x10E).value(),
give_pokemon_3 = lu16.init(0x10F).value(),
badge_animation = lu16.init(0x11E).value(),
unknown_125 = lu16.init(0x125).value(),
unknown_127 = lu16.init(0x127).value(),
unknown_128 = lu16.init(0x128).value(),
unknown_129 = lu16.init(0x129).value(),
unknown_12A = lu16.init(0x12A).value(),
unknown_12D = lu16.init(0x12D).value(),
unknown_134 = lu16.init(0x134).value(),
unknown_13F = lu16.init(0x13F).value(),
stop_camera_event = lu16.init(0x140).value(),
lock_camera = lu16.init(0x141).value(),
move_camera = lu16.init(0x143).value(),
unknown_144 = lu16.init(0x144).value(),
end_camera_event = lu16.init(0x145).value(),
start_pokemon_musical = lu16.init(0x167).value(),
check_pokemon_musical_functions = lu16.init(0x169).value(),
pokemon_menu_musical_functions = lu16.init(0x16B).value(),
choose_pokemon_musical = lu16.init(0x16E).value(),
unknown_182 = lu16.init(0x182).value(),
unknown_186 = lu16.init(0x186).value(),
unknown_187 = lu16.init(0x187).value(),
unknown_188 = lu16.init(0x188).value(),
unknown_189 = lu16.init(0x189).value(),
unknown_1D8 = lu16.init(0x1D8).value(),
unknown_1C2 = lu16.init(0x1C2).value(),
end_event_bc = lu16.init(0x1C3).value(),
store_trainer_id = lu16.init(0x1C4).value(),
unknown_1C7 = lu16.init(0x1C7).value(),
store_var_message = lu16.init(0x1C9).value(),
boot_p_c_sound = lu16.init(0x130).value(),
unknown_136 = lu16.init(0x136).value(),
check_wireless = lu16.init(0x13B).value(),
release_camera = lu16.init(0x142).value(),
reset_camera = lu16.init(0x147).value(),
call_end = lu16.init(0x14A).value(),
call_start = lu16.init(0x14B).value(),
liberty_ship_anm = lu16.init(0x154).value(),
open_interpoke = lu16.init(0x155).value(),
wild_battle = lu16.init(0x174).value(),
wild_battle_store_result = lu16.init(0x178).value(),
unknown_179 = lu16.init(0x179).value(),
unknown_17a = lu16.init(0x17a).value(),
unknown_17b = lu16.init(0x17b).value(),
unknown_17c = lu16.init(0x17c).value(),
set_status_cg = lu16.init(0x19B).value(),
show_cg = lu16.init(0x19E).value(),
call_screen_animation = lu16.init(0x19F).value(),
screen_function = lu16.init(0x1B1).value(),
fade_from_black = lu16.init(0x1AB).value(),
fade_into_black = lu16.init(0x1AC).value(),
fade_from_white = lu16.init(0x1AD).value(),
fade_into_white = lu16.init(0x1AE).value(),
unknown_1b5 = lu16.init(0x1b5).value(),
unknown_1b7 = lu16.init(0x1b7).value(),
unknown_1b8 = lu16.init(0x1b8).value(),
unknown_1EA = lu16.init(0x1EA).value(),
switch_ow_position = lu16.init(0x1EC).value(),
dream_world_function = lu16.init(0x209).value(),
dream_world_function2 = lu16.init(0x20A).value(),
show_dream_world_furniture = lu16.init(0x20B).value(),
check_item_interesting_bag = lu16.init(0x20E).value(),
unknown_229 = lu16.init(0x229).value(),
check_send_save_cg = lu16.init(0x23B).value(),
unknown_246 = lu16.init(0x246).value(),
unknown_24c = lu16.init(0x24c).value(),
lock_24f = lu16.init(0x24f).value(),
give_pokemon_4 = lu16.init(0x2ea).value(),
};
pub fn Arg1(comptime T: type) type {
return packed struct { arg: T };
}
pub fn Arg2(comptime T1: type, comptime T2: type) type {
return packed struct { arg1: T1, args2: T2 };
}
pub fn Arg3(comptime T1: type, comptime T2: type, comptime T3: type) type {
return packed struct { arg1: T1, args2: T2, args3: T3 };
}
pub fn Arg4(comptime T1: type, comptime T2: type, comptime T3: type, comptime T4: type) type {
return packed struct { arg1: T1, args2: T2, args3: T3, args4: T4 };
}
pub const CallRoutine = packed struct {
offset: li32,
};
pub const CompareTo = packed struct {
value: lu16,
};
pub const StoreVar = packed struct {
@"var": lu16,
};
pub const ClearVar = packed struct {
@"var": lu16,
};
pub const Unknown_0B = packed struct {
value: lu16,
};
pub const Unknown_0C = packed struct {
value: lu16,
};
pub const Unknown_0D = packed struct {
value: lu16,
};
pub const Unknown_0E = packed struct {
value: lu16,
};
pub const Unknown_0F = packed struct {
value: lu16,
};
pub const StoreFlag = packed struct {
value: lu16,
};
pub const Condition = packed struct {
condition: lu16,
};
pub const Unknown_12 = packed struct {
value: lu16,
};
pub const Unknown_13 = packed struct {
value1: lu16,
value2: lu16,
};
pub const Unknown_14 = packed struct {
value: lu16,
};
pub const Unknown_16 = packed struct {
value: lu16,
};
pub const Unknown_17 = packed struct {
value: lu16,
};
pub const Compare = packed struct {
value1: lu16,
value2: lu16,
};
pub const CallStd = packed struct {
function: lu16,
};
pub const Jump = packed struct {
offset: li32,
};
pub const If = packed struct {
value: u8,
offset: li32,
};
pub const Unknown_21 = packed struct {
value: lu16,
};
pub const Unknown_22 = packed struct {
value: lu16,
};
pub const SetFlag = packed struct {
value: lu16,
};
pub const ClearFlag = packed struct {
flag: lu16,
};
pub const SetVarFlagStatus = packed struct {
flag: lu16,
status: lu16,
};
pub const SetVar26 = packed struct {
value1: lu16,
value2: lu16,
};
pub const SetVar27 = packed struct {
value1: lu16,
value2: lu16,
};
pub const SetVarEqVal = packed struct {
container: lu16,
value: lu16,
};
pub const SetVar29 = packed struct {
container: lu16,
value: lu16,
};
pub const SetVar2A = packed struct {
container: lu16,
value: lu16,
};
pub const SetVar2B = packed struct {
value: lu16,
};
pub const Unknown_2D = packed struct {
value: lu16,
};
pub const MusicalMessage = packed struct {
id: lu16,
};
pub const EventGreyMessage = packed struct {
id: lu16,
view: lu16,
};
pub const BubbleMessage = packed struct {
id: lu16,
location: u8,
};
pub const ShowMessageAt = packed struct {
id: lu16,
xcoord: lu16,
ycoord: lu16,
zcoord: lu16,
};
pub const Message = packed struct {
id: lu16,
npc: lu16,
position: lu16,
type: lu16,
};
pub const Message2 = packed struct {
id: lu16,
npc: lu16,
position: lu16,
type: lu16,
};
pub const MoneyBox = packed struct {
xcoord: lu16,
ycoord: lu16,
};
pub const BorderedMessage = packed struct {
id: lu16,
color: lu16,
};
pub const PaperMessage = packed struct {
id: lu16,
transcoord: lu16,
};
pub const YesNo = packed struct {
yesno: lu16,
};
pub const Message3 = packed struct {
id: lu16,
npc: lu16,
position: lu16,
type: lu16,
unknown: lu16,
};
pub const DoubleMessage = packed struct {
idblack: lu16,
idwhite: lu16,
npc: lu16,
position: lu16,
type: lu16,
};
pub const AngryMessage = packed struct {
id: lu16,
unknownbyte: u8,
position: lu16,
};
pub const SetVarHero = packed struct {
arg: u8,
};
pub const SetVarItem = packed struct {
arg: u8,
item: lu16,
};
pub const unknown_4E = packed struct {
arg1: u8,
arg2: lu16,
arg3: lu16,
arg4: u8,
};
pub const SetVarItem2 = packed struct {
arg: u8,
item: lu16,
};
pub const SetVarItem3 = packed struct {
arg: u8,
item: lu16,
};
pub const SetVarMove = packed struct {
arg: u8,
move: lu16,
};
pub const SetVarBag = packed struct {
arg: u8,
item: lu16,
};
pub const SetVarPartyPoke = packed struct {
arg: u8,
party_poke: lu16,
};
pub const SetVarPartyPoke2 = packed struct {
arg: u8,
party_poke: lu16,
};
pub const SetVar_Unknown = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarType = packed struct {
arg: u8,
type: lu16,
};
pub const SetVarPoke = packed struct {
arg: u8,
poke: lu16,
};
pub const SetVarPoke2 = packed struct {
arg: u8,
poke: lu16,
};
pub const SetVarLocation = packed struct {
arg: u8,
location: lu16,
};
pub const SetVarPokeNick = packed struct {
arg: u8,
poke: lu16,
};
pub const SetVar_Unknown2 = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarStoreValue5C = packed struct {
arg: u8,
container: lu16,
stat: lu16,
};
pub const SetVarMusicalInfo = packed struct {
arg: lu16,
value: lu16,
};
pub const SetVarNations = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarActivities = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarPower = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarTrainerType = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarTrainerType2 = packed struct {
arg: u8,
value: lu16,
};
pub const SetVarGeneralWord = packed struct {
arg: u8,
value: lu16,
};
pub const ApplyMovement = packed struct {
npc: lu16,
movementdata: lu32,
};
pub const StoreHeroPosition = packed struct {
xcoord: lu16,
ycoord: lu16,
};
pub const Unknown_67 = packed struct {
value: lu16,
value2: lu16,
};
pub const StoreHeroPosition2 = packed struct {
xcoord: lu16,
ycoord: lu16,
};
pub const StoreNPCPosition = packed struct {
npc: lu16,
xcoord: lu16,
ycoord: lu16,
};
pub const Unknown_6A = packed struct {
npc: lu16,
flag: lu16,
};
pub const AddNPC = packed struct {
npc: lu16,
};
pub const RemoveNPC = packed struct {
npc: lu16,
};
pub const SetOWPosition = packed struct {
npc: lu16,
xcoord: lu16,
ycoord: lu16,
zcoord: lu16,
direction: lu16,
};
pub const Unknown_70 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
arg5: lu16,
};
pub const Unknown_71 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
};
pub const Unknown_72 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const Unknown_73 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const Release = packed struct {
npc: lu16,
};
pub const Lock = packed struct {
npc: lu16,
};
pub const Unknown_78 = packed struct {
@"var": lu16,
};
pub const Unknown_79 = packed struct {
npc: lu16,
arg2: lu16,
arg3: lu16,
};
pub const MoveNPCTo = packed struct {
npc: lu16,
xcoord: lu16,
ycoord: lu16,
zcoord: lu16,
};
pub const Unknown_7C = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const Unknown_7D = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const TeleportUpNPC = packed struct {
npc: lu16,
};
pub const Unknown_7F = packed struct {
arg: lu16,
arg2: lu16,
};
pub const Unknown_82 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const SetVar83 = packed struct {
value: lu16,
};
pub const SetVar84 = packed struct {
value: lu16,
};
pub const SingleTrainerBattle = packed struct {
trainerid: lu16,
trainerid2: lu16,
logic: lu16,
};
pub const DoubleTrainerBattle = packed struct {
ally: lu16,
trainerid: lu16,
trainerid2: lu16,
logic: lu16,
};
pub const Unknown_87 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
};
pub const Unknown_88 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
};
pub const Unknown_8A = packed struct {
arg: lu16,
arg2: lu16,
};
pub const PlayTrainerMusic = packed struct {
songid: lu16,
};
pub const StoreBattleResult = packed struct {
variable: lu16,
};
pub const DVar90 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const DVar92 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const DVar93 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const TrainerBattle = packed struct {
trainerid: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const DeactivateTrainerID = packed struct {
id: lu16,
};
pub const Unknown_96 = packed struct {
trainerid: lu16,
};
pub const StoreActiveTrainerID = packed struct {
trainerid: lu16,
arg2: lu16,
};
pub const ChangeMusic = packed struct {
songid: lu16,
};
pub const Unknown_A2 = packed struct {
sound: lu16,
arg2: lu16,
};
pub const Unknown_A5 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const PlaySound = packed struct {
id: lu16,
};
pub const PlayFanfare = packed struct {
id: lu16,
};
pub const PlayCry = packed struct {
id: lu16,
arg2: lu16,
};
pub const SetTextScriptMessage = packed struct {
id: lu16,
arg2: lu16,
arg3: lu16,
};
pub const Multi2 = packed struct {
arg: u8,
arg2: u8,
arg3: u8,
arg4: u8,
arg5: u8,
@"var": lu16,
};
pub const FadeScreen = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const ResetScreen = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
};
pub const Screen_B5 = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
};
pub const TakeItem = packed struct {
item: lu16,
quantity: lu16,
result: lu16,
};
pub const CheckItemBagSpace = packed struct {
item: lu16,
quantity: lu16,
result: lu16,
};
pub const CheckItemBagNumber = packed struct {
item: lu16,
quantity: lu16,
result: lu16,
};
pub const StoreItemCount = packed struct {
item: lu16,
result: lu16,
};
pub const Unknown_BA = packed struct {
arg: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
};
pub const Unknown_BB = packed struct {
arg: lu16,
arg2: lu16,
};
pub const Warp = packed struct {
mapid: lu16,
xcoord: lu16,
ycoord: lu16,
};
pub const TeleportWarp = packed struct {
mapid: lu16,
xcoord: lu16,
ycoord: lu16,
zcoord: lu16,
npcfacing: lu16,
};
pub const FallWarp = packed struct {
mapid: lu16,
xcoord: lu16,
ycoord: lu16,
};
pub const FastWarp = packed struct {
mapid: lu16,
xcoord: lu16,
ycoord: lu16,
herofacing: lu16,
};
pub const TeleportWarp2 = packed struct {
mapid: lu16,
xcoord: lu16,
ycoord: lu16,
zcoord: lu16,
herofacing: lu16,
};
pub const SpecialAnimation2 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const CallAnimation = packed struct {
arg: lu16,
arg2: lu16,
};
pub const StoreRandomNumber = packed struct {
arg: lu16,
arg2: lu16,
};
pub const StoreDate = packed struct {
month: lu16,
date: lu16,
};
pub const Store_D1 = packed struct {
arg: lu16,
arg2: lu16,
};
pub const StoreBirthDay = packed struct {
month: lu16,
day: lu16,
};
pub const StoreBadge = packed struct {
@"var": lu16,
badge: lu16,
};
pub const SetBadge = packed struct {
badge: lu16,
};
pub const StoreBadgeNumber = packed struct {
badge: lu16,
};
pub const TakeMoney = packed struct {
amount: lu16,
};
pub const CheckMoney = packed struct {
storage: lu16,
value: lu16,
};
pub const StorePartyNumberMinimum = packed struct {
result: lu16,
number: lu16,
};
pub const GivePokemon1 = packed struct {
result: lu16,
species: lu16,
item: lu16,
level: lu16,
};
pub const GivePokemon2 = packed struct {
result: lu16,
species: lu16,
form: lu16,
level: lu16,
unknown_0: lu16,
unknown_1: lu16,
unknown_2: lu16,
unknown_3: lu16,
unknown_4: lu16,
};
pub const GivePokemon3 = packed struct {
result: lu16,
species: lu16,
is_full: lu16,
};
pub const GivePokemon4 = packed struct {
result: lu16,
species: lu16,
level: lu16,
unknown_0: lu16,
unknown_1: lu16,
unknown_2: lu16,
};
pub const MoveCamera = packed struct {
arg1: lu16,
arg2: lu16,
arg3: lu32,
arg4: lu32,
arg5: lu32,
arg6: lu32,
arg7: lu16,
};
pub const ResetCamera = packed struct {
arg1: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
arg5: lu16,
arg6: lu16,
};
pub const SwitchOwPosition = packed struct {
arg1: lu16,
arg2: lu16,
arg3: lu16,
arg4: lu16,
arg5: lu16,
};
pub const WildBattle = packed struct {
species: lu16,
level: lu16,
};
pub const WildBattleStoreResult = packed struct {
species: lu16,
level: lu16,
variable: lu16,
};
}; | src/core/gen5/script.zig |
const std = @import("std");
const warn = std.debug.warn;
const CanonicalHuffmanTree = @import("./huffman.zig").CanonicalHuffmanTree;
pub fn BlockTree(comptime InputBitStream: type) type {
return struct {
const Self = @This();
pub const TLitTree = CanonicalHuffmanTree(u4, 31 + 257);
pub const TDistTree = CanonicalHuffmanTree(u4, 31 + 1);
lit_tree: TLitTree,
dist_tree: TDistTree,
pub fn makeStatic() Self {
// FIXME: zig fmt seems to ignore these comments --GM
// zig fmt: off
const lit_table = (([_]u4{8} ** (144 - 0)) ++ ([_]u4{9} ** (256 - 144)) ++ ([_]u4{7} ** (280 - 256)) ++ ([_]u4{8} ** (288 - 280)));
// zig fmt: on
const lit_tree = CanonicalHuffmanTree(u4, 31 + 257).fromLengths(&lit_table);
const dist_table = [_]u4{5} ** 32;
const dist_tree = CanonicalHuffmanTree(u4, 31 + 1).fromLengths(&dist_table);
return Self{
.lit_tree = lit_tree,
.dist_tree = dist_tree,
};
}
pub fn fromBitStream(stream: *InputBitStream) !Self {
const raw_hlit: u5 = try stream.readBitsNoEof(u5, 5);
const raw_hdist: u5 = try stream.readBitsNoEof(u5, 5);
const raw_hclen: u4 = try stream.readBitsNoEof(u4, 4);
// Convert to their real values
const real_hclen: u5 = @intCast(u5, raw_hclen) + 4;
const real_hdist: u6 = @intCast(u6, raw_hdist) + 1;
const real_hlit: u9 = @intCast(u9, raw_hlit) + 257;
//warn("HLIT = {} -> {}\n", raw_hlit, real_hlit);
//warn("HDIST = {} -> {}\n", raw_hdist, real_hdist);
//warn("HCLEN = {} -> {}\n", raw_hclen, real_hclen);
var clen_table: [15 + 4]u3 = [_]u3{0} ** (15 + 4);
const clen_remap: [15 + 4]u5 = [_]u5{
16, 17, 18, 0, 8,
7, 9, 6, 10, 5,
11, 4, 12, 3, 13,
2, 14, 1, 15,
};
// Parse the code length table
{
var i: u5 = 0;
while (i < real_hclen) : (i += 1) {
const k: u5 = clen_remap[i];
const v: u3 = try stream.readBitsNoEof(u3, 3);
clen_table[k] = v;
//warn("clen {} = {}\n", k, v);
}
}
// Build a canonical huffman tree
const clen_tree = CanonicalHuffmanTree(u3, 15 + 4).fromLengths(&clen_table);
// Build the other trees
const lit_tree = try buildDeflateHuffmanTree(u9, 31 + 257, real_hlit, &clen_tree, stream);
const dist_tree = try buildDeflateHuffmanTree(u6, 31 + 1, real_hdist, &clen_tree, stream);
return Self{
.lit_tree = lit_tree,
.dist_tree = dist_tree,
};
}
pub fn readLitFrom(self: *Self, stream: *InputBitStream) !(TLitTree.Tval) {
return try self.lit_tree.readFrom(stream);
}
pub fn readDistFrom(self: *Self, stream: *InputBitStream) !(TDistTree.Tval) {
return try self.dist_tree.readFrom(stream);
}
fn buildDeflateHuffmanTree(comptime Tval: type, comptime max_len: Tval, actual_len: Tval, clen_tree: *const CanonicalHuffmanTree(u3, 15 + 4), stream: *InputBitStream) !CanonicalHuffmanTree(u4, max_len) {
// Read tree lengths
var table: [max_len]u4 = [_]u4{0} ** (max_len);
{
var i: Tval = 0;
var prev: u4 = undefined;
while (i < actual_len) {
const v: u5 = try clen_tree.readFrom(stream);
//warn("hlit {} = {}\n", i, v);
switch (v) {
// Copy previous 3+u2 times
16 => {
// Can't copy a previous value if it's not there
if (i < 1) {
return error.Failed;
}
const times: usize = 3 + @as(usize, try stream.readBitsNoEof(u2, 2));
var j: usize = 0;
while (j < times) : (j += 1) {
table[i] = prev;
i += 1;
}
},
// Repeat 0 for 3+u3 times
17 => {
const times: usize = 3 + @as(usize, try stream.readBitsNoEof(u3, 3));
var j: usize = 0;
while (j < times) : (j += 1) {
table[i] = 0;
i += 1;
}
},
// Repeat 0 for 11+u7 times
18 => {
const times: usize = 11 + @as(usize, try stream.readBitsNoEof(u7, 7));
var j: usize = 0;
while (j < times) : (j += 1) {
table[i] = 0;
i += 1;
}
},
else => {
prev = @intCast(u4, v);
table[i] = prev;
i += 1;
},
}
}
}
// Build a canonical huffman tree
return CanonicalHuffmanTree(u4, max_len).fromLengths(&table);
}
};
} | src/block_tree.zig |
const std = @import("std");
const builtin = @import("builtin");
const uefi = @import("uefi/uefi.zig");
const state = @import("state.zig");
const graphics = @import("graphics.zig");
const gdt = @import("gdt.zig");
export fn EfiMain(img: uefi.Handle, sys: *uefi.SystemTable) uefi.Status {
state.uefi_image = img;
state.system_table = sys;
preExitBootServices() catch |err| {
_ = state.stdout.print("{}\n", err) catch void;
// TODO
// if (@errorReturnTrace()) |trace| {
// std.debug.dumpStackTrace(trace.*);
// }
while (true) {
asm volatile ("hlt" :::);
}
};
var map_key: usize = undefined;
var desc_size: usize = undefined;
var desc_version: u32 = undefined;
var memory_map_size = usize(1);
var memory_map: [*]uefi.MemoryDescriptor = undefined;
_ = sys.boot_services.allocatePool(uefi.MemoryType.LoaderData,
@sizeOf(@typeOf(memory_map)) * memory_map_size,
@ptrCast(**c_void, &memory_map));
while (sys.boot_services.getMemoryMap(&memory_map_size,
memory_map,
&map_key,
&desc_size,
&desc_version) != 0) {
_ = sys.boot_services.freePool(memory_map);
memory_map_size += 10;
_ = sys.boot_services.allocatePool(uefi.MemoryType.LoaderData,
@sizeOf(@typeOf(memory_map)) * memory_map_size,
@ptrCast(**c_void, &memory_map));
}
_ = sys.boot_services.exitBootServices(img, map_key);
postExitBootServices() catch |err| {
_ = state.stdout.print("{}\n", err) catch void;
// TODO
// if (@errorReturnTrace()) |trace| {
// std.debug.dumpStackTrace(trace.*);
// }
while (true) {
asm volatile ("hlt" :::);
}
};
return @enumToInt(uefi.StatusValues.Success);
}
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
@setCold(true);
if (!state.exited_boot_services) {
_ = state.stdout.print("{}\n", msg) catch unreachable;
}
while (true) {}
}
fn preExitBootServices() error{}!void {
_ = state.system_table.boot_services.setWatchdogTimer(0, 0, 0, null);
var gop: *uefi.protocols.graphics_output.Protocol = undefined;
_ = state.system_table.boot_services.locateProtocol(&uefi.protocols.graphics_output.guid, null, @ptrCast(*?*c_void, &gop));
const frame = graphics.Frame{
.info = gop.mode.info.*,
.frame_buffer = @intToPtr([*]u8, gop.mode.frame_buffer_base),
};
var fg = graphics.Pixel{
.blue = 255,
.green = 255,
.red = 255,
};
const bg = graphics.Pixel{
.blue = 0,
.green = 0,
.red = 0,
};
state.stdout = graphics.TextFrame.init(frame, fg, bg);
}
fn postExitBootServices() error{}!void {
_ = state.stdout.print("old gdt len: {}\n", gdt.storeGdt().len) catch unreachable;
gdt.loadGdt(gdt.our_gdt[0..], 1, 2);
_ = state.stdout.print("new gdt len: {}\n", gdt.storeGdt().len) catch unreachable;
while (true) {
asm volatile ("hlt" :::);
}
} | src/boot.zig |
pub const PORT_PCR_MUX_SHIFT = 8;
pub const PORT_PCR_MUX_MASK = 0x700;
pub const PORT_PCR_SRE_MASK = 0x4;
pub const PORT_PCR_DSE_MASK = 0x40;
pub const WDOG_UNLOCK_SEQ2 = 0xD928;
pub const WDOG_UNLOCK_SEQ1 = 0xC520;
pub const WDOG_STCTRLH_ALLOWUPDATE_MASK = 0x10;
pub const PMC_REGSC_BGBE_MASK = 0x1;
pub const PMC_REGSC_BGBE_SHIFT = 0;
pub const PMC_REGSC_REGONS_MASK = 0x4;
pub const PMC_REGSC_REGONS_SHIFT = 2;
pub const PMC_REGSC_ACKISO_MASK = 0x8;
pub const PMC_REGSC_ACKISO_SHIFT = 3;
pub const PMC_REGSC_BGEN_MASK = 0x10;
pub const PMC_REGSC_BGEN_SHIFT = 4;
// BDH Bit Fields
pub const UART_BDH_SBR_MASK = 0x1F;
pub const UART_BDH_SBR_SHIFT = 0;
pub const UART_BDH_RXEDGIE_MASK = 0x40;
pub const UART_BDH_RXEDGIE_SHIFT = 6;
pub const UART_BDH_LBKDIE_MASK = 0x80;
pub const UART_BDH_LBKDIE_SHIFT = 7;
// BDL Bit Fields
pub const UART_BDL_SBR_MASK = 0xFF;
pub const UART_BDL_SBR_SHIFT = 0;
// C1 Bit Fields
pub const UART_C1_PT_MASK = 0x1;
pub const UART_C1_PT_SHIFT = 0;
pub const UART_C1_PE_MASK = 0x2;
pub const UART_C1_PE_SHIFT = 1;
pub const UART_C1_ILT_MASK = 0x4;
pub const UART_C1_ILT_SHIFT = 2;
pub const UART_C1_WAKE_MASK = 0x8;
pub const UART_C1_WAKE_SHIFT = 3;
pub const UART_C1_M_MASK = 0x10;
pub const UART_C1_M_SHIFT = 4;
pub const UART_C1_RSRC_MASK = 0x20;
pub const UART_C1_RSRC_SHIFT = 5;
pub const UART_C1_UARTSWAI_MASK = 0x40;
pub const UART_C1_UARTSWAI_SHIFT = 6;
pub const UART_C1_LOOPS_MASK = 0x80;
pub const UART_C1_LOOPS_SHIFT = 7;
// C2 Bit Fields
pub const UART_C2_SBK_MASK = 0x1;
pub const UART_C2_SBK_SHIFT = 0;
pub const UART_C2_RWU_MASK = 0x2;
pub const UART_C2_RWU_SHIFT = 1;
pub const UART_C2_RE_MASK = 0x4;
pub const UART_C2_RE_SHIFT = 2;
pub const UART_C2_TE_MASK = 0x8;
pub const UART_C2_TE_SHIFT = 3;
pub const UART_C2_ILIE_MASK = 0x10;
pub const UART_C2_ILIE_SHIFT = 4;
pub const UART_C2_RIE_MASK = 0x20;
pub const UART_C2_RIE_SHIFT = 5;
pub const UART_C2_TCIE_MASK = 0x40;
pub const UART_C2_TCIE_SHIFT = 6;
pub const UART_C2_TIE_MASK = 0x80;
pub const UART_C2_TIE_SHIFT = 7;
// S1 Bit Fields
pub const UART_S1_PF_MASK = 0x1;
pub const UART_S1_PF_SHIFT = 0;
pub const UART_S1_FE_MASK = 0x2;
pub const UART_S1_FE_SHIFT = 1;
pub const UART_S1_NF_MASK = 0x4;
pub const UART_S1_NF_SHIFT = 2;
pub const UART_S1_OR_MASK = 0x8;
pub const UART_S1_OR_SHIFT = 3;
pub const UART_S1_IDLE_MASK = 0x10;
pub const UART_S1_IDLE_SHIFT = 4;
pub const UART_S1_RDRF_MASK = 0x20;
pub const UART_S1_RDRF_SHIFT = 5;
pub const UART_S1_TC_MASK = 0x40;
pub const UART_S1_TC_SHIFT = 6;
pub const UART_S1_TDRE_MASK = 0x80;
pub const UART_S1_TDRE_SHIFT = 7;
// S2 Bit Fields
pub const UART_S2_RAF_MASK = 0x1;
pub const UART_S2_RAF_SHIFT = 0;
pub const UART_S2_LBKDE_MASK = 0x2;
pub const UART_S2_LBKDE_SHIFT = 1;
pub const UART_S2_BRK13_MASK = 0x4;
pub const UART_S2_BRK13_SHIFT = 2;
pub const UART_S2_RWUID_MASK = 0x8;
pub const UART_S2_RWUID_SHIFT = 3;
pub const UART_S2_RXINV_MASK = 0x10;
pub const UART_S2_RXINV_SHIFT = 4;
pub const UART_S2_MSBF_MASK = 0x20;
pub const UART_S2_MSBF_SHIFT = 5;
pub const UART_S2_RXEDGIF_MASK = 0x40;
pub const UART_S2_RXEDGIF_SHIFT = 6;
pub const UART_S2_LBKDIF_MASK = 0x80;
pub const UART_S2_LBKDIF_SHIFT = 7;
// C3 Bit Fields
pub const UART_C3_PEIE_MASK = 0x1;
pub const UART_C3_PEIE_SHIFT = 0;
pub const UART_C3_FEIE_MASK = 0x2;
pub const UART_C3_FEIE_SHIFT = 1;
pub const UART_C3_NEIE_MASK = 0x4;
pub const UART_C3_NEIE_SHIFT = 2;
pub const UART_C3_ORIE_MASK = 0x8;
pub const UART_C3_ORIE_SHIFT = 3;
pub const UART_C3_TXINV_MASK = 0x10;
pub const UART_C3_TXINV_SHIFT = 4;
pub const UART_C3_TXDIR_MASK = 0x20;
pub const UART_C3_TXDIR_SHIFT = 5;
pub const UART_C3_T8_MASK = 0x40;
pub const UART_C3_T8_SHIFT = 6;
pub const UART_C3_R8_MASK = 0x80;
pub const UART_C3_R8_SHIFT = 7;
// D Bit Fields
pub const UART_D_RT_MASK = 0xFF;
pub const UART_D_RT_SHIFT = 0;
// MA1 Bit Fields
pub const UART_MA1_MA_MASK = 0xFF;
pub const UART_MA1_MA_SHIFT = 0;
// MA2 Bit Fields
pub const UART_MA2_MA_MASK = 0xFF;
pub const UART_MA2_MA_SHIFT = 0;
// C4 Bit Fields
pub const UART_C4_BRFA_MASK = 0x1F;
pub const UART_C4_BRFA_SHIFT = 0;
pub const UART_C4_M10_MASK = 0x20;
pub const UART_C4_M10_SHIFT = 5;
pub const UART_C4_MAEN2_MASK = 0x40;
pub const UART_C4_MAEN2_SHIFT = 6;
pub const UART_C4_MAEN1_MASK = 0x80;
pub const UART_C4_MAEN1_SHIFT = 7;
// C5 Bit Fields
pub const UART_C5_RDMAS_MASK = 0x20;
pub const UART_C5_RDMAS_SHIFT = 5;
pub const UART_C5_TDMAS_MASK = 0x80;
pub const UART_C5_TDMAS_SHIFT = 7;
// ED Bit Fields
pub const UART_ED_PARITYE_MASK = 0x40;
pub const UART_ED_PARITYE_SHIFT = 6;
pub const UART_ED_NOISY_MASK = 0x80;
pub const UART_ED_NOISY_SHIFT = 7;
// MODEM Bit Fields
pub const UART_MODEM_TXCTSE_MASK = 0x1;
pub const UART_MODEM_TXCTSE_SHIFT = 0;
pub const UART_MODEM_TXRTSE_MASK = 0x2;
pub const UART_MODEM_TXRTSE_SHIFT = 1;
pub const UART_MODEM_TXRTSPOL_MASK = 0x4;
pub const UART_MODEM_TXRTSPOL_SHIFT = 2;
pub const UART_MODEM_RXRTSE_MASK = 0x8;
pub const UART_MODEM_RXRTSE_SHIFT = 3;
// IR Bit Fields
pub const UART_IR_TNP_MASK = 0x3;
pub const UART_IR_TNP_SHIFT = 0;
pub const UART_IR_IREN_MASK = 0x4;
pub const UART_IR_IREN_SHIFT = 2;
// PFIFO Bit Fields
pub const UART_PFIFO_RXFIFOSIZE_MASK = 0x7;
pub const UART_PFIFO_RXFIFOSIZE_SHIFT = 0;
pub const UART_PFIFO_RXFE_MASK = 0x8;
pub const UART_PFIFO_RXFE_SHIFT = 3;
pub const UART_PFIFO_TXFIFOSIZE_MASK = 0x70;
pub const UART_PFIFO_TXFIFOSIZE_SHIFT = 4;
pub const UART_PFIFO_TXFE_MASK = 0x80;
pub const UART_PFIFO_TXFE_SHIFT = 7;
// CFIFO Bit Fields
pub const UART_CFIFO_RXUFE_MASK = 0x1;
pub const UART_CFIFO_RXUFE_SHIFT = 0;
pub const UART_CFIFO_TXOFE_MASK = 0x2;
pub const UART_CFIFO_TXOFE_SHIFT = 1;
pub const UART_CFIFO_RXFLUSH_MASK = 0x40;
pub const UART_CFIFO_RXFLUSH_SHIFT = 6;
pub const UART_CFIFO_TXFLUSH_MASK = 0x80;
pub const UART_CFIFO_TXFLUSH_SHIFT = 7;
// SFIFO Bit Fields
pub const UART_SFIFO_RXUF_MASK = 0x1;
pub const UART_SFIFO_RXUF_SHIFT = 0;
pub const UART_SFIFO_TXOF_MASK = 0x2;
pub const UART_SFIFO_TXOF_SHIFT = 1;
pub const UART_SFIFO_RXEMPT_MASK = 0x40;
pub const UART_SFIFO_RXEMPT_SHIFT = 6;
pub const UART_SFIFO_TXEMPT_MASK = 0x80;
pub const UART_SFIFO_TXEMPT_SHIFT = 7;
// TWFIFO Bit Fields
pub const UART_TWFIFO_TXWATER_MASK = 0xFF;
pub const UART_TWFIFO_TXWATER_SHIFT = 0;
// TCFIFO Bit Fields
pub const UART_TCFIFO_TXCOUNT_MASK = 0xFF;
pub const UART_TCFIFO_TXCOUNT_SHIFT = 0;
// RWFIFO Bit Fields
pub const UART_RWFIFO_RXWATER_MASK = 0xFF;
pub const UART_RWFIFO_RXWATER_SHIFT = 0;
// RCFIFO Bit Fields
pub const UART_RCFIFO_RXCOUNT_MASK = 0xFF;
pub const UART_RCFIFO_RXCOUNT_SHIFT = 0;
// C7816 Bit Fields
pub const UART_C7816_ISO_7816E_MASK = 0x1;
pub const UART_C7816_ISO_7816E_SHIFT = 0;
pub const UART_C7816_TTYPE_MASK = 0x2;
pub const UART_C7816_TTYPE_SHIFT = 1;
pub const UART_C7816_INIT_MASK = 0x4;
pub const UART_C7816_INIT_SHIFT = 2;
pub const UART_C7816_ANACK_MASK = 0x8;
pub const UART_C7816_ANACK_SHIFT = 3;
pub const UART_C7816_ONACK_MASK = 0x10;
pub const UART_C7816_ONACK_SHIFT = 4;
// IE7816 Bit Fields
pub const UART_IE7816_RXTE_MASK = 0x1;
pub const UART_IE7816_RXTE_SHIFT = 0;
pub const UART_IE7816_TXTE_MASK = 0x2;
pub const UART_IE7816_TXTE_SHIFT = 1;
pub const UART_IE7816_GTVE_MASK = 0x4;
pub const UART_IE7816_GTVE_SHIFT = 2;
pub const UART_IE7816_INITDE_MASK = 0x10;
pub const UART_IE7816_INITDE_SHIFT = 4;
pub const UART_IE7816_BWTE_MASK = 0x20;
pub const UART_IE7816_BWTE_SHIFT = 5;
pub const UART_IE7816_CWTE_MASK = 0x40;
pub const UART_IE7816_CWTE_SHIFT = 6;
pub const UART_IE7816_WTE_MASK = 0x80;
pub const UART_IE7816_WTE_SHIFT = 7;
// IS7816 Bit Fields
pub const UART_IS7816_RXT_MASK = 0x1;
pub const UART_IS7816_RXT_SHIFT = 0;
pub const UART_IS7816_TXT_MASK = 0x2;
pub const UART_IS7816_TXT_SHIFT = 1;
pub const UART_IS7816_GTV_MASK = 0x4;
pub const UART_IS7816_GTV_SHIFT = 2;
pub const UART_IS7816_INITD_MASK = 0x10;
pub const UART_IS7816_INITD_SHIFT = 4;
pub const UART_IS7816_BWT_MASK = 0x20;
pub const UART_IS7816_BWT_SHIFT = 5;
pub const UART_IS7816_CWT_MASK = 0x40;
pub const UART_IS7816_CWT_SHIFT = 6;
pub const UART_IS7816_WT_MASK = 0x80;
pub const UART_IS7816_WT_SHIFT = 7;
// WP7816_T_TYPE0 Bit Fields
pub const UART_WP7816_T_TYPE0_WI_MASK = 0xFF;
pub const UART_WP7816_T_TYPE0_WI_SHIFT = 0;
// WP7816_T_TYPE1 Bit Fields
pub const UART_WP7816_T_TYPE1_BWI_MASK = 0xF;
pub const UART_WP7816_T_TYPE1_BWI_SHIFT = 0;
pub const UART_WP7816_T_TYPE1_CWI_MASK = 0xF0;
pub const UART_WP7816_T_TYPE1_CWI_SHIFT = 4;
// WN7816 Bit Fields
pub const UART_WN7816_GTN_MASK = 0xFF;
pub const UART_WN7816_GTN_SHIFT = 0;
// WF7816 Bit Fields
pub const UART_WF7816_GTFD_MASK = 0xFF;
pub const UART_WF7816_GTFD_SHIFT = 0;
// ET7816 Bit Fields
pub const UART_ET7816_RXTHRESHOLD_MASK = 0xF;
pub const UART_ET7816_RXTHRESHOLD_SHIFT = 0;
pub const UART_ET7816_TXTHRESHOLD_MASK = 0xF0;
pub const UART_ET7816_TXTHRESHOLD_SHIFT = 4;
// TL7816 Bit Fields
pub const UART_TL7816_TLEN_MASK = 0xFF;
pub const UART_TL7816_TLEN_SHIFT = 0;
//define UART_TWFIFO_TXWATER(x) (((uint8_t)(((uint8_t)(x))<<UART_TWFIFO_TXWATER_SHIFT))&UART_TWFIFO_TXWATER_MASK)
//define UART_IR_TNP(x) (((uint8_t)(((uint8_t)(x))<<UART_IR_TNP_SHIFT))&UART_IR_TNP_MASK)
//define UART_D_RT(x) (((uint8_t)(((uint8_t)(x))<<UART_D_RT_SHIFT))&UART_D_RT_MASK)
//define UART_PFIFO_RXFIFOSIZE(x) (((uint8_t)(((uint8_t)(x))<<UART_PFIFO_RXFIFOSIZE_SHIFT))&UART_PFIFO_RXFIFOSIZE_MASK)
//define UART_MA1_MA(x) (((uint8_t)(((uint8_t)(x))<<UART_MA1_MA_SHIFT))&UART_MA1_MA_MASK)
//define UART_MA2_MA(x) (((uint8_t)(((uint8_t)(x))<<UART_MA2_MA_SHIFT))&UART_MA2_MA_MASK)
//define UART_PFIFO_TXFIFOSIZE(x) (((uint8_t)(((uint8_t)(x))<<UART_PFIFO_TXFIFOSIZE_SHIFT))&UART_PFIFO_TXFIFOSIZE_MASK)
//define UART_TCFIFO_TXCOUNT(x) (((uint8_t)(((uint8_t)(x))<<UART_TCFIFO_TXCOUNT_SHIFT))&UART_TCFIFO_TXCOUNT_MASK)
//define UART_RWFIFO_RXWATER(x) (((uint8_t)(((uint8_t)(x))<<UART_RWFIFO_RXWATER_SHIFT))&UART_RWFIFO_RXWATER_MASK)
//define UART_RCFIFO_RXCOUNT(x) (((uint8_t)(((uint8_t)(x))<<UART_RCFIFO_RXCOUNT_SHIFT))&UART_RCFIFO_RXCOUNT_MASK)
//define UART_C4_BRFA(x) (((uint8_t)(((uint8_t)(x))<<UART_C4_BRFA_SHIFT))&UART_C4_BRFA_MASK)
//define UART_BDL_SBR(x) (((uint8_t)(((uint8_t)(x))<<UART_BDL_SBR_SHIFT))&UART_BDL_SBR_MASK)
//define UART_BDH_SBR(x) (((uint8_t)(((uint8_t)(x))<<UART_BDH_SBR_SHIFT))&UART_BDH_SBR_MASK)
//define UART_WP7816_T_TYPE0_WI(x) (((uint8_t)(((uint8_t)(x))<<UART_WP7816_T_TYPE0_WI_SHIFT))&UART_WP7816_T_TYPE0_WI_MASK)
//define UART_WP7816_T_TYPE1_BWI(x) (((uint8_t)(((uint8_t)(x))<<UART_WP7816_T_TYPE1_BWI_SHIFT))&UART_WP7816_T_TYPE1_BWI_MASK)
//define UART_WP7816_T_TYPE1_CWI(x) (((uint8_t)(((uint8_t)(x))<<UART_WP7816_T_TYPE1_CWI_SHIFT))&UART_WP7816_T_TYPE1_CWI_MASK)
//define UART_WN7816_GTN(x) (((uint8_t)(((uint8_t)(x))<<UART_WN7816_GTN_SHIFT))&UART_WN7816_GTN_MASK)
//define UART_WF7816_GTFD(x) (((uint8_t)(((uint8_t)(x))<<UART_WF7816_GTFD_SHIFT))&UART_WF7816_GTFD_MASK)
//define UART_ET7816_RXTHRESHOLD(x) (((uint8_t)(((uint8_t)(x))<<UART_ET7816_RXTHRESHOLD_SHIFT))&UART_ET7816_RXTHRESHOLD_MASK)
//define UART_ET7816_TXTHRESHOLD(x) (((uint8_t)(((uint8_t)(x))<<UART_ET7816_TXTHRESHOLD_SHIFT))&UART_ET7816_TXTHRESHOLD_MASK)
//define UART_TL7816_TLEN(x) (((uint8_t)(((uint8_t)(x))<<UART_TL7816_TLEN_SHIFT))&UART_TL7816_TLEN_MASK)
// SOPT1 Bit Fields
pub const SIM_SOPT1_RAMSIZE_MASK = 0xF000;
pub const SIM_SOPT1_RAMSIZE_SHIFT = 12;
pub const SIM_SOPT1_OSC32KSEL_MASK = 0xC0000;
pub const SIM_SOPT1_OSC32KSEL_SHIFT = 18;
pub const SIM_SOPT1_USBVSTBY_MASK = 0x20000000;
pub const SIM_SOPT1_USBVSTBY_SHIFT = 29;
pub const SIM_SOPT1_USBSSTBY_MASK = 0x40000000;
pub const SIM_SOPT1_USBSSTBY_SHIFT = 30;
pub const SIM_SOPT1_USBREGEN_MASK = 0x80000000;
pub const SIM_SOPT1_USBREGEN_SHIFT = 31;
// SOPT1CFG Bit Fields
pub const SIM_SOPT1CFG_URWE_MASK = 0x1000000;
pub const SIM_SOPT1CFG_URWE_SHIFT = 24;
pub const SIM_SOPT1CFG_UVSWE_MASK = 0x2000000;
pub const SIM_SOPT1CFG_UVSWE_SHIFT = 25;
pub const SIM_SOPT1CFG_USSWE_MASK = 0x4000000;
pub const SIM_SOPT1CFG_USSWE_SHIFT = 26;
// SOPT2 Bit Fields
pub const SIM_SOPT2_RTCCLKOUTSEL_MASK = 0x10;
pub const SIM_SOPT2_RTCCLKOUTSEL_SHIFT = 4;
pub const SIM_SOPT2_CLKOUTSEL_MASK = 0xE0;
pub const SIM_SOPT2_CLKOUTSEL_SHIFT = 5;
pub const SIM_SOPT2_FBSL_MASK = 0x300;
pub const SIM_SOPT2_FBSL_SHIFT = 8;
pub const SIM_SOPT2_PTD7PAD_MASK = 0x800;
pub const SIM_SOPT2_PTD7PAD_SHIFT = 11;
pub const SIM_SOPT2_TRACECLKSEL_MASK = 0x1000;
pub const SIM_SOPT2_TRACECLKSEL_SHIFT = 12;
pub const SIM_SOPT2_PLLFLLSEL_MASK = 0x10000;
pub const SIM_SOPT2_PLLFLLSEL_SHIFT = 16;
pub const SIM_SOPT2_USBSRC_MASK = 0x40000;
pub const SIM_SOPT2_USBSRC_SHIFT = 18;
// SOPT4 Bit Fields
pub const SIM_SOPT4_FTM0FLT0_MASK = 0x1;
pub const SIM_SOPT4_FTM0FLT0_SHIFT = 0;
pub const SIM_SOPT4_FTM0FLT1_MASK = 0x2;
pub const SIM_SOPT4_FTM0FLT1_SHIFT = 1;
pub const SIM_SOPT4_FTM0FLT2_MASK = 0x4;
pub const SIM_SOPT4_FTM0FLT2_SHIFT = 2;
pub const SIM_SOPT4_FTM1FLT0_MASK = 0x10;
pub const SIM_SOPT4_FTM1FLT0_SHIFT = 4;
pub const SIM_SOPT4_FTM2FLT0_MASK = 0x100;
pub const SIM_SOPT4_FTM2FLT0_SHIFT = 8;
pub const SIM_SOPT4_FTM1CH0SRC_MASK = 0xC0000;
pub const SIM_SOPT4_FTM1CH0SRC_SHIFT = 18;
pub const SIM_SOPT4_FTM2CH0SRC_MASK = 0x300000;
pub const SIM_SOPT4_FTM2CH0SRC_SHIFT = 20;
pub const SIM_SOPT4_FTM0CLKSEL_MASK = 0x1000000;
pub const SIM_SOPT4_FTM0CLKSEL_SHIFT = 24;
pub const SIM_SOPT4_FTM1CLKSEL_MASK = 0x2000000;
pub const SIM_SOPT4_FTM1CLKSEL_SHIFT = 25;
pub const SIM_SOPT4_FTM2CLKSEL_MASK = 0x4000000;
pub const SIM_SOPT4_FTM2CLKSEL_SHIFT = 26;
pub const SIM_SOPT4_FTM0TRG0SRC_MASK = 0x10000000;
pub const SIM_SOPT4_FTM0TRG0SRC_SHIFT = 28;
pub const SIM_SOPT4_FTM0TRG1SRC_MASK = 0x20000000;
pub const SIM_SOPT4_FTM0TRG1SRC_SHIFT = 29;
// SOPT5 Bit Fields
pub const SIM_SOPT5_UART0TXSRC_MASK = 0x3;
pub const SIM_SOPT5_UART0TXSRC_SHIFT = 0;
pub const SIM_SOPT5_UART0RXSRC_MASK = 0xC;
pub const SIM_SOPT5_UART0RXSRC_SHIFT = 2;
pub const SIM_SOPT5_UART1TXSRC_MASK = 0x30;
pub const SIM_SOPT5_UART1TXSRC_SHIFT = 4;
pub const SIM_SOPT5_UART1RXSRC_MASK = 0xC0;
pub const SIM_SOPT5_UART1RXSRC_SHIFT = 6;
// SOPT7 Bit Fields
pub const SIM_SOPT7_ADC0TRGSEL_MASK = 0xF;
pub const SIM_SOPT7_ADC0TRGSEL_SHIFT = 0;
pub const SIM_SOPT7_ADC0PRETRGSEL_MASK = 0x10;
pub const SIM_SOPT7_ADC0PRETRGSEL_SHIFT = 4;
pub const SIM_SOPT7_ADC0ALTTRGEN_MASK = 0x80;
pub const SIM_SOPT7_ADC0ALTTRGEN_SHIFT = 7;
pub const SIM_SOPT7_ADC1TRGSEL_MASK = 0xF00;
pub const SIM_SOPT7_ADC1TRGSEL_SHIFT = 8;
pub const SIM_SOPT7_ADC1PRETRGSEL_MASK = 0x1000;
pub const SIM_SOPT7_ADC1PRETRGSEL_SHIFT = 12;
pub const SIM_SOPT7_ADC1ALTTRGEN_MASK = 0x8000;
pub const SIM_SOPT7_ADC1ALTTRGEN_SHIFT = 15;
// SDID Bit Fields
pub const SIM_SDID_PINID_MASK = 0xF;
pub const SIM_SDID_PINID_SHIFT = 0;
pub const SIM_SDID_FAMID_MASK = 0x70;
pub const SIM_SDID_FAMID_SHIFT = 4;
pub const SIM_SDID_REVID_MASK = 0xF000;
pub const SIM_SDID_REVID_SHIFT = 12;
// SCGC1 Bit Fields
pub const SIM_SCGC1_UART4_MASK = 0x400;
pub const SIM_SCGC1_UART4_SHIFT = 10;
// SCGC2 Bit Fields
pub const SIM_SCGC2_DAC0_MASK = 0x1000;
pub const SIM_SCGC2_DAC0_SHIFT = 12;
// SCGC3 Bit Fields
pub const SIM_SCGC3_FTM2_MASK = 0x1000000;
pub const SIM_SCGC3_FTM2_SHIFT = 24;
pub const SIM_SCGC3_ADC1_MASK = 0x8000000;
pub const SIM_SCGC3_ADC1_SHIFT = 27;
// SCGC4 Bit Fields
pub const SIM_SCGC4_EWM_MASK = 0x2;
pub const SIM_SCGC4_EWM_SHIFT = 1;
pub const SIM_SCGC4_CMT_MASK = 0x4;
pub const SIM_SCGC4_CMT_SHIFT = 2;
pub const SIM_SCGC4_I2C0_MASK = 0x40;
pub const SIM_SCGC4_I2C0_SHIFT = 6;
pub const SIM_SCGC4_I2C1_MASK = 0x80;
pub const SIM_SCGC4_I2C1_SHIFT = 7;
pub const SIM_SCGC4_UART0_MASK = 0x400;
pub const SIM_SCGC4_UART0_SHIFT = 10;
pub const SIM_SCGC4_UART1_MASK = 0x800;
pub const SIM_SCGC4_UART1_SHIFT = 11;
pub const SIM_SCGC4_UART2_MASK = 0x1000;
pub const SIM_SCGC4_UART2_SHIFT = 12;
pub const SIM_SCGC4_UART3_MASK = 0x2000;
pub const SIM_SCGC4_UART3_SHIFT = 13;
pub const SIM_SCGC4_USBOTG_MASK = 0x40000;
pub const SIM_SCGC4_USBOTG_SHIFT = 18;
pub const SIM_SCGC4_CMP_MASK = 0x80000;
pub const SIM_SCGC4_CMP_SHIFT = 19;
pub const SIM_SCGC4_VREF_MASK = 0x100000;
pub const SIM_SCGC4_VREF_SHIFT = 20;
// SCGC5 Bit Fields
pub const SIM_SCGC5_LPTIMER_MASK = 0x1;
pub const SIM_SCGC5_LPTIMER_SHIFT = 0;
pub const SIM_SCGC5_TSI_MASK = 0x20;
pub const SIM_SCGC5_TSI_SHIFT = 5;
pub const SIM_SCGC5_PORTA_MASK = 0x200;
pub const SIM_SCGC5_PORTA_SHIFT = 9;
pub const SIM_SCGC5_PORTB_MASK = 0x400;
pub const SIM_SCGC5_PORTB_SHIFT = 10;
pub const SIM_SCGC5_PORTC_MASK = 0x800;
pub const SIM_SCGC5_PORTC_SHIFT = 11;
pub const SIM_SCGC5_PORTD_MASK = 0x1000;
pub const SIM_SCGC5_PORTD_SHIFT = 12;
pub const SIM_SCGC5_PORTE_MASK = 0x2000;
pub const SIM_SCGC5_PORTE_SHIFT = 13;
// SCGC6 Bit Fields
pub const SIM_SCGC6_FTFL_MASK = 0x1;
pub const SIM_SCGC6_FTFL_SHIFT = 0;
pub const SIM_SCGC6_DMAMUX_MASK = 0x2;
pub const SIM_SCGC6_DMAMUX_SHIFT = 1;
pub const SIM_SCGC6_FLEXCAN0_MASK = 0x10;
pub const SIM_SCGC6_FLEXCAN0_SHIFT = 4;
pub const SIM_SCGC6_SPI0_MASK = 0x1000;
pub const SIM_SCGC6_SPI0_SHIFT = 12;
pub const SIM_SCGC6_SPI1_MASK = 0x2000;
pub const SIM_SCGC6_SPI1_SHIFT = 13;
pub const SIM_SCGC6_I2S_MASK = 0x8000;
pub const SIM_SCGC6_I2S_SHIFT = 15;
pub const SIM_SCGC6_CRC_MASK = 0x40000;
pub const SIM_SCGC6_CRC_SHIFT = 18;
pub const SIM_SCGC6_USBDCD_MASK = 0x200000;
pub const SIM_SCGC6_USBDCD_SHIFT = 21;
pub const SIM_SCGC6_PDB_MASK = 0x400000;
pub const SIM_SCGC6_PDB_SHIFT = 22;
pub const SIM_SCGC6_PIT_MASK = 0x800000;
pub const SIM_SCGC6_PIT_SHIFT = 23;
pub const SIM_SCGC6_FTM0_MASK = 0x1000000;
pub const SIM_SCGC6_FTM0_SHIFT = 24;
pub const SIM_SCGC6_FTM1_MASK = 0x2000000;
pub const SIM_SCGC6_FTM1_SHIFT = 25;
pub const SIM_SCGC6_ADC0_MASK = 0x8000000;
pub const SIM_SCGC6_ADC0_SHIFT = 27;
pub const SIM_SCGC6_RTC_MASK = 0x20000000;
pub const SIM_SCGC6_RTC_SHIFT = 29;
// SCGC7 Bit Fields
pub const SIM_SCGC7_FLEXBUS_MASK = 0x1;
pub const SIM_SCGC7_FLEXBUS_SHIFT = 0;
pub const SIM_SCGC7_DMA_MASK = 0x2;
pub const SIM_SCGC7_DMA_SHIFT = 1;
// CLKDIV1 Bit Fields
pub const SIM_CLKDIV1_OUTDIV4_MASK = 0xF0000;
pub const SIM_CLKDIV1_OUTDIV4_SHIFT = 16;
pub const SIM_CLKDIV1_OUTDIV3_MASK = 0xF00000;
pub const SIM_CLKDIV1_OUTDIV3_SHIFT = 20;
pub const SIM_CLKDIV1_OUTDIV2_MASK = 0xF000000;
pub const SIM_CLKDIV1_OUTDIV2_SHIFT = 24;
pub const SIM_CLKDIV1_OUTDIV1_MASK = 0xF0000000;
pub const SIM_CLKDIV1_OUTDIV1_SHIFT = 28;
// CLKDIV2 Bit Fields
pub const SIM_CLKDIV2_USBFRAC_MASK = 0x1;
pub const SIM_CLKDIV2_USBFRAC_SHIFT = 0;
pub const SIM_CLKDIV2_USBDIV_MASK = 0xE;
pub const SIM_CLKDIV2_USBDIV_SHIFT = 1;
// FCFG1 Bit Fields
pub const SIM_FCFG1_FLASHDIS_MASK = 0x1;
pub const SIM_FCFG1_FLASHDIS_SHIFT = 0;
pub const SIM_FCFG1_FLASHDOZE_MASK = 0x2;
pub const SIM_FCFG1_FLASHDOZE_SHIFT = 1;
pub const SIM_FCFG1_DEPART_MASK = 0xF00;
pub const SIM_FCFG1_DEPART_SHIFT = 8;
pub const SIM_FCFG1_EESIZE_MASK = 0xF0000;
pub const SIM_FCFG1_EESIZE_SHIFT = 16;
pub const SIM_FCFG1_PFSIZE_MASK = 0xF000000;
pub const SIM_FCFG1_PFSIZE_SHIFT = 24;
pub const SIM_FCFG1_NVMSIZE_MASK = 0xF0000000;
pub const SIM_FCFG1_NVMSIZE_SHIFT = 28;
// FCFG2 Bit Fields
pub const SIM_FCFG2_MAXADDR1_MASK = 0x7F0000;
pub const SIM_FCFG2_MAXADDR1_SHIFT = 16;
pub const SIM_FCFG2_PFLSH_MASK = 0x800000;
pub const SIM_FCFG2_PFLSH_SHIFT = 23;
pub const SIM_FCFG2_MAXADDR0_MASK = 0x7F000000;
pub const SIM_FCFG2_MAXADDR0_SHIFT = 24;
pub const SIM_FCFG2_SWAPPFLSH_MASK = 0x80000000;
pub const SIM_FCFG2_SWAPPFLSH_SHIFT = 31;
// UIDH Bit Fields
pub const SIM_UIDH_UID_MASK = 0xFFFFFFFF;
pub const SIM_UIDH_UID_SHIFT = 0;
// UIDMH Bit Fields
pub const SIM_UIDMH_UID_MASK = 0xFFFFFFFF;
pub const SIM_UIDMH_UID_SHIFT = 0;
// UIDML Bit Fields
pub const SIM_UIDML_UID_MASK = 0xFFFFFFFF;
pub const SIM_UIDML_UID_SHIFT = 0;
// UIDL Bit Fields
pub const SIM_UIDL_UID_MASK = 0xFFFFFFFF;
pub const SIM_UIDL_UID_SHIFT = 0;
// CR Bit Fields
pub const OSC_CR_SC16P_MASK = 0x1;
pub const OSC_CR_SC16P_SHIFT = 0;
pub const OSC_CR_SC8P_MASK = 0x2;
pub const OSC_CR_SC8P_SHIFT = 1;
pub const OSC_CR_SC4P_MASK = 0x4;
pub const OSC_CR_SC4P_SHIFT = 2;
pub const OSC_CR_SC2P_MASK = 0x8;
pub const OSC_CR_SC2P_SHIFT = 3;
pub const OSC_CR_EREFSTEN_MASK = 0x20;
pub const OSC_CR_EREFSTEN_SHIFT = 5;
pub const OSC_CR_ERCLKEN_MASK = 0x80;
pub const OSC_CR_ERCLKEN_SHIFT = 7;
// C1 Bit Fields
pub const MCG_C1_IREFSTEN_MASK = 0x1;
pub const MCG_C1_IREFSTEN_SHIFT = 0;
pub const MCG_C1_IRCLKEN_MASK = 0x2;
pub const MCG_C1_IRCLKEN_SHIFT = 1;
pub const MCG_C1_IREFS_MASK = 0x4;
pub const MCG_C1_IREFS_SHIFT = 2;
pub const MCG_C1_FRDIV_MASK = 0x38;
pub const MCG_C1_FRDIV_SHIFT = 3;
pub const MCG_C1_CLKS_MASK = 0xC0;
pub const MCG_C1_CLKS_SHIFT = 6;
// C2 Bit Fields
pub const MCG_C2_IRCS_MASK = 0x1;
pub const MCG_C2_IRCS_SHIFT = 0;
pub const MCG_C2_LP_MASK = 0x2;
pub const MCG_C2_LP_SHIFT = 1;
pub const MCG_C2_EREFS0_MASK = 0x4;
pub const MCG_C2_EREFS0_SHIFT = 2;
pub const MCG_C2_HGO0_MASK = 0x8;
pub const MCG_C2_HGO0_SHIFT = 3;
pub const MCG_C2_RANGE0_MASK = 0x30;
pub const MCG_C2_RANGE0_SHIFT = 4;
pub const MCG_C2_LOCRE0_MASK = 0x80;
pub const MCG_C2_LOCRE0_SHIFT = 7;
// C3 Bit Fields
pub const MCG_C3_SCTRIM_MASK = 0xFF;
pub const MCG_C3_SCTRIM_SHIFT = 0;
// C4 Bit Fields
pub const MCG_C4_SCFTRIM_MASK = 0x1;
pub const MCG_C4_SCFTRIM_SHIFT = 0;
pub const MCG_C4_FCTRIM_MASK = 0x1E;
pub const MCG_C4_FCTRIM_SHIFT = 1;
pub const MCG_C4_DRST_DRS_MASK = 0x60;
pub const MCG_C4_DRST_DRS_SHIFT = 5;
pub const MCG_C4_DMX32_MASK = 0x80;
pub const MCG_C4_DMX32_SHIFT = 7;
// C5 Bit Fields
pub const MCG_C5_PRDIV0_MASK = 0x1F;
pub const MCG_C5_PRDIV0_SHIFT = 0;
pub const MCG_C5_PLLSTEN0_MASK = 0x20;
pub const MCG_C5_PLLSTEN0_SHIFT = 5;
pub const MCG_C5_PLLCLKEN0_MASK = 0x40;
pub const MCG_C5_PLLCLKEN0_SHIFT = 6;
// C6 Bit Fields
pub const MCG_C6_VDIV0_MASK = 0x1F;
pub const MCG_C6_VDIV0_SHIFT = 0;
pub const MCG_C6_CME0_MASK = 0x20;
pub const MCG_C6_CME0_SHIFT = 5;
pub const MCG_C6_PLLS_MASK = 0x40;
pub const MCG_C6_PLLS_SHIFT = 6;
pub const MCG_C6_LOLIE0_MASK = 0x80;
pub const MCG_C6_LOLIE0_SHIFT = 7;
// S Bit Fields
pub const MCG_S_IRCST_MASK = 0x1;
pub const MCG_S_IRCST_SHIFT = 0;
pub const MCG_S_OSCINIT0_MASK = 0x2;
pub const MCG_S_OSCINIT0_SHIFT = 1;
pub const MCG_S_CLKST_MASK = 0xC;
pub const MCG_S_CLKST_SHIFT = 2;
pub const MCG_S_IREFST_MASK = 0x10;
pub const MCG_S_IREFST_SHIFT = 4;
pub const MCG_S_PLLST_MASK = 0x20;
pub const MCG_S_PLLST_SHIFT = 5;
pub const MCG_S_LOCK0_MASK = 0x40;
pub const MCG_S_LOCK0_SHIFT = 6;
pub const MCG_S_LOLS0_MASK = 0x80;
pub const MCG_S_LOLS0_SHIFT = 7;
// SysTick Register Masks
// CSR Bit Fields
pub const SysTick_CSR_ENABLE_MASK = 0x1;
pub const SysTick_CSR_ENABLE_SHIFT = 0;
pub const SysTick_CSR_TICKINT_MASK = 0x2;
pub const SysTick_CSR_TICKINT_SHIFT = 1;
pub const SysTick_CSR_CLKSOURCE_MASK = 0x4;
pub const SysTick_CSR_CLKSOURCE_SHIFT = 2;
pub const SysTick_CSR_COUNTFLAG_MASK = 0x10000;
pub const SysTick_CSR_COUNTFLAG_SHIFT = 16;
// RVR Bit Fields
pub const SysTick_RVR_RELOAD_MASK = 0xFFFFFF;
pub const SysTick_RVR_RELOAD_SHIFT = 0;
// CVR Bit Fields
pub const SysTick_CVR_CURRENT_MASK = 0xFFFFFF;
pub const SysTick_CVR_CURRENT_SHIFT = 0;
// CALIB Bit Fields
pub const SysTick_CALIB_TENMS_MASK = 0xFFFFFF;
pub const SysTick_CALIB_TENMS_SHIFT = 0;
pub const SysTick_CALIB_SKEW_MASK = 0x40000000;
pub const SysTick_CALIB_SKEW_SHIFT = 30;
pub const SysTick_CALIB_NOREF_MASK = 0x80000000;
pub const SysTick_CALIB_NOREF_SHIFT = 31;
pub const SCB_ICSR_PENDSVCLR_MASK = 0x8000000;
pub const SCB_ICSR_PENDSVCLR_SHIFT = 27;
pub const SCB_ICSR_PENDSVSET_MASK = 0x10000000;
pub const SCB_ICSR_PENDSVSET_SHIFT = 28;
// SCB - Peripheral register structure
const SystemControl_MemMap = struct {
RESERVED_0: [8]u8,
ACTLR: u32, // < Auxiliary Control Register,, offset: 0x8
RESERVED_1: [3316]u8,
CPUID: u32, // < CPUID Base Register, offset: 0xD00
ICSR: u32, // < Interrupt Control and State Register, offset: 0xD04
VTOR: u32, // < Vector Table Offset Register, offset: 0xD08
AIRCR: u32, // < Application Interrupt and Reset Control Register, offset: 0xD0C
SCR: u32, // < System Control Register, offset: 0xD10
CCR: u32, // < Configuration and Control Register, offset: 0xD14
SHPR1: u32, // < System Handler Priority Register 1, offset: 0xD18
SHPR2: u32, // < System Handler Priority Register 2, offset: 0xD1C
SHPR3: u32, // < System Handler Priority Register 3, offset: 0xD20
SHCSR: u32, // < System Handler Control and State Register, offset: 0xD24
CFSR: u32, // < Configurable Fault Status Registers, offset: 0xD28
HFSR: u32, // < HardFault Status register, offset: 0xD2C
DFSR: u32, // < Debug Fault Status Register, offset: 0xD30
MMFAR: u32, // < MemManage Address Register, offset: 0xD34
BFAR: u32, // < BusFault Address Register, offset: 0xD38
AFSR: u32, // < Auxiliary Fault Status Register, offset: 0xD3C
};
pub const Port = struct {
controlRegister: [32]u32, // PCR 0-31
globalPinControlLow: u32, // GPCLR
globalPinControlHigh: u32, // GPCHR
reserved: [24]u8,
interuptStatusFlag: u32, // ISFR
};
pub const Gpio = struct {
dataOutput: u32, // PDOR
setOutput: u32, // PSOR
clearOutput: u32, // PCOR
toggleOutput: u32, // PTOR
dataInput: u32, // PDIR
dataDirection: u32, // PDDR
};
const UartMemMap = struct {
BDH: u8, // < UART Baud Rate Registers:High, offset: 0x0
BDL: u8, // < UART Baud Rate Registers: Low, offset: 0x1
C1: u8, // < UART Control Register 1, offset: 0x2
C2: u8, // < UART Control Register 2, offset: 0x3
S1: u8, // < UART Status Register 1, offset: 0x4
S2: u8, // < UART Status Register 2, offset: 0x5
C3: u8, // < UART Control Register 3, offset: 0x6
D: u8, // < UART Data Register, offset: 0x7
MA1: u8, // < UART Match Address Registers 1, offset: 0x8
MA2: u8, // < UART Match Address Registers 2, offset: 0x9
C4: u8, // < UART Control Register 4, offset: 0xA
C5: u8, // < UART Control Register 5, offset: 0xB
ED: u8, // < UART Extended Data Register, offset: 0xC
MODEM: u8, // < UART Modem Register, offset: 0xD
IR: u8, // < UART Infrared Register, offset: 0xE
RESERVED_0: u8,
PFIFO: u8, // < UART FIFO Parameters, offset: 0x10
CFIFO: u8, // < UART FIFO Control Register, offset: 0x11
SFIFO: u8, // < UART FIFO Status Register, offset: 0x12
TWFIFO: u8, // < UART FIFO Transmit Watermark, offset: 0x13
TCFIFO: u8, // < UART FIFO Transmit Count, offset: 0x14
RWFIFO: u8, // < UART FIFO Receive Watermark, offset: 0x15
RCFIFO: u8, // < UART FIFO Receive Count, offset: 0x16
RESERVED_1: u8,
C7816: u8, // < UART 7816 Control Register, offset: 0x18
IE7816: u8, // < UART 7816 Interrupt Enable Register, offset: 0x19
IS7816: u8, // < UART 7816 Interrupt Status Register, offset: 0x1A
WP7816_type: u8,
WN7816: u8, // < UART 7816 Wait N Register, offset: 0x1C
WF7816: u8, // < UART 7816 Wait FD Register, offset: 0x1D
ET7816: u8, // < UART 7816 Error Threshold Register, offset: 0x1E
TL7816: u8, // < UART 7816 Transmit Length Register, offset: 0x1F
};
pub const SystemStruct = struct {
Options1: *volatile u32 = @intToPtr(*volatile u32, 0x40047000), // SIM_SOPT1
Options1ConfigurationRegister: *volatile u32 = @intToPtr(*volatile u32, 0x40047004), // SIM_SOPT1CFG
Options2: *volatile u32 = @intToPtr(*volatile u32, 0x40048004), // SIM_SOPT2
Options4: *volatile u32 = @intToPtr(*volatile u32, 0x4004800C), // SIM_SOPT4
Options5: *volatile u32 = @intToPtr(*volatile u32, 0x40048010), // SIM_SOPT5
Options7: *volatile u32 = @intToPtr(*volatile u32, 0x40048018), // SIM_SOPT7
DeviceIdentification: *volatile u32 = @intToPtr(*volatile u32, 0x40048024), // SIM_SDID
ClockGating1: *volatile u32 = @intToPtr(*volatile u32, 0x40048028), // SIM_SCGC1
ClockGating2: *volatile u32 = @intToPtr(*volatile u32, 0x4004802C), // SIM_SCGC2
ClockGating3: *volatile u32 = @intToPtr(*volatile u32, 0x40048030), // SIM_SCGC3
ClockGating4: *volatile u32 = @intToPtr(*volatile u32, 0x40048034), // SIM_SCGC4
ClockGating5: *volatile u32 = @intToPtr(*volatile u32, 0x40048038), // SIM_SCGC5
ClockGating6: *volatile u32 = @intToPtr(*volatile u32, 0x4004803C), // SIM_SCGC6
ClockGating7: *volatile u32 = @intToPtr(*volatile u32, 0x40048040), // SIM_SCGC7
ClockDevider1: *volatile u32 = @intToPtr(*volatile u32, 0x40048044), // SIM_CLKDIV1
ClockDevider2: *volatile u32 = @intToPtr(*volatile u32, 0x40048048), // SIM_CLKDIV2
FlashConfiguration1: *volatile u32 = @intToPtr(*volatile u32, 0x4004804C), // SIM_FCFG1
FlashConfiguration2: *volatile u32 = @intToPtr(*volatile u32, 0x40048050), // SIM_FCFG2
UniqueIdentificationHigh: *volatile u32 = @intToPtr(*volatile u32, 0x40048054), // SIM_UIDH
UniqueIdentificationMidHigh: *volatile u32 = @intToPtr(*volatile u32, 0x40048058), // SIM_UIDMH
UniqueIdentificationMidLow: *volatile u32 = @intToPtr(*volatile u32, 0x4004805C), // SIM_UIDML
UniqueIdentificationLow: *volatile u32 = @intToPtr(*volatile u32, 0x40048060), // SIM_UIDL
};
const MultiPurposeClockGenerator = struct {
control1: u8, // MCG_C1
control2: u8, // MCG_C2
control3: u8, // MCG_C3
control4: u8, // MCG_C4
control5: u8, // MCG_C5
control6: u8, // MCG_C6
status: u8, // MCG_S
reserved0: u8,
statusAndControl: u8, // MCG_SC
reserved1: u8,
autoTrimCompareValueHigh: u8, // MCG_ATCVH
autoTrimCompareValueLow: u8, // MCG_ATCVL
control7: u8, // MCG_C7
control8: u8, // MCG_C8
};
const PowerStruct = struct {
modeProtection: u8, // SMC_PMPROT
modeControl: u8, // SMC_PMCTRL
vllsControl: u8, // SMC_VLLSCTRL
modeStatus: u8, // SMC_PMSTAT
};
const WatchdogStruct = struct {
statusAndControlHigh: u16, // WDOG_STCTRLH
statusAndControlLow: u16, // WDOG_STCTRLL
timeoutValueHigh: u16, // WDOG_TOVALH
timeoutValueLow: u16, // WDOG_TOVALL
windowRegisterHigh: u16, // WDOG_WINH
windowRegisterLow: u16, // WDOG_WINL
refresh: u16, // WDOG_REFRESH
unlock: u16, // WDOG_UNLOCK
timerOutputHigh: u16, // WDOG_TMROUTH
timerOutputLow: u16, // WDOG_TMROUTL
resetCount: u16, // WDOG_RSTCNT
prescaler: u16, // WDOG_PRESC
};
pub const SysTick_MemMap = struct {
CSR: u32, // < SysTick Control and Status Register, offset: 0x0
RVR: u32, // < SysTick Reload Value Register, offset: 0x4
CVR: u32, // < SysTick Current Value Register, offset: 0x8
CALIB: u32, // < SysTick Calibration Value Register, offset: 0xC
};
pub var PortA align(32) = @intToPtr(*volatile Port, 0x40049000);
pub var PortB align(32) = @intToPtr(*volatile Port, 0x4004A000);
pub var PortC align(32) = @intToPtr(*volatile Port, 0x4004B000);
pub var PortD align(32) = @intToPtr(*volatile Port, 0x4004C000);
pub var PortE align(32) = @intToPtr(*volatile Port, 0x4004D000);
pub var GpioA align(32) = @intToPtr(*volatile Gpio, 0x400FF000);
pub var GpioB align(32) = @intToPtr(*volatile Gpio, 0x400FF040);
pub var GpioC align(32) = @intToPtr(*volatile Gpio, 0x400FF080);
pub var GpioD align(32) = @intToPtr(*volatile Gpio, 0x400FF0C0);
pub var GpioE align(32) = @intToPtr(*volatile Gpio, 0x400FF100);
pub var System = SystemStruct{};
pub var Uart0 = @intToPtr(*volatile UartMemMap, 0x4006A000);
pub var Uart1 = @intToPtr(*volatile UartMemMap, 0x4006B000);
pub var Uart2 = @intToPtr(*volatile UartMemMap, 0x4006C000);
pub var OscillatorControl = @intToPtr(*volatile u8, 0x40065000);
pub var ClockGenerator = @intToPtr(*volatile MultiPurposeClockGenerator, 0x40064000);
pub var RegolatorStatusAndControl = @intToPtr(*volatile u8, 0x4007D002); // PMC_REGSC
pub var Power = @intToPtr(*volatile PowerStruct, 0x4007E000);
pub var Watchdog = @intToPtr(*volatile WatchdogStruct, 0x40052000);
pub var SystemControl = @intToPtr(*volatile SystemControl_MemMap, 0xE000E000);
pub var SysTick = @intToPtr(*volatile SysTick_MemMap, 0xE000E010);
pub fn port_pcr_mux(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, PORT_PCR_MUX_SHIFT, PORT_PCR_MUX_MASK);
}
pub fn uart_bdh_sbr(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, UART_BDH_SBR_SHIFT, UART_BDH_SBR_MASK);
}
pub fn uart_bdl_sbr(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, UART_BDL_SBR_SHIFT, UART_BDL_SBR_MASK);
}
pub fn uart_c4_brfa(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, UART_C4_BRFA_SHIFT, UART_C4_BRFA_MASK);
}
pub fn mcg_c2_range0(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C2_RANGE0_SHIFT, MCG_C2_RANGE0_MASK);
}
pub fn mcg_c1_frdiv(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C1_FRDIV_SHIFT, MCG_C1_FRDIV_MASK);
}
pub fn mcg_c1_clks(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C1_CLKS_SHIFT, MCG_C1_CLKS_MASK);
}
pub fn mcg_s_clkst(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_S_CLKST_SHIFT, MCG_S_CLKST_MASK);
}
pub fn mcg_c3_sctrim(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C3_SCTRIM_SHIFT, MCG_C3_SCTRIM_MASK);
}
pub fn mcg_c4_fctrim(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C4_FCTRIM_SHIFT, MCG_C4_FCTRIM_MASK);
}
pub fn mcg_c4_drst_drs(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C4_DRST_DRS_SHI, MCG_C4_DRST_DRS_MASKFT);
}
pub fn mcg_c5_prdiv0(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C5_PRDIV0_SHIFT, MCG_C5_PRDIV0_MASK);
}
pub fn mcg_c6_vdiv0(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, MCG_C6_VDIV0_SHIFT, MCG_C6_VDIV0_MASK);
}
pub fn sim_clkdiv1_outdiv4(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_CLKDIV1_OUTDIV4_SHIFT, SIM_CLKDIV1_OUTDIV4_MASK);
}
pub fn sim_clkdiv1_outdiv3(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_CLKDIV1_OUTDIV3_SHIFT, SIM_CLKDIV1_OUTDIV3_MASK);
}
pub fn sim_clkdiv1_outdiv2(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_CLKDIV1_OUTDIV2_SHIFT, SIM_CLKDIV1_OUTDIV2_MASK);
}
pub fn sim_clkdiv1_outdiv1(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_CLKDIV1_OUTDIV1_SHIFT, SIM_CLKDIV1_OUTDIV1_MASK);
}
pub fn sim_clkdiv2_usbdiv(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_CLKDIV2_USBDIV_SHIFT, SIM_CLKDIV2_USBDIV_MASK);
}
pub fn sim_fcfg1_depart(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG1_DEPART_SHIFT, SIM_FCFG1_DEPART_MASK);
}
pub fn sim_fcfg1_eesize(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG1_EESIZE_SHIFT, SIM_FCFG1_EESIZE_MASK);
}
pub fn sim_fcfg1_pfsize(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG1_PFSIZE_SHIFT, SIM_FCFG1_PFSIZE_MASK);
}
pub fn sim_fcfg1_nvmsize(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG1_NVMSIZE_SHIFT, SIM_FCFG1_NVMSIZE_MASK);
}
pub fn sim_fcfg2_maxaddr1(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG2_MAXADDR1_SHIFT, SIM_FCFG2_MAXADDR1_MASK);
}
pub fn sim_fcfg2_maxaddr0(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_FCFG2_MAXADDR0_SHIFT, SIM_FCFG2_MAXADDR0_MASK);
}
pub fn sim_uidh_uid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_UIDH_UID_SHIFT, SIM_UIDH_UID_MASK);
}
pub fn sim_uidmh_uid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_UIDMH_UID_SHIFT, SIM_UIDMH_UID_MASK);
}
pub fn sim_uidml_uid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_UIDML_UID_SHIFT, SIM_UIDML_UID_MASK);
}
pub fn sim_uidl_uid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_UIDL_UID_SHIFT, SIM_UIDL_UID_MASK);
}
pub fn sim_sopt1_ramsize(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT1_RAMSIZE_SHIFT, SIM_SOPT1_RAMSIZE_MASK);
}
pub fn sim_sopt1_osc32ksel(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT1_OSC32KSEL_SHIFT, SIM_SOPT1_OSC32KSEL_MASK);
}
pub fn sim_sopt2_clkoutsel(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT2_CLKOUTSEL_SHIFT, SIM_SOPT2_CLKOUTSEL_MASK);
}
pub fn sim_sopt2_fbsl(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT2_FBSL_SHIFT, SIM_SOPT2_FBSL_MASK);
}
pub fn sim_sopt5_uart0txsrc(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT5_UART0TXSRC_SHIFT, SIM_SOPT5_UART0TXSRC_MASK);
}
pub fn sim_sopt5_uart0rxsrc(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT5_UART0RXSRC_SHIFT, SIM_SOPT5_UART0RXSRC_MASK);
}
pub fn sim_sopt5_uart1txsrc(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT5_UART1TXSRC_SHIFT, SIM_SOPT5_UART1TXSRC_MASK);
}
pub fn sim_sopt5_uart1rxsrc(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT5_UART1RXSRC_SHIFT, SIM_SOPT5_UART1RXSRC_MASK);
}
pub fn sim_sopt7_adc0trgsel(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT7_ADC0TRGSEL_SHIFT, SIM_SOPT7_ADC0TRGSEL_MASK);
}
pub fn sim_sopt7_adc1trgsel(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT7_ADC1TRGSEL_SHIFT, SIM_SOPT7_ADC1TRGSEL_MASK);
}
pub fn sim_sdid_pinid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SDID_PINID_SHIFT, SIM_SDID_PINID_MASK);
}
pub fn sim_sdid_famid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SDID_FAMID_SHIFT, SIM_SDID_FAMID_MASK);
}
pub fn sim_sdid_revid(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SDID_REVID_SHIFT, SIM_SDID_REVID_MASK);
}
pub fn sim_sopt4_ftm1ch0src(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT4_FTM1CH0SRC_SHIFT, SIM_SOPT4_FTM1CH0SRC_MASK);
}
pub fn sim_sopt4_ftm2ch0src(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SIM_SOPT4_FTM2CH0SRC_SHIFT, SIM_SOPT4_FTM2CH0SRC_MASK);
}
pub fn systick_rvr_reload(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SysTick_RVR_RELOAD_SHIFT, SysTick_RVR_RELOAD_MASK);
}
pub fn systick_cvr_current(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SysTick_CVR_CURRENT_SHIFT, SysTick_CVR_CURRENT_MASK);
}
pub fn systick_calib_tenms(comptime x: comptime_int) comptime_int {
return left_shift_and_mask(x, SysTick_CALIB_TENMS_SHIFT, SysTick_CALIB_TENMS_MASK);
}
fn left_shift_and_mask(comptime x: comptime_int, comptime shift: u5, comptime mask: u32) comptime_int {
return (x << shift) & mask;
}
pub inline fn nop() void {
asm volatile ("nop");
}
test "PCR" {
const expectEqual = @import("std").testing.expectEqual;
var port align(32) = @intToPtr(*volatile Port, 0x40049000);
expectEqual(@as(usize, 0x40049000), @ptrToInt(&port.controlRegister[0]));
expectEqual(@as(usize, 0x40049004), @ptrToInt(&port.controlRegister[1]));
expectEqual(@as(usize, 0x40049008), @ptrToInt(&port.controlRegister[2]));
expectEqual(@as(usize, 0x4004900C), @ptrToInt(&port.controlRegister[3]));
expectEqual(@as(usize, 0x40049010), @ptrToInt(&port.controlRegister[4]));
expectEqual(@as(usize, 0x40049014), @ptrToInt(&port.controlRegister[5]));
expectEqual(@as(usize, 0x40049018), @ptrToInt(&port.controlRegister[6]));
expectEqual(@as(usize, 0x4004901C), @ptrToInt(&port.controlRegister[7]));
expectEqual(@as(usize, 0x40049020), @ptrToInt(&port.controlRegister[8]));
expectEqual(@as(usize, 0x40049024), @ptrToInt(&port.controlRegister[9]));
expectEqual(@as(usize, 0x40049028), @ptrToInt(&port.controlRegister[10]));
expectEqual(@as(usize, 0x4004902C), @ptrToInt(&port.controlRegister[11]));
expectEqual(@as(usize, 0x40049030), @ptrToInt(&port.controlRegister[12]));
expectEqual(@as(usize, 0x40049034), @ptrToInt(&port.controlRegister[13]));
expectEqual(@as(usize, 0x40049038), @ptrToInt(&port.controlRegister[14]));
expectEqual(@as(usize, 0x4004903C), @ptrToInt(&port.controlRegister[15]));
expectEqual(@as(usize, 0x40049040), @ptrToInt(&port.controlRegister[16]));
expectEqual(@as(usize, 0x40049044), @ptrToInt(&port.controlRegister[17]));
expectEqual(@as(usize, 0x40049048), @ptrToInt(&port.controlRegister[18]));
expectEqual(@as(usize, 0x4004904C), @ptrToInt(&port.controlRegister[19]));
expectEqual(@as(usize, 0x40049050), @ptrToInt(&port.controlRegister[20]));
expectEqual(@as(usize, 0x40049054), @ptrToInt(&port.controlRegister[21]));
expectEqual(@as(usize, 0x40049058), @ptrToInt(&port.controlRegister[22]));
expectEqual(@as(usize, 0x4004905C), @ptrToInt(&port.controlRegister[23]));
expectEqual(@as(usize, 0x40049060), @ptrToInt(&port.controlRegister[24]));
expectEqual(@as(usize, 0x40049064), @ptrToInt(&port.controlRegister[25]));
expectEqual(@as(usize, 0x40049068), @ptrToInt(&port.controlRegister[26]));
expectEqual(@as(usize, 0x4004906C), @ptrToInt(&port.controlRegister[27]));
expectEqual(@as(usize, 0x40049070), @ptrToInt(&port.controlRegister[28]));
expectEqual(@as(usize, 0x40049074), @ptrToInt(&port.controlRegister[29]));
expectEqual(@as(usize, 0x40049078), @ptrToInt(&port.controlRegister[30]));
expectEqual(@as(usize, 0x4004907C), @ptrToInt(&port.controlRegister[31]));
expectEqual(@as(usize, 0x40049080), @ptrToInt(&port.gpclr));
expectEqual(@as(usize, 0x40049084), @ptrToInt(&port.gpchr));
expectEqual(@as(usize, 0x400490A0), @ptrToInt(&port.isfr));
}
test "Gpio" {
const expectEqual = @import("std").testing.expectEqual;
var gpio align(32) = @intToPtr(*volatile Gpio, 0x400FF000);
expectEqual(@as(usize, 0x400FF000), @ptrToInt(&gpio.dataOutput));
expectEqual(@as(usize, 0x400FF004), @ptrToInt(&gpio.setOutput));
expectEqual(@as(usize, 0x400FF008), @ptrToInt(&gpio.clearOutput));
expectEqual(@as(usize, 0x400FF00C), @ptrToInt(&gpio.toggleOutput));
expectEqual(@as(usize, 0x400FF010), @ptrToInt(&gpio.dataInput));
expectEqual(@as(usize, 0x400FF014), @ptrToInt(&gpio.dataDirection));
} | src/teensy3_2/mk20dx256.zig |
const std = @import("std");
const platform = @import("../platform.zig");
const time = std.time;
const vfs = @import("../vfs.zig");
const util = @import("../util.zig");
const RefCount = util.RefCount;
const File = vfs.File;
const Node = vfs.Node;
const c = @cImport({
@cInclude("miniz/miniz.h");
});
/// Support for mounting .zip files as a filesystem. DIRECTORY ENTRIES ARE REQUIRED in the .zip file.
// These **MUST** be inlined.
inline fn myFsImpl(self: *Node) *FsImpl {
return self.file_system.?.cookie.?.as(FsImpl);
}
inline fn myImpl(self: *Node) *NodeImpl {
return self.cookie.?.as(NodeImpl);
}
const NodeImpl = struct {
const ops: Node.Ops = .{
.open = NodeImpl.open,
.close = NodeImpl.close,
.read = NodeImpl.read,
.find = NodeImpl.find,
.readDir = NodeImpl.readDir,
.unlink_me = NodeImpl.unlink_me,
};
miniz_stat: c.mz_zip_archive_file_stat = undefined,
data: ?[]u8 = null,
fn minizToVfsStat(in: c.mz_zip_archive_file_stat) Node.Stat {
return .{
.inode = in.m_file_index + 2,
.blocks = in.m_comp_size,
.size = in.m_uncomp_size,
.type = if (in.m_is_directory != 0) .directory else .file,
.modify_time = @truncate(i64, in.m_time) * time.ns_per_s,
.access_time = @truncate(i64, in.m_time) * time.ns_per_s,
.create_time = @truncate(i64, in.m_time) * time.ns_per_s,
.mode = Node.Mode.all,
};
}
fn lazyExtract(self: *Node) !void {
var node_impl = myImpl(self);
var fs_impl = myFsImpl(self);
if (node_impl.miniz_stat.m_is_directory != 0) return vfs.Error.NotFile;
if (node_impl.data != null) return;
node_impl.data = try self.file_system.?.allocator.alloc(u8, node_impl.miniz_stat.m_uncomp_size);
var mz_ok = c.mz_zip_reader_extract_to_mem(&fs_impl.archive, node_impl.miniz_stat.m_file_index, node_impl.data.?.ptr, node_impl.data.?.len, 0);
if (mz_ok == 0) return vfs.Error.ReadFailed;
}
pub fn init(file_system: *vfs.FileSystem, index: u32, preinit_stat: ?c.mz_zip_archive_file_stat) !*Node {
var fs_impl = file_system.cookie.?.as(FsImpl);
if (fs_impl.opened.get(index)) |existing_node| {
return existing_node;
}
var node_impl = try file_system.allocator.create(NodeImpl);
errdefer file_system.allocator.destroy(node_impl);
node_impl.* = .{};
if (preinit_stat) |preinit_stat_inner| {
node_impl.miniz_stat = preinit_stat_inner;
} else {
var mz_ok = c.mz_zip_reader_file_stat(&fs_impl.archive, @truncate(c.mz_uint, index), &node_impl.miniz_stat);
if (mz_ok == 0) return vfs.Error.ReadFailed;
}
var initial_stat = NodeImpl.minizToVfsStat(node_impl.miniz_stat);
var node = try file_system.allocator.create(Node);
errdefer file_system.allocator.destroy(node);
node.* = Node.init(NodeImpl.ops, util.asCookie(node_impl), initial_stat, file_system);
try fs_impl.opened.putNoClobber(node_impl.miniz_stat.m_file_index, node);
return node;
}
pub fn open(self: *Node) !void {
// Do nothing, as there is nothing to do.
}
pub fn close(self: *Node) !void {
var node_impl = myImpl(self);
if (self.opens.refs == 0) {
if (node_impl.data != null) self.file_system.?.allocator.free(node_impl.data.?);
if (!self.stat.flags.mount_point) _ = myFsImpl(self).opened.remove(node_impl.miniz_stat.m_file_index);
self.file_system.?.allocator.destroy(node_impl);
self.file_system.?.allocator.destroy(self);
}
}
pub fn read(self: *Node, offset: u64, buffer: []u8) !usize {
if (self.stat.type == .directory) return vfs.Error.NotFile;
try lazyExtract(self);
var my_data = myImpl(self).data.?;
var trueOff = @truncate(usize, offset);
var trueEnd = if (trueOff + buffer.len > self.stat.size) self.stat.size else trueOff + buffer.len;
std.mem.copy(u8, buffer, my_data[trueOff..trueEnd]);
return trueEnd - trueOff;
}
pub fn find(self: *Node, path: []const u8) !File {
var node_impl = myImpl(self);
var fs_impl = myFsImpl(self);
if (self.stat.type != .directory) return vfs.Error.NotDirectory;
var index: u32 = undefined;
if (!self.stat.flags.mount_point) {
var my_path_raw: [1024]u8 = undefined;
// Important note! my_path_len includes the null-terminator in its length calculations!
var my_path_len = c.mz_zip_reader_get_filename(&fs_impl.archive, node_impl.miniz_stat.m_file_index, &my_path_raw, 1024);
if (my_path_len == 0) return vfs.Error.ReadFailed;
var my_path = my_path_raw[0 .. my_path_len - 1];
var full_path_raw: [1024]u8 = undefined;
var full_path = try std.fmt.bufPrint(full_path_raw[0..], "{}{}", .{ my_path, path });
full_path_raw[full_path.len] = 0;
var mz_ok = c.mz_zip_reader_locate_file_v2(&fs_impl.archive, full_path.ptr, null, 0, &index);
if (mz_ok == 0) {
full_path = try std.fmt.bufPrint(full_path_raw[0..], "{}{}/", .{ my_path, path });
full_path_raw[full_path.len] = 0;
mz_ok = c.mz_zip_reader_locate_file_v2(&fs_impl.archive, full_path.ptr, null, 0, &index);
}
if (mz_ok == 0) return vfs.Error.NoSuchFile;
} else {
var full_path_raw: [1024]u8 = undefined;
var full_path: []u8 = full_path_raw[0..path.len];
std.mem.copy(u8, full_path, path);
full_path_raw[full_path.len] = 0;
var mz_ok = c.mz_zip_reader_locate_file_v2(&fs_impl.archive, full_path.ptr, null, 0, &index);
if (mz_ok == 0) {
full_path = full_path_raw[0 .. path.len + 1];
full_path_raw[full_path.len - 1] = '/';
full_path_raw[full_path.len] = 0;
mz_ok = c.mz_zip_reader_locate_file_v2(&fs_impl.archive, full_path.ptr, null, 0, &index);
}
if (mz_ok == 0) return vfs.Error.NoSuchFile;
}
var node = try NodeImpl.init(self.file_system.?, index, null);
try node.open();
var file: File = undefined;
std.mem.copy(u8, file.name_buf[0..], path);
file.name_len = path.len;
file.node = node;
return file;
}
pub fn readDir(self: *Node, offset: u64, files: []File) !usize {
if (self.stat.type != .directory) return vfs.Error.NotDirectory;
var node_impl = myImpl(self);
var fs_impl = myFsImpl(self);
var my_path_raw: [1024]u8 = undefined;
var my_path: []const u8 = "";
if (!self.stat.flags.mount_point) {
var my_path_len = c.mz_zip_reader_get_filename(&fs_impl.archive, node_impl.miniz_stat.m_file_index, &my_path_raw, 1024);
if (my_path_len == 0) return vfs.Error.ReadFailed;
my_path = my_path_raw[0 .. my_path_len - 1];
}
var true_index: usize = 0;
var total_index = @truncate(usize, offset);
while (total_index < fs_impl.archive.m_total_files and true_index < files.len) {
var file_info: c.mz_zip_archive_file_stat = undefined;
var mz_ok = c.mz_zip_reader_file_stat(&fs_impl.archive, @truncate(c.mz_uint, total_index), &file_info);
if (mz_ok == 0) return vfs.Error.ReadFailed;
var path_slice: []u8 = std.mem.spanZ(@ptrCast([*c]u8, file_info.m_filename[0..]));
if (std.mem.eql(u8, my_path, path_slice)) {
total_index += 1;
continue;
}
if (my_path.len > 0 and !std.mem.startsWith(u8, path_slice, my_path)) {
total_index += 1;
continue;
}
path_slice = path_slice[my_path.len..];
if (std.mem.endsWith(u8, path_slice, "/")) {
path_slice = path_slice[0 .. path_slice.len - 1];
}
if (std.mem.indexOf(u8, path_slice, "/") != null) {
total_index += 1;
continue;
}
var file: File = undefined;
std.mem.copy(u8, file.name_buf[0..], path_slice[my_path.len..]);
file.name_len = path_slice.len - my_path.len;
files[true_index] = file;
true_index += 1;
total_index += 1;
}
return true_index;
}
pub fn unlink_me(self: *Node) !void {
// There's nothing worth doing here.
}
};
const FsImpl = struct {
const OpenedCache = std.AutoHashMap(u32, *Node);
const ops: vfs.FileSystem.Ops = .{
.mount = FsImpl.mount,
.unmount = FsImpl.unmount,
};
zip_data: []u8 = undefined,
archive: c.mz_zip_archive = undefined,
opened: FsImpl.OpenedCache = undefined,
pub fn mount(self: *vfs.FileSystem, zipfile: ?*Node, args: ?[]const u8) anyerror!*Node {
if (zipfile == null) return vfs.Error.NoSuchFile;
var fs_impl = try self.allocator.create(FsImpl);
errdefer self.allocator.destroy(fs_impl);
// TODO: take advantage of read/write/etc callbacks
// TODO: take advantage of memory allocation callbacks
fs_impl.* = .{};
fs_impl.zip_data = try self.allocator.alloc(u8, zipfile.?.stat.size);
errdefer self.allocator.free(fs_impl.zip_data);
var amount = try zipfile.?.read(0, fs_impl.zip_data);
if (amount != zipfile.?.stat.size) return vfs.Error.ReadFailed;
c.mz_zip_zero_struct(&fs_impl.archive);
var mz_ok = c.mz_zip_reader_init_mem(&fs_impl.archive, fs_impl.zip_data.ptr, fs_impl.zip_data.len, 0);
if (mz_ok == 0) return vfs.Error.NoSuchFile;
fs_impl.opened = FsImpl.OpenedCache.init(self.allocator);
errdefer fs_impl.opened.deinit();
self.cookie = util.asCookie(fs_impl);
var root_node_impl = try self.allocator.create(NodeImpl);
errdefer self.allocator.destroy(root_node_impl);
var now = platform.getTimeNano();
var root_node_stat = Node.Stat{
.flags = .{ .mount_point = true },
.inode = 1,
.type = .directory,
.mode = Node.Mode.all,
.modify_time = now,
.create_time = now,
.access_time = now,
};
var root_node = try self.allocator.create(Node);
errdefer self.allocator.destroy(root_node);
root_node.* = Node.init(NodeImpl.ops, util.asCookie(root_node_impl), root_node_stat, self);
return root_node;
}
pub fn unmount(self: *vfs.FileSystem) void {
var fs_impl = self.cookie.?.as(FsImpl);
_ = c.mz_zip_reader_end(&fs_impl.archive);
}
};
pub const Fs = vfs.FileSystem.init("zipfs", FsImpl.ops); | kernel/fs/zipfs.zig |
const std = @import("std");
const c = @import("internal/c.zig");
const internal = @import("internal/internal.zig");
const log = std.log.scoped(.git);
const git = @import("git.zig");
pub const Blame = opaque {
pub fn deinit(self: *Blame) void {
log.debug("Blame.deinit called", .{});
c.git_blame_free(@ptrCast(*c.git_blame, self));
log.debug("blame freed successfully", .{});
}
pub fn hunkCount(self: *Blame) u32 {
log.debug("Blame.hunkCount called", .{});
const ret = c.git_blame_get_hunk_count(@ptrCast(*c.git_blame, self));
log.debug("blame hunk count: {}", .{ret});
return ret;
}
pub fn hunkByIndex(self: *Blame, index: u32) ?*const BlameHunk {
log.debug("Blame.hunkByIndex called, index: {}", .{index});
return @ptrCast(
?*const git.BlameHunk,
c.git_blame_get_hunk_byindex(@ptrCast(*c.git_blame, self), index),
);
}
pub fn hunkByLine(self: *Blame, line: usize) ?*const BlameHunk {
log.debug("Blame.hunkByLine called, line: {}", .{line});
return @ptrCast(
?*const git.BlameHunk,
c.git_blame_get_hunk_byline(@ptrCast(*c.git_blame, self), line),
);
}
/// Get blame data for a file that has been modified in memory. The `reference` parameter is a pre-calculated blame for the
/// in-odb history of the file. This means that once a file blame is completed (which can be expensive), updating the buffer
/// blame is very fast.
///
/// Lines that differ between the buffer and the committed version are marked as having a zero OID for their final_commit_id.
pub fn blameBuffer(self: *Blame, buffer: [:0]const u8) !*git.Blame {
log.debug("Blame.blameBuffer called, buffer: {s}", .{buffer});
var blame: *git.Blame = undefined;
try internal.wrapCall("git_blame_buffer", .{
@ptrCast(*?*c.git_blame, &blame),
@ptrCast(*c.git_blame, self),
buffer.ptr,
buffer.len,
});
log.debug("successfully fetched blame buffer", .{});
return blame;
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const BlameHunk = extern struct {
/// The number of lines in this hunk.
lines_in_hunk: usize,
/// The OID of the commit where this line was last changed.
final_commit_id: git.Oid,
/// The 1-based line number where this hunk begins, in the final version
/// of the file.
final_start_line_number: usize,
/// The author of `final_commit_id`. If `use_mailmap` has been
/// specified, it will contain the canonical real name and email address.
final_signature: *git.Signature,
/// The OID of the commit where this hunk was found.
/// This will usually be the same as `final_commit_id`, except when
/// `any_commit_copies` has been specified.
orig_commit_id: git.Oid,
/// The path to the file where this hunk originated, as of the commit
/// specified by `orig_commit_id`.
/// Use `origPath`
z_orig_path: [*:0]const u8,
/// The 1-based line number where this hunk begins in the file named by
/// `orig_path` in the commit specified by `orig_commit_id`.
orig_start_line_number: usize,
/// The author of `orig_commit_id`. If `use_mailmap` has been
/// specified, it will contain the canonical real name and email address.
orig_signature: *git.Signature,
/// The 1 iff the hunk has been tracked to a boundary commit (the root,
/// or the commit specified in git_blame_options.oldest_commit)
boundary: u8,
pub fn origPath(self: BlameHunk) [:0]const u8 {
return std.mem.sliceTo(self.z_orig_path, 0);
}
test {
try std.testing.expectEqual(@sizeOf(c.git_blame_hunk), @sizeOf(BlameHunk));
try std.testing.expectEqual(@bitSizeOf(c.git_blame_hunk), @bitSizeOf(BlameHunk));
}
comptime {
std.testing.refAllDecls(@This());
}
};
pub const BlameOptions = struct {
flags: BlameFlags = .{},
/// The lower bound on the number of alphanumeric characters that must be detected as moving/copying within a file for it
/// to associate those lines with the parent commit. The default value is 20.
///
/// This value only takes effect if any of the `BlameFlags.track_copies_*` flags are specified.
min_match_characters: u16 = 0,
/// The id of the newest commit to consider. The default is HEAD.
newest_commit: git.Oid = git.Oid.zero,
/// The id of the oldest commit to consider. The default is the first commit encountered with a `null` parent.
oldest_commit: git.Oid = git.Oid.zero,
/// The first line in the file to blame. The default is 1 (line numbers start with 1).
min_line: usize = 0,
/// The last line in the file to blame. The default is the last line of the file.
max_line: usize = 0,
pub const BlameFlags = packed struct {
normal: bool = false,
/// Track lines that have moved within a file (like `git blame -M`).
///
/// This is not yet implemented and reserved for future use.
track_copies_same_file: bool = false,
/// Track lines that have moved across files in the same commit (like `git blame -C`).
///
/// This is not yet implemented and reserved for future use.
track_copies_same_commit_moves: bool = false,
/// Track lines that have been copied from another file that exists in the same commit (like `git blame -CC`).
/// Implies same_file.
///
/// This is not yet implemented and reserved for future use.
track_copies_same_commit_copies: bool = false,
/// Track lines that have been copied from another file that exists in *any* commit (like `git blame -CCC`). Implies
/// same_commit_copies.
///
/// This is not yet implemented and reserved for future use.
track_copies_any_commit_copies: bool = false,
/// Restrict the search of commits to those reachable following only the first parents.
first_parent: bool = false,
/// Use mailmap file to map author and committer names and email addresses to canonical real names and email
/// addresses. The mailmap will be read from the working directory, or HEAD in a bare repository.
use_mailmap: bool = false,
/// Ignore whitespace differences
ignore_whitespace: bool = false,
z_padding1: u8 = 0,
z_padding2: u16 = 0,
pub fn format(
value: BlameFlags,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
return internal.formatWithoutFields(
value,
options,
writer,
&.{ "z_padding1", "z_padding2" },
);
}
test {
try std.testing.expectEqual(@sizeOf(c.git_blame_flag_t), @sizeOf(BlameFlags));
try std.testing.expectEqual(@bitSizeOf(c.git_blame_flag_t), @bitSizeOf(BlameFlags));
}
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
} | src/blame.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = @import("memory.zig");
pub const cgltf = @import("zcgltf.zig");
pub fn parseAndLoadFile(gltf_path: [:0]const u8) cgltf.Error!*cgltf.Data {
const options = cgltf.Options{
.memory = .{
.alloc = mem.zmeshAllocUser,
.free = mem.zmeshFreeUser,
},
};
const data = try cgltf.parseFile(options, gltf_path);
errdefer cgltf.free(data);
try cgltf.loadBuffers(options, data, gltf_path);
return data;
}
pub fn appendMeshPrimitive(
data: *cgltf.Data,
mesh_index: u32,
prim_index: u32,
indices: *std.ArrayList(u32),
positions: *std.ArrayList([3]f32),
normals: ?*std.ArrayList([3]f32),
texcoords0: ?*std.ArrayList([2]f32),
tangents: ?*std.ArrayList([4]f32),
) !void {
assert(mesh_index < data.meshes_count);
assert(prim_index < data.meshes.?[mesh_index].primitives_count);
const mesh = &data.meshes.?[mesh_index];
const prim = &mesh.primitives[prim_index];
const num_vertices: u32 = @intCast(u32, prim.attributes[0].data.count);
const num_indices: u32 = @intCast(u32, prim.indices.?.count);
// Indices.
{
try indices.ensureTotalCapacity(indices.items.len + num_indices);
const accessor = prim.indices.?;
const buffer_view = accessor.buffer_view.?;
assert(accessor.stride == buffer_view.stride or buffer_view.stride == 0);
assert(accessor.stride * accessor.count == buffer_view.size);
assert(buffer_view.buffer.data != null);
const data_addr = @alignCast(4, @ptrCast([*]const u8, buffer_view.buffer.data) +
accessor.offset + buffer_view.offset);
if (accessor.stride == 1) {
assert(accessor.component_type == .r_8u);
const src = @ptrCast([*]const u8, data_addr);
var i: u32 = 0;
while (i < num_indices) : (i += 1) {
indices.appendAssumeCapacity(src[i]);
}
} else if (accessor.stride == 2) {
assert(accessor.component_type == .r_16u);
const src = @ptrCast([*]const u16, data_addr);
var i: u32 = 0;
while (i < num_indices) : (i += 1) {
indices.appendAssumeCapacity(src[i]);
}
} else if (accessor.stride == 4) {
assert(accessor.component_type == .r_32u);
const src = @ptrCast([*]const u32, data_addr);
var i: u32 = 0;
while (i < num_indices) : (i += 1) {
indices.appendAssumeCapacity(src[i]);
}
} else {
unreachable;
}
}
// Attributes.
{
const attributes = prim.attributes[0..prim.attributes_count];
for (attributes) |attrib| {
const accessor = attrib.data;
assert(accessor.component_type == .r_32f);
const buffer_view = accessor.buffer_view.?;
assert(buffer_view.buffer.data != null);
assert(accessor.stride == buffer_view.stride or buffer_view.stride == 0);
assert(accessor.stride * accessor.count == buffer_view.size);
const data_addr = @ptrCast([*]const u8, buffer_view.buffer.data) +
accessor.offset + buffer_view.offset;
if (attrib.type == .position) {
assert(accessor.type == .vec3);
const slice = @ptrCast([*]const [3]f32, @alignCast(4, data_addr))[0..num_vertices];
try positions.appendSlice(slice);
} else if (attrib.type == .normal) {
if (normals) |n| {
assert(accessor.type == .vec3);
const slice = @ptrCast([*]const [3]f32, @alignCast(4, data_addr))[0..num_vertices];
try n.appendSlice(slice);
}
} else if (attrib.type == .texcoord) {
if (texcoords0) |tc| {
assert(accessor.type == .vec2);
const slice = @ptrCast([*]const [2]f32, @alignCast(4, data_addr))[0..num_vertices];
try tc.appendSlice(slice);
}
} else if (attrib.type == .tangent) {
if (tangents) |tan| {
assert(accessor.type == .vec4);
const slice = @ptrCast([*]const [4]f32, @alignCast(4, data_addr))[0..num_vertices];
try tan.appendSlice(slice);
}
}
}
}
} | modules/graphics/vendored/zmesh/src/io.zig |
const std = @import("std");
const fs = std.fs;
const io = std.io;
const Rom = @import("cart.zig").Cart.Rom;
const Allocator = std.mem.Allocator;
pub const InesError = error{
MissingMagic,
UnexpectedEndOfPrgRom,
UnexpectedEndOfChrRom,
};
pub const Mirroring = enum {
horizontal,
vertical,
four_screen,
};
pub const RomInfo = struct {
prg_rom: ?[]u8,
chr_rom: ?[]u8,
prg_rom_mul_16kb: u8,
prg_ram_mul_8kb: u8,
chr_header_byte: ChrHeaderByte,
has_sram: bool,
mirroring: Mirroring,
has_trainer: bool,
mapper: u8, //TODO: Make enum
const ChrHeaderByte = union(enum) {
uses_chr_ram,
mul_8kb: u8,
};
pub fn deinit(self: RomInfo, allocator: *Allocator) void {
if (self.prg_rom) |prg| {
allocator.free(prg);
}
if (self.chr_rom) |chr| {
allocator.free(chr);
}
}
pub fn readFile(allocator: *Allocator, path: []const u8) !RomInfo {
std.log.info("Loading rom at path \"{s}\"", .{path});
const file = try fs.cwd().openFile(path, .{});
defer file.close();
return RomInfo.readReader(allocator, file.reader());
}
pub fn readReader(allocator: *Allocator, reader: anytype) !RomInfo {
const magic = "NES\x1a";
if (!(try reader.isBytes(magic[0..]))) {
return InesError.MissingMagic;
}
const prg_rom_mul_16kb = try reader.readByte();
const chr_header_byte = blk: {
const byte = try reader.readByte();
if (byte == 0) {
break :blk .uses_chr_ram;
} else {
break :blk RomInfo.ChrHeaderByte{ .mul_8kb = byte };
}
};
const flags6 = try reader.readByte();
const mirroring = blk: {
const bit0 = flags6 & 0b01;
const bit1 = (flags6 >> 2) & 0b10;
break :blk @intToEnum(Mirroring, bit0 | bit1);
};
const has_sram = (flags6 >> 1) & 1 == 1;
const has_trainer = (flags6 >> 2) & 1 == 1;
const flags7 = try reader.readByte();
const mapper = (flags7 & 0xf) | (flags6 >> 4);
const flags8 = try reader.readByte();
const prg_ram_mul_8kb = flags8;
try reader.skipBytes(7 + if (has_trainer) @as(usize, 512) else 0, .{});
const prg_rom_size = @as(usize, prg_rom_mul_16kb) * 1024 * 16;
const prg_rom = try allocator.alloc(u8, prg_rom_size);
errdefer allocator.free(prg_rom);
if ((try reader.readAll(prg_rom)) != prg_rom_size) {
return InesError.UnexpectedEndOfPrgRom;
}
const chr_rom = switch (chr_header_byte) {
.uses_chr_ram => null,
.mul_8kb => |chr_rom_mul_8kb| blk: {
const chr_rom_size = @as(usize, chr_rom_mul_8kb) * 1024 * 8;
const rom = try allocator.alloc(u8, chr_rom_size);
errdefer allocator.free(rom);
if ((try reader.readAll(rom)) != chr_rom_size) {
return InesError.UnexpectedEndOfChrRom;
}
break :blk rom;
},
};
return RomInfo{
.prg_rom = prg_rom,
.chr_rom = chr_rom,
.prg_rom_mul_16kb = prg_rom_mul_16kb,
.prg_ram_mul_8kb = prg_ram_mul_8kb,
.chr_header_byte = chr_header_byte,
.has_sram = has_sram,
.mirroring = mirroring,
.has_trainer = has_trainer,
.mapper = mapper,
};
}
};
const testing = std.testing;
test "Parse INES 1.0" {
const info = try RomInfo.readFile(testing.allocator, "roms/nes-test-roms/other/nestest.nes");
defer info.deinit(testing.allocator);
try testing.expectEqual(@as(u8, 1), info.prg_rom_mul_16kb);
try testing.expectEqual(@as(u8, 0), info.prg_ram_mul_8kb);
try testing.expectEqual(RomInfo.ChrHeaderByte{ .mul_8kb = 1 }, info.chr_header_byte);
try testing.expectEqual(false, info.has_sram);
try testing.expectEqual(Mirroring.horizontal, info.mirroring);
try testing.expectEqual(false, info.has_trainer);
try testing.expectEqual(@as(u8, 0), info.mapper);
} | src/ines.zig |
const std = @import("std");
const utils = @import("utils");
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const sort = std.sort;
const print = utils.print;
const desc_i32 = sort.desc(i32);
const OctupusMap = struct {
width: usize,
height: usize,
energy: []i32,
flashed: []bool,
steps: i32,
};
fn readInput(arena: *ArenaAllocator, lines_it: *utils.FileLineIterator) anyerror!OctupusMap {
var numbers = try std.ArrayList(i32).initCapacity(&arena.allocator, 4096 * 4);
var width: usize = 0;
while (lines_it.next()) |line| {
for (line) |h| {
try numbers.append(@intCast(i32, h - 48));
}
width = line.len;
}
print("File ok :) Number of inputs: {d}", .{numbers.items.len});
var flashed = try arena.allocator.alloc(bool, numbers.items.len);
std.mem.set(bool, flashed, false);
return OctupusMap{
.width = width,
.height = numbers.items.len / width,
.energy = numbers.items,
.flashed = flashed,
.steps = 0,
};
}
fn increaseEnergy(map: *OctupusMap, x: i32, y: i32) void {
if (x < 0 or y < 0 or x >= map.width or y >= map.height) {
return;
}
const offset = @intCast(usize, y) * map.width + @intCast(usize, x);
map.energy[offset] += 1;
}
fn runStep(map: *OctupusMap) i32 {
map.steps += 1;
for (map.energy) |*e| {
e.* += 1;
}
while (true) {
var has_flashed = false;
var y: i32 = 0;
while (y < map.height) : (y += 1) {
var x: i32 = 0;
while (x < map.width) : (x += 1) {
const offset = @intCast(usize, y) * map.width + @intCast(usize, x);
if (map.energy[offset] > 9 and !map.flashed[offset]) {
map.flashed[offset] = true;
increaseEnergy(map, x - 1, y - 1);
increaseEnergy(map, x, y - 1);
increaseEnergy(map, x + 1, y - 1);
increaseEnergy(map, x - 1, y);
increaseEnergy(map, x + 1, y);
increaseEnergy(map, x - 1, y + 1);
increaseEnergy(map, x, y + 1);
increaseEnergy(map, x + 1, y + 1);
has_flashed = true;
}
}
}
if (!has_flashed) {
break;
}
}
var num_flashed: i32 = 0;
for (map.flashed) |flashed, offset| {
if (flashed) {
num_flashed += 1;
map.energy[offset] = 0;
map.flashed[offset] = false;
}
}
return num_flashed;
}
fn part1(map: *OctupusMap) i32 {
var sum: i32 = 0;
var step: i32 = 0;
while (step < 100) : (step += 1) {
sum += runStep(map);
}
return sum;
}
fn part2(map: *OctupusMap) i32 {
while (runStep(map) != @intCast(i32, map.width * map.height)) {}
return map.steps;
}
pub fn main() anyerror!void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var lines_it = try utils.iterateLinesInFile(&arena.allocator, "input.txt");
defer lines_it.deinit();
var input = try readInput(&arena, &lines_it);
const part1_result = part1(&input);
print("Part 1: {d}", .{part1_result});
const part2_result = part2(&input);
print("Part 2: {d}", .{part2_result});
} | day11/src/main.zig |
const std = @import("std");
const log = std.log;
const mem = std.mem;
const os = std.os;
const ScreenWidth = 64;
const ScreenHeight = 32;
const PrgRomAddress = 0x200;
const StackAddress = 0xEA0;
const ScreenAddress = 0xF00;
pub const Chip8 = struct {
Screen: [ScreenHeight][ScreenWidth]u1,
KeyDown: [16]bool,
// Memory Map:
// +---------------+= 0xFFF (4095) End of Chip-8 RAM
// | |
// | |= 0xF00 (3840) Start of screen
// | |= 0xEA0 (3744) Start of stack
// | |
// | |
// | 0x200 to 0xFFF|
// | Chip-8 |
// | Program / Data|
// | Space |
// | |
// | |
// | |
// +- - - - - - - -+= 0x600 (1536) Start of ETI 660 Chip-8 programs
// | |
// | |
// | |
// +---------------+= 0x200 (512) Start of most Chip-8 programs
// | 0x000 to 0x1FF|
// | Reserved for |
// | interpreter |
// +---------------+= 0x000 (0) Start of Chip-8 RAM
RAM: [4096]u8,
// 16 general purpose 8-bit registers
V: [16]u8,
// This register is generally used to store memory addresses, so only the lowest
// (rightmost) 12 bits are usually used.
I: u16,
// Sound timer. Decrements at 60Hz when non-zero.
ST: u8,
// Delay timer. Decrements at 60Hz when non-zero.
DT: u8,
// Program counter
PC: usize,
// Stack pointer
SP: usize,
// When we're waiting for an input key, this is the register that the key gets
// written to.
WaitingForKeyPress: bool,
KeyWaitRegister: usize,
pub fn init(prgRom: []u8) Chip8 {
// Programs may also refer to a group of sprites representing the hexadecimal
// digits 0 through F. These sprites are 5 bytes long, or 8x5 pixels. The data
// should be stored in the interpreter area of Chip-8 memory (0x000 to 0x1FF).
const hex_digits = [_]u8{
0xf0, 0x90, 0x90, 0x90, 0xf0, // 0
0x20, 0x60, 0x20, 0x20, 0x70, // 1
0xf0, 0x10, 0xf0, 0x80, 0xf0, // 2
0xf0, 0x10, 0xf0, 0x10, 0xf0, // 3
0x90, 0x90, 0xf0, 0x10, 0x10, // 4
0xf0, 0x80, 0xf0, 0x10, 0xf0, // 5
0xf0, 0x80, 0xf0, 0x90, 0xf0, // 6
0xf0, 0x10, 0x20, 0x40, 0x40, // 7
0xf0, 0x90, 0xf0, 0x90, 0xf0, // 8
0xf0, 0x90, 0xf0, 0x10, 0xf0, // 9
0xf0, 0x90, 0xf0, 0x90, 0x90, // A
0xe0, 0x90, 0xe0, 0x90, 0xe0, // B
0xf0, 0x80, 0x80, 0x80, 0xf0, // C
0xe0, 0x90, 0x90, 0x90, 0xe0, // D
0xf0, 0x80, 0xf0, 0x80, 0xf0, // E
0xf0, 0x80, 0xf0, 0x80, 0x80, // F
};
var ram: [4096]u8 = undefined;
mem.set(u8, ram[0..], 0);
mem.copy(u8, ram[0..], hex_digits[0..]);
mem.copy(u8, ram[PrgRomAddress..], prgRom[0..]);
var screen: [ScreenHeight][ScreenWidth]u1 = undefined;
for (screen) |*row| {
mem.set(u1, row[0..], 0);
}
var keys: [16]bool = undefined;
mem.set(bool, keys[0..], false);
var v: [16]u8 = undefined;
mem.set(u8, v[0..], 0);
return Chip8{
.Screen = screen,
.KeyDown = keys,
.RAM = ram,
.V = v,
.I = 0,
.ST = 0,
.DT = 0,
.PC = PrgRomAddress,
.SP = 0x0000,
.WaitingForKeyPress = false,
.KeyWaitRegister = 0,
};
}
pub fn step(self: *Chip8) bool {
if (self.WaitingForKeyPress) {
return false;
}
const op1 = self.RAM[self.PC];
const op2 = self.RAM[self.PC + 1];
const opcode = (@intCast(u16, op1) << 8) | @intCast(u16, op2);
const nnn = ((@intCast(u16, op1) & 0x0f) << 8) | @intCast(u16, op2);
var shouldRender = false;
switch (op1 & 0xf0) {
0x00 => {
if (opcode == 0x00e0) {
log.info("{X:0>4} CLS", .{self.PC});
for (self.Screen) |*row| {
mem.set(u1, row[0..], 0);
}
self.PC += 2;
} else if (opcode == 0x00ee) {
// The stack is an array of 16-bit values, used to store the address that the
// interpreter should return to when finished with a subroutine.
self.SP -= 2;
const ret = (@intCast(u16, self.RAM[StackAddress + self.SP + 1]) << 8) | @intCast(u16, self.RAM[StackAddress + self.SP]);
log.info("{X:0>4} RET = {X:0>4}", .{ self.PC, ret });
self.PC = ret;
} else {
log.info("{X:0>4} SYS #{X:0>4}", .{ self.PC, nnn });
self.PC = @intCast(usize, nnn);
}
},
0x10 => {
log.info("{X:0>4} JP #{X:0>4}", .{ self.PC, nnn });
self.PC = @intCast(usize, nnn);
},
0x20 => {
// The stack is an array of 16-bit values, used to store the address that the interpreter
// should return to when finished with a subroutine.
log.info("{X:0>4} CALL #{X:0>4}", .{ self.PC, nnn });
const nextPC = self.PC + 2;
self.RAM[StackAddress + self.SP] = @intCast(u8, nextPC & 0x00ff);
self.RAM[StackAddress + self.SP + 1] = @intCast(u8, (nextPC & 0xff00) >> 8);
self.SP += 2;
self.PC = @intCast(usize, nnn);
},
0x30 => {
const vx = @intCast(usize, op1 & 0x0f);
log.info("{X:0>4} SE V{} ({X:0>4}), #{X:0>2}", .{ self.PC, vx, self.V[vx], op2 });
if (self.V[vx] == op2) {
self.PC += 2;
}
self.PC += 2;
},
0x40 => {
const vx = @intCast(usize, op1 & 0x0f);
log.info("{X:0>4} SNE V{}, #{X:0>2}", .{ self.PC, vx, op2 });
if (self.V[vx] != op2) {
self.PC += 2;
}
self.PC += 2;
},
0x50 => {
const vx = @intCast(usize, op1 & 0x0f);
const vy = @intCast(usize, op2 & 0xf0) >> 4;
log.info("{X:0>4} SE V{}, V{}", .{ self.PC, vx, vy });
if (self.V[vx] == self.V[vy]) {
self.PC += 2;
}
self.PC += 2;
},
0x60 => {
const vx = @intCast(usize, op1 & 0x0f);
log.info("{X:0>4} LD V{}, #{X:0>2}", .{ self.PC, vx, op2 });
self.V[vx] = op2;
self.PC += 2;
},
0x70 => {
const vx = @intCast(usize, op1 & 0x0f);
log.info("{X:0>4} ADD V{}, #{X:0>2}", .{ self.PC, vx, op2 });
const v = @addWithOverflow(u8, self.V[vx], op2, &self.V[vx]);
if (v) {
log.info(" result = {}", .{self.V[vx]});
}
self.PC += 2;
},
0x80 => {
const vx = @intCast(usize, op1 & 0x0f);
const vy = @intCast(usize, op2 & 0xf0) >> 4;
switch (op2 & 0x0f) {
0x00 => {
log.info("{X:0>4} LD V{}, V{}", .{ self.PC, vx, vy });
self.V[vx] = self.V[vy];
},
0x01 => {
log.info("{X:0>4} OR V{}, V{}", .{ self.PC, vx, vy });
self.V[vx] |= self.V[vy];
},
0x02 => {
log.info("{X:0>4} AND V{}, V{}", .{ self.PC, vx, vy });
self.V[vx] &= self.V[vy];
},
0x03 => {
log.info("{X:0>4} XOR V{}, V{}", .{ self.PC, vx, vy });
self.V[vx] ^= self.V[vy];
},
0x04 => {
log.info("{X:0>4} ADD V{}, V{}", .{ self.PC, vx, vy });
const rv = @intCast(u16, self.V[vx]) + @intCast(u16, self.V[vy]);
self.V[vx] = @intCast(u8, rv & 0x00ff);
if (rv > 255) {
self.V[0xF] = 1;
} else {
self.V[0xF] = 0;
}
},
0x05 => {
log.info("{X:0>4} SUB V{}, V{}", .{ self.PC, vx, vy });
if (self.V[vy] > self.V[vx]) {
self.V[0xF] = 0;
} else {
self.V[0xF] = 1;
}
// Subtracting Y from X is the same as adding the two's complement of Y with overflow.
var tmp_vy: u8 = 0;
var v = @addWithOverflow(u8, ~self.V[vy], 1, &tmp_vy);
v = @addWithOverflow(u8, self.V[vx], tmp_vy, &self.V[vx]);
if (v) {
log.info(" result = {}", .{self.V[vx]});
}
},
0x06 => {
log.info("{X:0>4} SHR V{}", .{ self.PC, vx });
self.V[0xF] = self.V[vx] & 0x01;
self.V[vx] >>= 1;
},
0x07 => {
log.info("{X:0>4} SUBN V{}, V{}", .{ self.PC, vx, vy });
if (self.V[vx] > self.V[vy]) {
self.V[0xF] = 0;
} else {
self.V[0xF] = 1;
}
// Subtracting Y from X is the same as adding the two's complement of Y with overflow.
var v = @addWithOverflow(u8, ~self.V[vx], 1, &self.V[vx]);
v = @addWithOverflow(u8, self.V[vy], self.V[vx], &self.V[vx]);
if (v) {
log.info(" result = {}", .{self.V[vx]});
}
},
0x0e => {
log.info("{X:0>4} SHL V{}", .{ self.PC, vx });
self.V[0xF] = (self.V[vx] & 0x80) >> 7;
self.V[vx] <<= 1;
},
else => {},
}
self.PC += 2;
},
0x90 => {
const vx = @intCast(usize, op1 & 0x0f);
const vy = @intCast(usize, op2 & 0xf0) >> 4;
log.info("{X:0>4} SNE V{}, V{}", .{ self.PC, vx, vy });
if (self.V[vx] != self.V[vy]) {
self.PC += 2;
}
self.PC += 2;
},
0xa0 => {
log.info("{X:0>4} LD I, #{X:0>4}", .{ self.PC, nnn });
self.I = nnn;
self.PC += 2;
},
0xb0 => {
log.info("{X:0>4} JP V0, #{X:0>4}", .{ self.PC, nnn });
self.PC = @intCast(u16, self.V[0]) + nnn;
},
0xc0 => {
const vx = @intCast(usize, op1 & 0x0f);
log.info("{X:0>4} RND V{}, #{X:0>2}", .{ self.PC, vx, op2 });
var rnd: [1]u8 = undefined;
os.getrandom(&rnd) catch |err| {
log.info("Unable to getrandom: {s}", .{err});
};
self.V[vx] = rnd[0] & op2;
self.PC += 2;
},
0xd0 => {
const vx = self.V[@intCast(usize, op1 & 0x0f)];
const vy = self.V[@intCast(usize, op2 & 0xf0) >> 4];
const n_rows = @intCast(usize, op2) & 0x0f;
log.info("{X:0>4} DRW V{}, V{}, {X:0>2}", .{ self.PC, vx, vy, n_rows });
self.V[0xF] = 0;
var y: usize = 0;
while (y < n_rows) {
const sprite_row = self.RAM[@intCast(usize, self.I) + y];
const screen_y = (vy + y) % ScreenHeight;
var x: usize = 0;
while (x < 8) {
const val = (sprite_row >> (7 - @intCast(u3, x))) & 1;
const screen_x = (vx + x) % ScreenWidth;
if ((self.Screen[screen_y][screen_x] == 1) and (val == 1)) {
self.V[0xF] |= 1;
}
self.Screen[screen_y][screen_x] ^= @intCast(u1, val);
x += 1;
}
y += 1;
}
shouldRender = true;
self.PC += 2;
},
0xe0 => {
const vx = @intCast(usize, op1 & 0x0f);
const idx = @intCast(usize, self.V[vx]);
switch (op2) {
0x9e => {
log.info("{X:0>4} SKP V{}", .{ self.PC, vx });
if (self.KeyDown[idx]) {
self.PC += 2;
}
self.PC += 2;
},
0xa1 => {
log.info("{X:0>4} SKNP V{}", .{ self.PC, vx });
if (!self.KeyDown[idx]) {
self.PC += 2;
}
self.PC += 2;
},
else => {},
}
},
0xf0 => {
const vx = @intCast(usize, op1 & 0x0f);
switch (op2) {
0x07 => {
log.info("{X:0>4} LD V{}, DT", .{ self.PC, vx });
self.V[vx] = self.DT;
},
0x0a => {
log.info("{X:0>4} LD V{}, K", .{ self.PC, vx });
self.WaitingForKeyPress = true;
self.KeyWaitRegister = vx;
},
0x15 => {
log.info("{X:0>4} LD DT, V{}", .{ self.PC, vx });
self.DT = self.V[vx];
},
0x18 => {
log.info("{X:0>4} LD ST, V{}", .{ self.PC, vx });
self.ST = self.V[vx];
},
0x1e => {
log.info("{X:0>4} ADD I, V{}", .{ self.PC, vx });
self.I += self.V[vx];
},
0x29 => {
log.info("{X:0>4} LD F, V{}", .{ self.PC, vx });
self.I = self.V[vx] * 5;
},
0x33 => {
log.info("{X:0>4} LD B, V{}", .{ self.PC, vx });
const hundreds = self.V[vx] / 100;
self.RAM[self.I] = hundreds;
const tens = (self.V[vx] - (hundreds * 100)) / 10;
self.RAM[self.I + 1] = tens;
const units = self.V[vx] - (hundreds * 100) - (tens * 10);
self.RAM[self.I + 2] = units;
},
0x55 => {
log.info("{X:0>4} LD [I], V{}", .{ self.PC, vx });
var i: usize = 0;
while (i <= vx) {
self.RAM[self.I + i] = self.V[i];
i += 1;
}
},
0x65 => {
log.info("{X:0>4} LD V{}, [I]", .{ self.PC, vx });
var i: usize = 0;
while (i <= vx) {
self.V[i] = self.RAM[self.I + i];
i += 1;
}
},
else => {},
}
self.PC += 2;
},
else => {
log.info("{X:0>4} error 0x{X:0>2}", .{ self.PC, op1 });
},
}
return shouldRender;
}
pub fn keyDown(self: *Chip8, key: usize) void {
self.KeyDown[key] = true;
if (self.WaitingForKeyPress) {
self.WaitingForKeyPress = false;
self.V[self.KeyWaitRegister] = @intCast(u8, key);
}
}
pub fn keyUp(self: *Chip8, key: usize) void {
self.KeyDown[key] = false;
}
pub fn tickTimers(self: *Chip8) void {
if (self.DT > 0) {
self.DT -= 1;
}
if (self.ST > 0) {
self.ST -= 1;
}
}
}; | src/chip8.zig |
const std = @import("std");
const print = @import("std").debug.print;
const PriorityQueue = std.PriorityQueue;
const ArrayList = std.ArrayList;
const test_allocator = std.testing.allocator;
const Point = struct {
x: i32,
y: i32,
distance: u64,
};
fn min_compare(a: Point, b: Point) std.math.Order {
return std.math.order(a.distance, b.distance);
}
pub fn solve(list: ArrayList(ArrayList(u8)), visited: ArrayList(ArrayList(bool))) !u64 {
var cols = list.items[0].items.len;
var rows = list.items.len;
// Ugly Dijkstra's
var distances = ArrayList(ArrayList(u64)).init(test_allocator);
{
var r: usize = 0;
while (r < rows) : (r += 1) {
var c: usize = 0;
var distance_row = ArrayList(u64).init(test_allocator);
while (c < cols) : (c += 1) {
try distance_row.append(999999);
}
try distances.append(distance_row);
}
}
distances.items[0].items[0] = 0;
var pq = PriorityQueue(Point).init(test_allocator, min_compare);
defer pq.deinit();
try pq.add(Point{ .x = 0, .y = 0, .distance = 0 });
while (pq.count() != 0) {
const curr = pq.remove();
var crow = @intCast(usize, curr.y);
var ccol = @intCast(usize, curr.x);
visited.items[crow].items[ccol] = true;
var to_check = std.ArrayList(Point).init(test_allocator);
try to_check.append(Point{ .x = curr.x - 1, .y = curr.y, .distance = 999999 });
try to_check.append(Point{ .x = curr.x + 1, .y = curr.y, .distance = 999999 });
try to_check.append(Point{ .x = curr.x, .y = curr.y - 1, .distance = 999999 });
try to_check.append(Point{ .x = curr.x, .y = curr.y + 1, .distance = 999999 });
for (to_check.items) |point| {
var signed_nrow = point.y;
var signed_ncol = point.x;
if (signed_nrow >= 0 and signed_ncol >= 0 and signed_nrow < rows and signed_ncol < cols) {
var nrow = @intCast(usize, signed_nrow);
var ncol = @intCast(usize, signed_ncol);
var point_distance = distances.items[nrow].items[ncol];
if (!visited.items[nrow].items[ncol]) {
var new_distance: u64 = distances.items[crow].items[ccol] + list.items[ncol].items[nrow];
if (new_distance < point_distance) {
try pq.add(Point{ .x = @intCast(i32, ncol), .y = @intCast(i32, nrow), .distance = new_distance });
distances.items[nrow].items[ncol] = new_distance;
}
}
}
}
}
return distances.items[rows - 1].items[cols - 1];
}
pub fn part_one(f: []const u8) !void {
var file = try std.fs.cwd().openFile(f, .{});
defer file.close();
var buf_reader = std.io.bufferedReader(file.reader());
var in_stream = buf_reader.reader();
var buf: [100]u8 = undefined;
var list = ArrayList(ArrayList(u8)).init(test_allocator);
var visited = ArrayList(ArrayList(bool)).init(test_allocator);
while (try in_stream.readUntilDelimiterOrEof(&buf, '\n')) |line| {
var l = line.len;
var i: u32 = 0;
var row = ArrayList(u8).init(test_allocator);
var visited_row = ArrayList(bool).init(test_allocator);
while (i < l) : (i += 1) {
var ch: []u8 = line[i..(i + 1)];
var value = try std.fmt.parseUnsigned(u8, ch, 10);
try row.append(value);
try visited_row.append(false);
}
try list.append(row);
try visited.append(visited_row);
}
print("Part 1 - Risk: {d}\n", .{solve(list, visited)});
}
pub fn part_two(f: []const u8) !void {
var list = ArrayList(ArrayList(u8)).init(test_allocator);
var visited = ArrayList(ArrayList(bool)).init(test_allocator);
var k: u8 = 0;
while (k < 5) : (k += 1) {
var file = try std.fs.cwd().openFile(f, .{});
var buf_reader = std.io.bufferedReader(file.reader());
var in_stream = buf_reader.reader();
var buf: [100]u8 = undefined;
while (try in_stream.readUntilDelimiterOrEof(&buf, '\n')) |line| {
var l = line.len;
var j: u8 = 0;
var row = ArrayList(u8).init(test_allocator);
var visited_row = ArrayList(bool).init(test_allocator);
while (j < 5) : (j += 1) {
var i: u32 = 0;
while (i < l) : (i += 1) {
var ch: []u8 = line[i..(i + 1)];
var value = (try std.fmt.parseUnsigned(u8, ch, 10)) + j + k;
if (value >= 10) {
try row.append(value - 10 + 1);
} else {
try row.append(value);
}
try visited_row.append(false);
}
}
try list.append(row);
try visited.append(visited_row);
}
file.close();
}
print("Part 2 - Risk: {d}\n", .{solve(list, visited)});
}
pub fn main() !void {
const f = "input.txt";
part_one(f) catch |err| {};
part_two(f) catch |err| {};
} | day_15/day_15.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const MessagePool = @import("message_pool.zig").MessagePool;
const Message = MessagePool.Message;
const vr = @import("vr.zig");
const Header = vr.Header;
const Replica = vr.Replica;
const RingBuffer = @import("ring_buffer.zig").RingBuffer;
const log = std.log.scoped(.message_bus);
const SendQueue = RingBuffer(*Message, config.connection_send_queue_max);
pub const MessageBus = struct {
pub const Address = *Replica;
pool: MessagePool,
configuration: []Address,
send_queues: []SendQueue,
pub fn init(allocator: *mem.Allocator, configuration: []Address) !MessageBus {
const send_queues = try allocator.alloc(SendQueue, configuration.len);
errdefer allocator.free(send_queues);
mem.set(SendQueue, send_queues, .{});
return MessageBus{
.pool = try MessagePool.init(allocator),
.configuration = configuration,
.send_queues = send_queues,
};
}
pub fn tick(self: *MessageBus) void {
self.flush();
}
pub fn get_message(self: *MessageBus) ?*Message {
return self.pool.get_message();
}
pub fn unref(self: *MessageBus, message: *Message) void {
self.pool.unref(message);
}
/// Returns true if the target replica is connected and has space in its send queue.
pub fn can_send_to_replica(self: *MessageBus, replica: u16) bool {
return !self.send_queues[replica].full();
}
pub fn send_header_to_replica(self: *MessageBus, replica: u16, header: Header) void {
assert(header.size == @sizeOf(Header));
if (!self.can_send_to_replica(replica)) {
log.debug("cannot send to replica {}, dropping", .{replica});
return;
}
const message = self.pool.get_header_only_message() orelse {
log.debug("no header only message available, " ++
"dropping message to replica {}", .{replica});
return;
};
defer self.unref(message);
message.header.* = header;
const body = message.buffer[@sizeOf(Header)..message.header.size];
// The order matters here because checksum depends on checksum_body:
message.header.set_checksum_body(body);
message.header.set_checksum();
self.send_message_to_replica(replica, message);
}
pub fn send_message_to_replica(self: *MessageBus, replica: u16, message: *Message) void {
self.send_queues[replica].push(message.ref()) catch |err| switch (err) {
error.NoSpaceLeft => {
self.unref(message);
log.notice("message queue for replica {} full, dropping message", .{replica});
},
};
}
pub fn send_header_to_client(self: *MessageBus, client_id: u128, header: Header) void {
assert(header.size == @sizeOf(Header));
// TODO Do not allocate a message if we know we cannot send to the client.
const message = self.pool.get_header_only_message() orelse {
log.debug("no header only message available, " ++
"dropping message to client {}", .{client_id});
return;
};
defer self.unref(message);
message.header.* = header;
const body = message.buffer[@sizeOf(Header)..message.header.size];
// The order matters here because checksum depends on checksum_body:
message.header.set_checksum_body(body);
message.header.set_checksum();
self.send_message_to_client(client_id, message);
}
/// Try to send the message to the client with the given id.
/// If the client is not currently connected, the message is silently dropped.
pub fn send_message_to_client(self: *MessageBus, client_id: u128, message: *Message) void {
// Do nothing
}
/// Deliver messages to all replicas. Always iterate on a copy to
/// avoid potential infinite loops.
pub fn flush(self: *MessageBus) void {
for (self.send_queues) |*queue, replica| {
var copy = queue.*;
queue.* = .{};
while (copy.pop()) |message| {
self.configuration[replica].on_message(message);
self.unref(message);
}
}
}
};
test "" {
std.testing.refAllDecls(MessageBus);
} | src/test_message_bus.zig |
const std = @import("std");
const example_input = @embedFile("./example_input.txt");
const puzzle_input = @embedFile("./puzzle_input.txt");
pub fn main() !void {
std.debug.print("--- Part One ---\n", .{});
std.debug.print("Result: {d}\n", .{try part1(std.testing.allocator, puzzle_input)});
std.debug.print("--- Part Two ---\n", .{});
std.debug.print("Result: {d}\n", .{try part2(std.testing.allocator, puzzle_input)});
}
fn part1(allocator: std.mem.Allocator, input: []const u8) !usize {
var iter = std.mem.split(u8, input, ",");
var list = std.ArrayList(usize).init(allocator);
while (iter.next()) |item| {
const n = std.fmt.parseInt(usize, item, 10) catch unreachable;
try list.append(n);
}
const numbers = list.toOwnedSlice();
defer allocator.free(numbers);
const min = std.mem.min(usize, numbers);
const max = std.mem.max(usize, numbers);
var i: usize = min;
var min_cost: usize = std.math.maxInt(usize);
while (i < max) : (i += 1) {
var cost: usize = 0;
for (numbers) |n| {
cost += if (i > n) i - n else n - i;
}
if (cost < min_cost) min_cost = cost;
}
return min_cost;
}
test "day07 part1 - example input" {
try std.testing.expectEqual(@as(usize, 37), try part1(std.testing.allocator, example_input));
}
test "day07 part1 - puzzle input" {
try std.testing.expectEqual(@as(usize, 342_534), try part1(std.testing.allocator, puzzle_input));
}
fn part2(allocator: std.mem.Allocator, input: []const u8) !usize {
var iter = std.mem.split(u8, input, ",");
var list = std.ArrayList(usize).init(allocator);
while (iter.next()) |item| {
const n = std.fmt.parseInt(usize, item, 10) catch unreachable;
try list.append(n);
}
const numbers = list.toOwnedSlice();
defer allocator.free(numbers);
const min = std.mem.min(usize, numbers);
const max = std.mem.max(usize, numbers);
var i: usize = min;
var min_cost: usize = std.math.maxInt(usize);
while (i < max) : (i += 1) {
var cost: usize = 0;
for (numbers) |n| {
cost += stepCost(if (i > n) i - n else n - i);
}
if (cost < min_cost) min_cost = cost;
}
return min_cost;
}
fn stepCost(d: usize) usize {
return d * (d + 1) / 2;
}
test "day07 part2 - example input" {
try std.testing.expectEqual(@as(usize, 168), try part2(std.testing.allocator, example_input));
}
test "day07 part2 - puzzle input" {
try std.testing.expectEqual(@as(usize, 94_004_208), try part2(std.testing.allocator, puzzle_input));
} | src/day07/day07.zig |
const std = @import("std");
const builtin = @import("builtin");
const deque = @import("deque");
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
pub const TaskFn = fn () anyerror!void;
pub fn Future(comptime T: type) type {
return union(enum) {
const Self = @This();
Error: anyerror,
Ok: T,
pub async fn resolve(self: Self) !T {
return switch (self) {
Self.Error => |err| err,
Self.Ok => |ok| ok,
};
}
pub async fn get(self: Self) !T {
return switch (self) {
Self.Error => |err| err,
Self.Ok => |ok| ok,
};
}
};
}
pub const ThreadPool = struct {
const Deque = deque.Deque(Task, 32);
const Stealer = deque.Stealer(Task, 32);
const Task = struct {
task_fn: TaskFn,
};
const Worker = struct {
stealer: Stealer,
terminate: bool,
thread: ?*Thread,
fn run(self: *Worker) u8 {
while (!self.terminate) {
while (self.stealer.steal()) |task| {
task.task_fn() catch |err| {
std.debug.warn("error: {}\n", .{@errorName(err)});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return 1;
};
}
}
return 0;
}
fn shutdown(self: *Worker) void {
// this race condition is okay (i think)
self.terminate = true;
if (self.thread) |thread|
thread.wait();
}
};
allocator: *Allocator,
worker_pool: []Worker,
thread_count: usize,
work_pool: Deque,
pub fn init(allocator: *Allocator, thread_count: ?usize) !ThreadPool {
if (builtin.single_threaded) {
@compileError("cannot use ThreadPool in signgle threaded build mode");
}
const count = thread_count orelse try Thread.cpuCount();
var result = ThreadPool{
.allocator = allocator,
.worker_pool = try allocator.alloc(Worker, count),
.thread_count = count,
.work_pool = try Deque.new(allocator),
};
for (result.worker_pool) |*worker| {
worker.thread = null;
}
return result;
}
pub fn deinit(self: *ThreadPool) void {
for (self.worker_pool) |*worker| {
worker.shutdown();
}
}
pub fn start(self: *ThreadPool) !void {
for (self.worker_pool) |*worker| {
worker.terminate = false;
worker.stealer = self.work_pool.stealer();
@fence(.SeqCst);
worker.thread = try Thread.spawn(worker, Worker.run);
}
}
pub fn push(self: *ThreadPool, task: TaskFn) !void {
try self.work_pool.push(Task{
.task_fn = task,
});
}
};
test "simple" {
var slice = try std.heap.page_allocator.alloc(u8, 1 << 24);
defer std.heap.page_allocator.free(slice);
var fba = std.heap.ThreadSafeFixedBufferAllocator.init(slice);
var allocator = &fba.allocator;
const Test = struct {
var static: usize = 0;
fn hello() anyerror!void {
try std.io.null_out_stream.print("hello {}: {}\n", .{Thread.getCurrentId(), static});
static += 1;
}
};
var pool = try ThreadPool.init(allocator, null);
defer pool.deinit();
const AMOUNT = 1000000;
{
var i: usize = AMOUNT;
while (i > 0) : (i -= 1) {
try pool.push(Test.hello);
}
var timer = try std.time.Timer.start();
try pool.start();
std.debug.warn("\n time-multi: {}\n", .{timer.lap()});
timer.reset();
Test.static = 0;
}
{
var timer = try std.time.Timer.start();
var i: usize = AMOUNT;
while (i > 0) : (i -= 1) {
try Test.hello();
}
std.debug.warn("time-single: {}\n", .{timer.lap()});
}
} | src/threadpool.zig |
const std = @import("std");
const mem = std.mem;
const open_flags = .{
.access_sub_paths = true,
.iterate = true,
};
pub const Iterator = struct {
allocator: mem.Allocator,
root: std.fs.Dir,
segments: std.ArrayListUnmanaged([]const u8),
stack: std.ArrayListUnmanaged(std.fs.Dir.Iterator),
components: std.ArrayListUnmanaged([]const u8),
path: ?[]const u8,
done: bool,
pub fn init(allocator: mem.Allocator, root: std.fs.Dir, pattern: []const u8) !Iterator {
if (pattern.len > 0 and pattern[0] == '/') return error.NoAbsolutePatterns;
var ret = Iterator{
.allocator = allocator,
.root = root,
.segments = std.ArrayListUnmanaged([]const u8){},
.stack = std.ArrayListUnmanaged(std.fs.Dir.Iterator){},
.components = std.ArrayListUnmanaged([]const u8){},
.path = null,
.done = false,
};
errdefer ret.deinit();
var it = mem.split(u8, pattern, "/");
while (it.next()) |seg| {
if (mem.indexOf(u8, seg, "**") != null)
return error.NotSupported;
try ret.segments.append(allocator, seg);
}
return ret;
}
pub fn deinit(self: *Iterator) void {
self.segments.deinit(self.allocator);
self.components.deinit(self.allocator);
if (self.stack.items.len > 0) {
for (self.stack.items[1..]) |*it| {
it.dir.close();
}
}
self.stack.deinit(self.allocator);
if (self.path) |path| self.allocator.free(path);
}
pub fn match(pattern: []const u8, str: []const u8) bool {
if (mem.eql(u8, pattern, "*")) return true;
var i: usize = 0;
var it = mem.tokenize(u8, pattern, "*");
var exact_begin = pattern.len > 0 and pattern[0] != '*';
while (it.next()) |substr| {
if (mem.indexOf(u8, str[i..], substr)) |j| {
if (exact_begin) {
if (j != 0) return false;
exact_begin = false;
}
i += j + substr.len;
} else return false;
}
return if (pattern[pattern.len - 1] == '*') true else i == str.len;
}
pub fn next(self: *Iterator) !?[]const u8 {
if (self.done) return null;
if (self.stack.items.len == 0) {
try self.stack.append(self.allocator, self.root.iterate());
}
var i = self.stack.items.len - 1;
reset: while (true) {
var it = &self.stack.items[i];
while (try it.next()) |entry| {
if (entry.kind != .File and entry.kind != .Directory)
continue;
if (match(self.segments.items[i], entry.name)) switch (entry.kind) {
.File => {
if (self.path) |path| {
self.allocator.free(path);
self.path = null;
}
try self.components.append(self.allocator, entry.name);
self.path = try std.fs.path.join(self.allocator, self.components.items);
_ = self.components.pop();
return self.path;
},
.Directory => {
if (i < self.segments.items.len - 1) {
const dir = try it.dir.openDir(entry.name, open_flags);
try self.stack.append(self.allocator, dir.iterate());
try self.components.append(self.allocator, entry.name);
i += 1;
continue :reset;
}
},
else => unreachable,
};
}
if (i == 0) {
self.done = true;
return null;
}
i -= 1;
_ = self.components.pop();
self.stack.pop().dir.close();
}
}
};
pub fn copy(
allocator: mem.Allocator,
pattern: []const u8,
from: std.fs.Dir,
to: std.fs.Dir,
) !void {
var it = try Iterator.init(allocator, from, pattern);
defer it.deinit();
while (try it.next()) |subpath| {
if (std.fs.path.dirname(subpath)) |dirname|
try to.makePath(dirname);
try from.copyFile(subpath, to, subpath, .{});
}
}
test "no files" {
try copy_test("", &[_][]const u8{}, &[_][]const u8{});
}
test "single file" {
try copy_test("build.zig", &[_][]const u8{"build.zig"}, &[_][]const u8{"build.zig"});
}
test "single file in dir" {
try copy_test("src/main.zig", &[_][]const u8{"src/main.zig"}, &[_][]const u8{"src/main.zig"});
}
test "glob all in root" {
try copy_test(
"*",
&[_][]const u8{ "something.zig", "file", "src/main.zig" },
&[_][]const u8{ "something.zig", "file" },
);
}
test "glob single file with extension" {
try copy_test(
"*.zig",
&[_][]const u8{ "build.zig", "README.md", "src/main.zig" },
&[_][]const u8{"build.zig"},
);
}
test "glob multiple files with extension" {
try copy_test(
"*.txt",
&[_][]const u8{ "build.txt", "file.txt", "src/main.zig" },
&[_][]const u8{ "build.txt", "file.txt" },
);
}
test "glob single file with prefix" {
try copy_test(
"build*",
&[_][]const u8{ "build.zig", "file.zig", "src/main.zig" },
&[_][]const u8{"build.zig"},
);
}
test "glob multiple files with prefix" {
try copy_test(
"ha*",
&[_][]const u8{ "haha", "hahahaha.zig", "file", "src/hain.zig" },
&[_][]const u8{ "haha", "hahahaha.zig" },
);
}
test "glob all files in dir" {
try copy_test(
"src/*",
&[_][]const u8{ "src/main.zig", "src/file.txt", "README.md", "build.zig" },
&[_][]const u8{ "src/main.zig", "src/file.txt" },
);
}
test "glob files with extension in dir" {
try copy_test(
"src/*.zig",
&[_][]const u8{ "src/main.zig", "src/lib.zig", "src/file.txt", "README.md", "build.zig" },
&[_][]const u8{ "src/main.zig", "src/lib.zig" },
);
}
test "glob single file in multiple dirs" {
try copy_test(
"*/test.zig",
&[_][]const u8{ "src/test.zig", "something/test.zig", "README.md", "src/a_file" },
&[_][]const u8{ "src/test.zig", "something/test.zig" },
);
}
test "glob beginning and end of a file" {
try copy_test(
"*hello*",
&[_][]const u8{ "this_is_hello_file", "hello_world", "hello", "greeting_hello", "file" },
&[_][]const u8{ "this_is_hello_file", "hello_world", "hello", "greeting_hello" },
);
}
test "glob beginning and middle" {
try copy_test(
"*hello*file",
&[_][]const u8{ "hellofile", "hello_world_file", "ahelloafile", "greeting_hellofile", "file" },
&[_][]const u8{ "hellofile", "hello_world_file", "ahelloafile", "greeting_hellofile" },
);
}
test "glob extension in multiple dirs" {
try copy_test(
"*/*.zig",
&[_][]const u8{ "src/main.zig", "something/lib.zig", "README.md", "src/a_file" },
&[_][]const u8{ "src/main.zig", "something/lib.zig" },
);
}
fn copy_test(pattern: []const u8, fs: []const []const u8, expected: []const []const u8) !void {
var dir = try setup_fs(fs);
defer dir.cleanup();
var dst = std.testing.tmpDir(open_flags);
defer dst.cleanup();
try copy(std.testing.allocator, pattern, dir.dir, dst.dir);
try expect_fs(dst.dir, expected);
}
fn setup_fs(files: []const []const u8) !std.testing.TmpDir {
var root = std.testing.tmpDir(open_flags);
errdefer root.cleanup();
for (files) |subpath| {
if (subpath.len == 0) continue;
var buf: [std.mem.page_size]u8 = undefined;
const path = blk: {
for (subpath) |c, i| buf[i] = if (c == '/') std.fs.path.sep else c;
break :blk buf[0..subpath.len];
};
const kind: std.fs.File.Kind = if (path[path.len - 1] == std.fs.path.sep)
.Directory
else
.File;
try touch(root.dir, path, kind);
}
return root;
}
fn expect_fs(root: std.fs.Dir, expected: []const []const u8) !void {
for (expected) |subpath| try root.access(subpath, .{ .read = true });
}
fn touch(root: std.fs.Dir, subpath: []const u8, kind: std.fs.File.Kind) !void {
switch (kind) {
.Directory => try root.makeDir(subpath),
.File => {
if (std.fs.path.dirname(subpath)) |dirname|
try root.makePath(dirname);
const file = try root.createFile(subpath, .{});
file.close();
},
else => return error.OnlyDirOrFile,
}
} | .gyro/glob-mattnite-github.com-7d17d551/pkg/src/main.zig |
const xcb = @import("../xcb.zig");
pub const id = xcb.Extension{ .name = "SHAPE", .global_id = 0 };
pub const OP = u8;
pub const KIND = u8;
pub const SO = extern enum(c_uint) {
@"Set" = 0,
@"Union" = 1,
@"Intersect" = 2,
@"Subtract" = 3,
@"Invert" = 4,
};
pub const SK = extern enum(c_uint) {
@"Bounding" = 0,
@"Clip" = 1,
@"Input" = 2,
};
/// Opcode for Notify.
pub const NotifyOpcode = 0;
/// @brief NotifyEvent
pub const NotifyEvent = struct {
@"response_type": u8,
@"shape_kind": xcb.shape.KIND,
@"sequence": u16,
@"affected_window": xcb.WINDOW,
@"extents_x": i16,
@"extents_y": i16,
@"extents_width": u16,
@"extents_height": u16,
@"server_time": xcb.TIMESTAMP,
@"shaped": u8,
@"pad0": [11]u8,
};
/// @brief QueryVersioncookie
pub const QueryVersioncookie = struct {
sequence: c_uint,
};
/// @brief QueryVersionRequest
pub const QueryVersionRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 0,
@"length": u16,
};
/// @brief QueryVersionReply
pub const QueryVersionReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"major_version": u16,
@"minor_version": u16,
};
/// @brief RectanglesRequest
pub const RectanglesRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 1,
@"length": u16,
@"operation": xcb.shape.OP,
@"destination_kind": xcb.shape.KIND,
@"ordering": u8,
@"pad0": u8,
@"destination_window": xcb.WINDOW,
@"x_offset": i16,
@"y_offset": i16,
@"rectangles": []const xcb.RECTANGLE,
};
/// @brief MaskRequest
pub const MaskRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 2,
@"length": u16,
@"operation": xcb.shape.OP,
@"destination_kind": xcb.shape.KIND,
@"pad0": [2]u8,
@"destination_window": xcb.WINDOW,
@"x_offset": i16,
@"y_offset": i16,
@"source_bitmap": xcb.PIXMAP,
};
/// @brief CombineRequest
pub const CombineRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 3,
@"length": u16,
@"operation": xcb.shape.OP,
@"destination_kind": xcb.shape.KIND,
@"source_kind": xcb.shape.KIND,
@"pad0": u8,
@"destination_window": xcb.WINDOW,
@"x_offset": i16,
@"y_offset": i16,
@"source_window": xcb.WINDOW,
};
/// @brief OffsetRequest
pub const OffsetRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 4,
@"length": u16,
@"destination_kind": xcb.shape.KIND,
@"pad0": [3]u8,
@"destination_window": xcb.WINDOW,
@"x_offset": i16,
@"y_offset": i16,
};
/// @brief QueryExtentscookie
pub const QueryExtentscookie = struct {
sequence: c_uint,
};
/// @brief QueryExtentsRequest
pub const QueryExtentsRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 5,
@"length": u16,
@"destination_window": xcb.WINDOW,
};
/// @brief QueryExtentsReply
pub const QueryExtentsReply = struct {
@"response_type": u8,
@"pad0": u8,
@"sequence": u16,
@"length": u32,
@"bounding_shaped": u8,
@"clip_shaped": u8,
@"pad1": [2]u8,
@"bounding_shape_extents_x": i16,
@"bounding_shape_extents_y": i16,
@"bounding_shape_extents_width": u16,
@"bounding_shape_extents_height": u16,
@"clip_shape_extents_x": i16,
@"clip_shape_extents_y": i16,
@"clip_shape_extents_width": u16,
@"clip_shape_extents_height": u16,
};
/// @brief SelectInputRequest
pub const SelectInputRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 6,
@"length": u16,
@"destination_window": xcb.WINDOW,
@"enable": u8,
@"pad0": [3]u8,
};
/// @brief InputSelectedcookie
pub const InputSelectedcookie = struct {
sequence: c_uint,
};
/// @brief InputSelectedRequest
pub const InputSelectedRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 7,
@"length": u16,
@"destination_window": xcb.WINDOW,
};
/// @brief InputSelectedReply
pub const InputSelectedReply = struct {
@"response_type": u8,
@"enabled": u8,
@"sequence": u16,
@"length": u32,
};
/// @brief GetRectanglescookie
pub const GetRectanglescookie = struct {
sequence: c_uint,
};
/// @brief GetRectanglesRequest
pub const GetRectanglesRequest = struct {
@"major_opcode": u8,
@"minor_opcode": u8 = 8,
@"length": u16,
@"window": xcb.WINDOW,
@"source_kind": xcb.shape.KIND,
@"pad0": [3]u8,
};
/// @brief GetRectanglesReply
pub const GetRectanglesReply = struct {
@"response_type": u8,
@"ordering": u8,
@"sequence": u16,
@"length": u32,
@"rectangles_len": u32,
@"pad0": [20]u8,
@"rectangles": []xcb.RECTANGLE,
};
test "" {
@import("std").testing.refAllDecls(@This());
} | src/auto/shape.zig |
const std = @import("std");
const debug = std.debug;
const fmt = std.fmt;
const io = std.io;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const testing = std.testing;
const ston = @This();
pub const Parser = @import("src/Parser.zig");
pub usingnamespace @import("src/meta.zig");
/// The type ston understands to be an index and will therefor be serialized/deserialized as
/// such,
pub fn Index(comptime _IndexType: type, comptime _ValueType: type) type {
return struct {
pub const IndexType = _IndexType;
pub const ValueType = _ValueType;
index: IndexType,
value: ValueType,
};
}
pub fn index(i: anytype, value: anytype) Index(@TypeOf(i), @TypeOf(value)) {
return .{ .index = i, .value = value };
}
/// The type ston understands to be a field and will therefor be serialized/deserialized as
/// such,
pub fn Field(comptime _ValueType: type) type {
return struct {
pub const ValueType = _ValueType;
name: []const u8,
value: ValueType,
};
}
pub fn field(name: []const u8, value: anytype) Field(@TypeOf(value)) {
return .{ .name = name, .value = value };
}
/// The type to use to specify that the underlying value is a string. All this type does is
/// force the `{s}` format specify in its own format function.
pub fn String(comptime T: type) type {
return struct {
value: T,
pub fn format(
self: @This(),
comptime f: []const u8,
opts: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
_ = f;
_ = opts;
try writer.print("{s}", .{self.value});
}
};
}
pub fn string(value: anytype) String(@TypeOf(value)) {
return .{ .value = value };
}
pub const DerserializeLineError = error{
InvalidBoolValue,
InvalidEnumValue,
InvalidField,
InvalidFloatValue,
InvalidIndex,
InvalidIntValue,
InvalidValue,
};
const Bool = enum(u1) { @"false" = 0, @"true" = 1 };
/// Parses parserens into `T`, where `T` is a union of possible fields/indexs that are valid.
/// This only deserializes up to the next `Token.Tag.value` parseren and will then return a `T`
/// initialized based on what deserialized.
pub fn deserializeLine(comptime T: type, parser: *ston.Parser) DerserializeLineError!T {
if (comptime ston.isIndex(T)) {
const i = try parser.index(T.IndexType);
const value = try deserializeLine(T.ValueType, parser);
return index(i, value);
}
if (comptime ston.isField(T)) {
const name = try parser.anyField();
const value = try deserializeLine(T.ValueType, parser);
return field(name, value);
}
switch (T) {
[]const u8, [:'\n']const u8 => return try parser.value(),
[*:'\n']const u8 => return (try parser.value()).ptr,
else => {},
}
switch (@typeInfo(T)) {
.Float => {
const value = parser.value() catch return error.InvalidFloatValue;
return fmt.parseFloat(T, value) catch return error.InvalidFloatValue;
},
.Int => return try parser.intValue(T),
.Enum => return try parser.enumValue(T),
.Bool => {
const res = deserializeLine(Bool, parser) catch return error.InvalidBoolValue;
return res == .@"true";
},
.Union => |info| {
inline for (info.fields) |f| {
if (parser.field(f.name)) |_| {
return @unionInit(T, f.name, try deserializeLine(f.field_type, parser));
} else |_| {}
}
return error.InvalidField;
},
else => @compileError("'" ++ @typeName(T) ++ "' is not supported"),
}
}
/// A struct that provides an iterator like API over `deserializeLine`.
pub fn Deserializer(comptime T: type) type {
return struct {
parser: *ston.Parser,
value: T = default(T),
pub inline fn next(des: *@This()) DerserializeLineError!T {
try update(T, &des.value, des.parser);
return des.value;
}
inline fn update(comptime T2: type, ptr: *T2, parser: *ston.Parser) !void {
if (comptime ston.isIndex(T2)) {
ptr.index = try parser.index(T2.IndexType);
return update(T2.ValueType, &ptr.value, parser);
}
// Sometimes we can avoid doing parsing work by just checking if the current thing we
// are parsing is the same `field` as what we previously parsed.
if (@typeInfo(T2) == .Union) {
const info = @typeInfo(T2).Union;
inline for (info.fields) |f| {
if (ptr.* == @field(info.tag_type.?, f.name)) {
if (parser.field(f.name)) |_| {
return update(f.field_type, &@field(ptr, f.name), parser);
} else |_| {}
}
}
}
ptr.* = try deserializeLine(T2, parser);
}
fn default(comptime T2: type) T2 {
switch (@typeInfo(T2)) {
.Int, .Float => return @as(T2, 0),
.Enum => |info| return @field(T2, info.fields[0].name),
.Void => return {},
.Bool => return false,
.Optional, .Null => return null,
.Struct => |struct_info| {
var res: T = undefined;
inline for (struct_info.fields) |f|
@field(res, f.name) = default(@TypeOf(@field(res, f.name)));
return res;
},
.Pointer => |ptr_info| {
switch (ptr_info.size) {
.Slice => return &[_]ptr_info.child{},
.C => return null,
.One, .Many => @compileError("Can't set a non nullable pointer to zero."),
}
},
.Array => |info| {
if (info.sentinel) |sentinel| {
return [_:sentinel]info.child{default(info.child)} ** info.len;
}
return [_]info.child{default(info.child)} ** info.len;
},
.Vector => |info| {
return @splat(info.len, default(info.child));
},
.Union => |info| {
const field_0 = info.fields[0];
return @unionInit(T2, field_0.name, default(field_0.field_type));
},
else => @compileError("Can't set a " ++ @typeName(T) ++ " to zero."),
}
}
};
}
pub fn deserialize(comptime T: type, parser: *ston.Parser) Deserializer(T) {
return .{ .parser = parser };
}
fn expectDerserializeLine(str: [:0]const u8, comptime T: type, err_expect: DerserializeLineError!T) !void {
var parser = ston.Parser{ .str = str };
var des_parser = ston.Parser{ .str = str };
var des = deserialize(T, &des_parser);
const expect = err_expect catch |err| {
try testing.expectError(err, deserializeLine(T, &parser));
try testing.expectError(err, des.next());
des_parser = ston.Parser{ .str = str };
try testing.expectError(err, des.next());
return;
};
try testing.expectEqual(expect, deserializeLine(T, &parser) catch {
try testing.expect(false);
unreachable;
});
try testing.expectEqual(expect, des.next() catch {
try testing.expect(false);
unreachable;
});
des_parser = ston.Parser{ .str = str };
try testing.expectEqual(expect, des.next() catch {
try testing.expect(false);
unreachable;
});
}
test "deserializeLine" {
const T = union(enum) {
int: u8,
float: f32,
bol: bool,
enu: enum { a, b },
string: []const u8,
index: Index(u8, u8),
};
try expectDerserializeLine(".int=2\n", T, T{ .int = 2 });
try expectDerserializeLine(".float=2\n", T, T{ .float = 2 });
try expectDerserializeLine(".bol=true\n", T, T{ .bol = true });
try expectDerserializeLine(".enu=a\n", T, T{ .enu = .a });
// try expectDerserializeLine(".string=string\n", T, T{ .string = "string" });
try expectDerserializeLine(".index[2]=4\n", T, T{ .index = .{ .index = 2, .value = 4 } });
try expectDerserializeLine("[1]\n", T, error.InvalidField);
try expectDerserializeLine(".int.a=1\n", T, error.InvalidIntValue);
try expectDerserializeLine(".index.a=1\n", T, error.InvalidIndex);
try expectDerserializeLine(".int=q\n", T, error.InvalidIntValue);
try expectDerserializeLine(".bol=q\n", T, error.InvalidBoolValue);
try expectDerserializeLine(".enu=q\n", T, error.InvalidEnumValue);
try expectDerserializeLine(".index[q]=q\n", T, error.InvalidIndex);
try expectDerserializeLine(".q=q\n", T, error.InvalidField);
}
pub fn serialize(writer: anytype, value: anytype) !void {
// TODO: Calculate upper bound for `prefix` from the type of `value`
var buf: [mem.page_size]u8 = undefined;
var prefix = io.fixedBufferStream(&buf);
return serializeHelper(writer, &prefix, value);
}
fn serializeHelper(writer: anytype, prefix: *io.FixedBufferStream([]u8), value: anytype) !void {
const T = @TypeOf(value);
if (comptime ston.isIndex(T)) {
var copy = prefix.*;
copy.writer().writeAll("[") catch unreachable;
fmt.formatInt(value.index, 10, .lower, .{}, copy.writer()) catch unreachable;
copy.writer().writeAll("]") catch unreachable;
try serializeHelper(writer, ©, value.value);
return;
}
if (comptime ston.isIntMap(T)) {
var it = value.iterator();
while (it.next()) |entry| {
var copy = prefix.*;
copy.writer().writeAll("[") catch unreachable;
fmt.formatInt(entry.key_ptr.*, 10, .lower, .{}, copy.writer()) catch unreachable;
copy.writer().writeAll("]") catch unreachable;
try serializeHelper(writer, ©, entry.value_ptr.*);
}
return;
}
if (comptime ston.isArrayList(T)) {
return serializeHelper(writer, prefix, value.items);
}
if (comptime ston.isField(T)) {
var copy = prefix.*;
copy.writer().writeAll(".") catch unreachable;
copy.writer().writeAll(value.name) catch unreachable;
try serializeHelper(writer, ©, value.value);
return;
}
switch (@typeInfo(T)) {
.Void, .Null => {},
.Bool => {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
try writer.writeAll(if (value) "true" else "false");
try writer.writeAll("\n");
},
.Int, .ComptimeInt => {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
try fmt.formatInt(value, 10, .lower, .{}, writer);
try writer.writeAll("\n");
},
.Float, .ComptimeFloat => {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
try fmt.formatFloatDecimal(value, .{}, writer);
try writer.writeAll("\n");
},
.Optional => if (value) |v| {
try serializeHelper(writer, prefix, v);
} else {},
.Pointer => |info| switch (info.size) {
.One => try serializeHelper(writer, prefix, value.*),
.Slice => for (value) |v, i| {
var copy = prefix.*;
copy.writer().writeAll("[") catch unreachable;
fmt.formatInt(i, 10, .lower, .{}, copy.writer()) catch unreachable;
copy.writer().writeAll("]") catch unreachable;
try serializeHelper(writer, ©, v);
},
else => @compileError("Type '" ++ @typeName(T) ++ "' not supported"),
},
.Array => |info| {
var l: usize = info.len;
try serializeHelper(writer, prefix, value[0..l]);
},
.Enum => {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
if (@hasDecl(T, "format")) {
try value.format("", .{}, writer);
} else {
try writer.writeAll(@tagName(value));
}
try writer.writeAll("\n");
},
.Union => |info| {
const Tag = meta.Tag(T);
if (@hasDecl(T, "format")) {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
try value.format("", .{}, writer);
try writer.writeAll("\n");
} else inline for (info.fields) |f| {
if (@field(Tag, f.name) == value) {
var copy = prefix.*;
copy.writer().writeAll("." ++ f.name) catch unreachable;
try serializeHelper(writer, ©, @field(value, f.name));
return;
}
}
unreachable;
},
.Struct => |info| if (@hasDecl(T, "format")) {
try writer.writeAll(prefix.getWritten());
try writer.writeAll("=");
try value.format("", .{}, writer);
try writer.writeAll("\n");
} else inline for (info.fields) |f| {
var copy = prefix.*;
copy.writer().writeAll("." ++ f.name) catch unreachable;
try serializeHelper(writer, ©, @field(value, f.name));
},
else => @compileError("Type '" ++ @typeName(T) ++ "' not supported"),
}
}
fn expectSerialized(str: []const u8, value: anytype) !void {
var buf: [mem.page_size]u8 = undefined;
var fbs = io.fixedBufferStream(&buf);
try serialize(fbs.writer(), value);
try testing.expectEqualStrings(str, fbs.getWritten());
}
test "serialize - struct" {
const S = struct {
a: u8 = 1,
b: enum { a, b } = .a,
c: bool = false,
d: String(*const [4:0]u8) = string("abcd"),
e: Index(u8, u8) = .{ .index = 2, .value = 3 },
f: union(enum) { a: u8, b: bool } = .{ .a = 2 },
g: f32 = 1.5,
h: void = {},
i: Field(u8) = .{ .name = "a", .value = 2 },
};
try expectSerialized(
\\.a=1
\\.b=a
\\.c=false
\\.d=abcd
\\.e[2]=3
\\.f.a=2
\\.g=1.5
\\.i.a=2
\\
, S{});
try expectSerialized(
\\[0].a=1
\\[0].b=a
\\[0].c=false
\\[0].d=abcd
\\[0].e[2]=3
\\[0].f.a=2
\\[0].g=1.5
\\[0].i.a=2
\\[1].a=1
\\[1].b=a
\\[1].c=false
\\[1].d=abcd
\\[1].e[2]=3
\\[1].f.a=2
\\[1].g=1.5
\\[1].i.a=2
\\
, [_]S{.{}} ** 2);
try expectSerialized(
\\[0][0].a=1
\\[0][0].b=a
\\[0][0].c=false
\\[0][0].d=abcd
\\[0][0].e[2]=3
\\[0][0].f.a=2
\\[0][0].g=1.5
\\[0][0].i.a=2
\\[0][1].a=1
\\[0][1].b=a
\\[0][1].c=false
\\[0][1].d=abcd
\\[0][1].e[2]=3
\\[0][1].f.a=2
\\[0][1].g=1.5
\\[0][1].i.a=2
\\[1][0].a=1
\\[1][0].b=a
\\[1][0].c=false
\\[1][0].d=abcd
\\[1][0].e[2]=3
\\[1][0].f.a=2
\\[1][0].g=1.5
\\[1][0].i.a=2
\\[1][1].a=1
\\[1][1].b=a
\\[1][1].c=false
\\[1][1].d=abcd
\\[1][1].e[2]=3
\\[1][1].f.a=2
\\[1][1].g=1.5
\\[1][1].i.a=2
\\
, [_][2]S{[_]S{.{}} ** 2} ** 2);
}
test "serialize - HashMap" {
var hm = std.AutoHashMap(u8, u8).init(testing.allocator);
defer hm.deinit();
try hm.putNoClobber(2, 3);
try hm.putNoClobber(4, 8);
try hm.putNoClobber(10, 20);
try expectSerialized(
\\[4]=8
\\[10]=20
\\[2]=3
\\
, hm);
}
test "serialize - ArrayHashMap" {
var hm = std.AutoArrayHashMap(u8, u8).init(testing.allocator);
defer hm.deinit();
try hm.putNoClobber(2, 3);
try hm.putNoClobber(4, 8);
try hm.putNoClobber(10, 20);
try expectSerialized(
\\[2]=3
\\[4]=8
\\[10]=20
\\
, hm);
}
test "serialize - ArrayList" {
var list = std.ArrayList(u8).init(testing.allocator);
defer list.deinit();
try list.append(1);
try list.append(2);
try list.append(3);
try expectSerialized(
\\[0]=1
\\[1]=2
\\[2]=3
\\
, list);
} | ston.zig |
const std = @import("std");
const resolvePath = @import("resolvePath.zig").resolvePath;
pub const Server = struct {
server: std.net.StreamServer,
pub fn init(ip: []const u8, port: u16) !Server {
var server = std.net.StreamServer.init(.{
.reuse_address = true,
});
errdefer server.deinit();
try server.listen(try std.net.Address.parseIp(ip, port));
return Server{
.server = server,
};
}
pub fn deinit(self: *Server) void {
self.server.deinit();
}
pub fn getConnection(self: *Server) !std.net.StreamServer.Connection {
return self.server.accept();
}
pub fn readRequest(connection: std.net.StreamServer.Connection) !Context {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
errdefer arena.deinit();
var url_buf: [1200]u8 = undefined;
const url = try arena.allocator.dupe(u8, readCrLf(connection.stream.reader(), &url_buf) orelse return error.BadRequest);
const css = std.mem.indexOf(u8, url, "://") orelse return error.BadRequest;
const scheme = url[0..css];
const without_scheme = url[(scheme.len + "://".len)..];
const indeks = std.mem.indexOf(u8, without_scheme, "/");
const host = if (indeks) |ix| without_scheme[0..ix] else without_scheme;
const dangerous_uri = if (indeks) |ix| without_scheme[ix + 1 ..] else "";
var path_buf: [1024]u8 = undefined;
const path = try arena.allocator.dupe(u8, (try resolvePath(&path_buf, dangerous_uri))[1..]);
return Context{
.request = .{
.original_url = url,
.url = .{
.scheme = scheme,
.host = host,
.path = path,
},
},
.response_status = ResponseStatus.TEMPORARY_FAILURE,
.arena = arena,
.connection = connection,
.headers_written = false,
};
}
fn readCrLf(in: anytype, buf: []u8) ?[]u8 {
const line = (in.readUntilDelimiterOrEof(buf, '\n') catch |_| null) orelse
return null;
if (line.len == 0 or line[line.len - 1] != '\r')
return null;
return line[0 .. line.len - 1];
}
pub const Context = struct {
pub const Writer = std.io.Writer(*Context, std.os.WriteError, write);
request: Request,
response_status: ResponseStatus,
arena: std.heap.ArenaAllocator,
connection: std.net.StreamServer.Connection,
headers_written: bool,
pub fn deinit(self: *Context) void {
self.ensureResponseStatusWritten() catch {};
self.connection.stream.close();
self.arena.deinit();
}
pub fn status(self: *Context, response_status: ResponseStatus) void {
self.response_status = response_status;
}
pub fn writer(self: *Context) Writer {
return .{ .context = self };
}
fn ensureResponseStatusWritten(self: *Context) !void {
if (self.headers_written) return;
try self.connection.stream.writer().print("{} {s}\r\n", .{ @enumToInt(self.response_status.code), self.response_status.meta });
self.headers_written = true;
}
fn write(self: *Context, buffer: []const u8) std.os.WriteError!usize {
try self.ensureResponseStatusWritten();
return self.connection.stream.write(buffer);
}
};
pub const Request = struct {
original_url: []u8,
url: struct {
scheme: []const u8,
host: []const u8,
path: []u8,
},
};
pub const ResponseStatus = struct {
code: enum(u8) {
Input = 10,
SensitiveInput = 11,
Success = 20,
RedirectTemporary = 30,
RedirectPermanent = 31,
TemporaryFailure = 40,
ServerUnavailable = 41,
CgiError = 42,
ProxyError = 43,
SlowDown = 44,
PermanentFailure = 50,
NotFound = 51,
Gone = 52,
ProxyRequestRefused = 53,
BadRequest = 59,
ClientCertificateRequired = 60,
CertificateNotAuthorised = 61,
CertificateNotValid = 62,
},
meta: []const u8,
pub const TEMPORARY_FAILURE: ResponseStatus = .{ .code = .TemporaryFailure, .meta = "internal error" };
pub const NO_NON_GEMINI: ResponseStatus = .{ .code = .ProxyRequestRefused, .meta = "no non-gemini requests" };
pub const NO_MATCHING_VHOST: ResponseStatus = .{ .code = .ProxyRequestRefused, .meta = "no matching vhost" };
pub const BAD_REQUEST: ResponseStatus = .{ .code = .BadRequest, .meta = "bad request" };
pub const NOT_FOUND: ResponseStatus = .{ .code = .NotFound, .meta = "not found" };
};
}; | src/server.zig |
const builtin = @import("builtin");
const std = @import("std");
const File = std.os.File;
const Timer = std.os.time.Timer;
const warn = std.debug.warn;
const assert = std.debug.assert;
/// Return the time stamp counter plus auxilliary information.
/// The auxilary information is an u32 unique to each cpu. If two
/// rdtsc_aux return two different values then the time stamp
/// maybe suspect.
fn rdtscp(pAux: *u32) u64 {
var lo: u32 = undefined;
var hi: u32 = undefined;
var aux: u32 = undefined;
asm volatile ("rdtsc\n"
: [lo] "={eax}" (lo),
[hi] "={edx}" (hi),
[aux] "={ecx}" (aux));
//warn("rdtscp: aux={}\n", aux);
pAux.* = aux;
return (u64(hi) << 32) | u64(lo);
}
/// Return the time stamp counter
fn rdtsc() u64 {
var lo: u32 = undefined;
var hi: u32 = undefined;
asm volatile ("rdtsc\n"
: [lo] "={eax}" (lo),
[hi] "={edx}" (hi));
return (u64(hi) << 32) | u64(lo);
}
/// mfence instruction
fn mfence() void {
asm volatile ("mfence": : :"memory");
}
/// lfence instruction
fn lfence() void {
asm volatile ("lfence": : :"memory");
}
/// sfence instruction
fn sfence() void {
asm volatile ("sfence": : :"memory");
}
/// A possible API for a systesm cycle counters
const CycleCounter = struct {
const Self = @This();
pub start_cpu_id: u32,
pub start_cycle_counter: u64,
pub cpu_id: u32,
pub cycle_counter: u64,
fn init(pSelf: *Self) void {
pSelf.cpu_id = 0;
}
pub fn start(pSelf: *Self) u64 {
pSelf.cycle_counter = pSelf.rdTsc(&pSelf.cpu_id);
pSelf.start_cycle_counter = pSelf.cycle_counter;
pSelf.start_cpu_id = pSelf.cpu_id;
return pSelf.cycle_counter;
}
pub fn now(pSelf: *Self) u64 {
var cpu_id: u32 = undefined;
pSelf.cycle_counter = rdTsc(&cpu_id);
return pSelf.cycle_counter;
}
/// TODO: For some reason in debug build mode the cpu_id's don't match
/// and are large numbers.
pub fn read(pSelf: *Self) !u64 {
pSelf.cycle_counter = pSelf.rdTsc(&pSelf.cpu_id);
switch (builtin.mode) {
builtin.Mode.Debug, => {
// Supress compile error in Debug mode:
// error: function with inferred error set must return at least one possible error
if ((pSelf.cpu_id != pSelf.start_cpu_id) and false) return error.WillNotHappen;
},
builtin.Mode.ReleaseSafe, builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {
if (pSelf.cpu_id != pSelf.start_cpu_id) {
return error.UnexpectedCpuid;
}
},
}
return pSelf.cycle_counter;
}
// TODO: Add comptime code to determine appropriate code
// See [google/benchmark/sysinfo.h GetCPUCyclesPerSecond()]
// (https://github.com/google/benchmark/blob/master/src/sysinfo.cc#L436)
pub fn getCpuCyclesPerSecond(pSelf: *Self) !u64 {
var freq_str_in_khz = try readFile(a,
"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq", @alignOf(u8));
defer a.free(freq_str_in_khz);
var freq = stringToInteger(u64, freq_str_in_khz);
freq *= 1000;
return freq;
}
// Read time stamp counter
//
// TODO: Add comptime code to determine appropriate code
// See [google/benchmark/cycleclock.h Now()]
// (https://github.com/google/benchmark/blob/master/src/cycleclock.h#L61)
fn rdTsc(pSelf: *Self, pCpu_id: *u32) u64 {
return rdtscp(pCpu_id);
}
// Slight modification of std/io.zig/readFileAllocAligned
// changed the last 2 lines from:
// try adapter.stream.readNoEof(buf[0..size]);
// return buf;
// to:
// var count = try adapter.stream.read(buf[0..size]);
// return buf[0..count];
fn readFile(allocator: *mem.Allocator, path: []const u8, comptime A: u29) ![]align(A) u8 {
var file = try File.openRead(path);
defer file.close();
const size = try file.getEndPos();
const buf = try allocator.alignedAlloc(u8, A, size);
errdefer allocator.free(buf);
var adapter = std.io.FileInStream.init(file);
var count = try adapter.stream.read(buf[0..size]);
return buf[0..count];
}
// Convet numeric string to integer.
//
// TODO: Support negative numbers and radix like parseInt.
fn stringToInteger(comptime T: type, str: []u8) T {
var i: usize = 0;
var val: T = 0;
while (i < str.len) : (i += 1) {
if ((str[i] < '0') or (str[i] > '9')) break;
val *= 10;
val += str[i] - '0';
}
return val;
}
};
/// Tests
fn loops(
comptime readTimeAndAux: fn(*u32) u64,
comptime name: [] const u8,
comptime loop_count: usize,
comptime inner_loop_count: usize,
log: bool,
) void {
var i: usize = 0;
var aux_start: u32 = undefined;
var once: bool = true;
var start_time = timer.read();
while (i < loop_count) : (i += 1) {
comptime var j = 0;
var aux: u32 = undefined;
var cur_time = readTimeAndAux(&aux_start);
inline while(j < inner_loop_count) : (j += 1) {
cur_time = readTimeAndAux(&aux);
}
if (aux != aux_start and once) {
once = false;
warn("aux:{} != aux_start:{}\n", aux, aux_start);
}
}
var end_time = timer.read();
var duration = end_time - start_time;
var seconds = @intToFloat(f64, end_time - start_time) / @intToFloat(f64, std.os.time.ns_per_s);
var ops_per_sec = @intToFloat(f64, (loop_count * inner_loop_count)) / seconds;
var ns_per_op = (seconds / @intToFloat(f64, (loop_count * inner_loop_count))) * 1000000000;
if (log) {
warn("test {}: cpu_id={} time={.4}s time/op={.4}ns ops/sec={.0}\n",
name[0..], aux_start, seconds, ns_per_op, ops_per_sec);
}
}
var timer: Timer = undefined;
fn timerRead(pAux: *u32) u64 {
pAux.* = 0;
return timer.read();
}
fn readTsc(pAux: *u32) u64 {
return rdtscp(pAux);
}
var gCc: CycleCounter = undefined;
fn readCc(pAux: *u32) u64 {
var x: u64 = gCc.read() catch 0;
pAux.* = gCc.cpu_id;
return gCc.cycle_counter;
}
const a = std.debug.global_allocator;
const mem = std.mem;
test "fences" {
lfence();
sfence();
mfence();
}
test "Timer" {
var aux1: u32 = undefined;
var aux2: u32 = undefined;
_ = rdtscp(&aux1);
_ = rdtscp(&aux2);
warn("\naux1={} aux2={}\n", aux1, aux2);
var cc : CycleCounter = undefined;
cc.init();
var freq: u64 = try cc.getCpuCyclesPerSecond();
warn("freq={}\n", freq);
var cc_start: u64 = cc.start();
assert(cc.start_cycle_counter == cc_start);
var cc_end: u64 = try cc.read();
//assert(cc.start_cpu_id == cc.cpu_id); // TODO: was passing previously but not now, why?
assert(cc.cycle_counter == cc_end);
var duration_cc = cc_end - cc_start;
assert(cc_end > cc_start);
assert(duration_cc == (cc_end - cc_start));
warn(" duration_cc:{} = cc_end:{} - cc_start:{}\n", duration_cc, cc_end, cc_start);
var tsc_start: u64 = rdtsc();
var tsc_end: u64 = rdtsc();
var duration_rdtsc = tsc_end - tsc_start;
assert(tsc_end > tsc_start);
assert(duration_rdtsc == (tsc_end - tsc_start));
warn(" duration_rdtsc:{} = tsc_end:{} - tsc_start:{}\n", duration_rdtsc, tsc_end, tsc_start);
var aux_start: u32 = 0x123;
tsc_start = rdtscp(&aux_start);
var aux_end: u32 = 0x456;
tsc_end = rdtscp(&aux_end);
var duration_rdtscp = tsc_end - tsc_start;
assert(tsc_end > tsc_start);
assert(duration_rdtscp == (tsc_end - tsc_start));
warn("duration_rdtscp:{} = tsc_end:{} - tsc_start:{} aux_start={} aux_end={}\n",
duration_rdtscp, tsc_end, tsc_start, aux_start, aux_end);
// Initialize timer
timer = try Timer.start();
gCc.init();
const loop_count: usize = 2000000;
const inner_loop_count = 100;
// Warm up CPU, don't log
warn("Warm up CPU\n");
loops(timerRead, "timer.read()"[0..], loop_count, inner_loop_count, false);
warn("Running loops\n");
loops(timerRead, "timer.read()", loop_count, inner_loop_count, true);
loops(readCc, " readCc()", loop_count, inner_loop_count, true);
loops(readTsc, " rdtsc()", loop_count, inner_loop_count, true);
loops(rdtscp, " rdstcp()", loop_count, inner_loop_count, true);
} | timer/timer.zig |
const x86_64 = @import("../index.zig");
const bitjuggle = @import("bitjuggle");
const std = @import("std");
/// Specifies which element to load into a segment from
/// descriptor tables (i.e., is a index to LDT or GDT table
/// with some additional flags).
///
/// See Intel 3a, Section 3.4.2 "Segment Selectors"
pub const SegmentSelector = struct {
value: u16,
/// Creates a new SegmentSelector
pub fn init(index: u16, rpl: x86_64.PrivilegeLevel) SegmentSelector {
return .{
.value = index << 3 | @as(u16, @enumToInt(rpl)),
};
}
// Returns the GDT index.
pub fn getIndex(self: SegmentSelector) u16 {
return self.value >> 3;
}
/// Set the privilege level for this Segment selector.
pub fn setRpl(self: *SegmentSelector, rpl: x86_64.PrivilegeLevel) void {
bitjuggle.setBits(&self.value, 0, 2, @as(u16, @enumToInt(rpl)));
}
/// Returns the requested privilege level.
/// Returns `error.InvalidPrivilegeLevel` if the privledge level bits are out of range of the `PrivilegeLevel` enum
pub fn getRpl(self: SegmentSelector) x86_64.PrivilegeLevel {
switch (bitjuggle.getBits(self.value, 0, 2)) {
0 => return x86_64.PrivilegeLevel.Ring0,
1 => return x86_64.PrivilegeLevel.Ring1,
2 => return x86_64.PrivilegeLevel.Ring2,
3 => return x86_64.PrivilegeLevel.Ring3,
}
}
/// Returns the requested privilege level.
///
/// ## Panic
/// Will panic if the privledge level bits are out of range of the `PrivilegeLevel` enum
pub fn getRplPanic(self: SegmentSelector) x86_64.PrivilegeLevel {
return @intToEnum(x86_64.PrivilegeLevel, bitjuggle.getBits(self.value, 0, 2));
}
pub fn format(value: SegmentSelector, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
try writer.print("SegmentSelector(.index = {}, .rpl = {})", .{ value.getIndex(), value.getRpl() });
}
comptime {
std.testing.refAllDecls(@This());
}
};
test "SegmentSelector" {
var a = SegmentSelector.init(1, .Ring0);
try std.testing.expectEqual(@as(u16, 1), a.getIndex());
try std.testing.expectEqual(x86_64.PrivilegeLevel.Ring0, a.getRpl());
a.setRpl(.Ring3);
try std.testing.expectEqual(@as(u16, 1), a.getIndex());
try std.testing.expectEqual(x86_64.PrivilegeLevel.Ring3, a.getRpl());
}
/// A 64-bit mode global descriptor table (GDT).
///
/// In 64-bit mode, segmentation is not supported. The GDT is used nonetheless, for example for
/// switching between user and kernel mode or for loading a TSS.
///
/// The GDT has a fixed size of 8 entries, trying to add more entries will panic.
///
/// You do **not** need to add a null segment descriptor yourself - this is already done internally.
///
/// Data segment registers in ring 0 can be loaded with the null segment selector. When running in
/// ring 3, the `ss` register must point to a valid data segment which can be obtained through the
/// `createUserDataSegment()` function.
///
/// Code segments must be valid and non-null at all times and can be obtained through the
/// `createKernelCodeSegment()` and `createUserCodeSegment()` in rings 0 and 3 respectively.
///
/// For more info, see:
/// [x86 Instruction Reference for `mov`](https://www.felixcloutier.com/x86/mov#64-bit-mode-exceptions),
/// [Intel Manual](https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf),
/// [AMD Manual](https://www.amd.com/system/files/TechDocs/24593.pdf)
pub const GlobalDescriptorTable = struct {
table: [8]u64 = [_]u64{0} ** 8,
next_free: u16 = 1,
/// Create a GDT from a slice of `u64`.
/// The length of the slice must not exceed 8.
pub fn fromRawSlice(slice: []const u64) !GlobalDescriptorTable {
if (slice.len > 8) return error.SliceLenExceedsEight;
var table: [8]u64 = [_]u64{0} ** 8;
const next_free = @truncate(u16, slice.len);
var i: usize = 0;
while (i != next_free) : (i += 1) {
table[i] = slice[i];
}
return GlobalDescriptorTable{
.table = table,
.next_free = next_free,
};
}
/// Adds the given segment descriptor to the GDT, returning the segment selector.
///
/// Panics if the GDT has no free entries left.
pub fn addEntry(self: *GlobalDescriptorTable, entry: Descriptor) SegmentSelector {
switch (entry) {
.UserSegment => |value| {
const rpl = if (value & Descriptor.DPL_RING_3 != 0) x86_64.PrivilegeLevel.Ring3 else x86_64.PrivilegeLevel.Ring0;
return SegmentSelector.init(self.push(value), rpl);
},
.SystemSegment => |systemSegmentData| {
const index = self.push(systemSegmentData.low);
_ = self.push(systemSegmentData.high);
return SegmentSelector.init(index, x86_64.PrivilegeLevel.Ring0);
},
}
}
/// Loads the GDT in the CPU using the `lgdt` instruction.
/// ### NOTE:
/// This does **not** alter any of the segment registers; you **must** (re)load them yourself using the appropriate functions:
/// `instructions.segmentation.loadSs`, `instructions.segmentation.setCs`
pub fn load(self: *GlobalDescriptorTable) void {
const ptr = x86_64.structures.DescriptorTablePointer{
.base = x86_64.VirtAddr.fromPtr(&self.table),
.limit = @as(u16, self.next_free * @sizeOf(u64) - 1),
};
x86_64.instructions.tables.lgdt(&ptr);
}
fn push(self: *GlobalDescriptorTable, value: u64) u16 {
if (self.next_free < self.table.len) {
const index = self.next_free;
self.table[index] = value;
self.next_free += 1;
return index;
}
@panic("GDT full");
}
comptime {
std.testing.refAllDecls(@This());
}
};
test "GlobalDescriptorTable" {
var gdt: GlobalDescriptorTable = .{};
_ = gdt.addEntry(createKernelCodeSegment());
_ = gdt.addEntry(createUserCodeSegment());
_ = gdt.addEntry(createUserDataSegment());
}
/// Creates a segment descriptor for a 64-bit kernel code segment.
/// Suitable for use with `syscall` or 64-bit `sysenter`.
pub fn createKernelCodeSegment() Descriptor {
return .{ .UserSegment = Descriptor.KERNEL_CODE64 };
}
/// Creates a segment descriptor for a ring 0 data segment (32-bit or 64-bit).
/// Suitable for use with `syscall` or 64-bit `sysenter`.
pub fn createKernelDataSegment() Descriptor {
return .{ .UserSegment = Descriptor.KERNEL_DATA };
}
/// Creates a segment descriptor for a ring 3 data segment (32-bit or 64-bit).
/// Suitable for use with `sysret` or `sysexit`.
pub fn createUserDataSegment() Descriptor {
return .{ .UserSegment = Descriptor.USER_DATA };
}
/// Creates a segment descriptor for a 64-bit ring 3 code segment. #
/// Suitable for use with `sysret` or `sysexit`.
pub fn createUserCodeSegment() Descriptor {
return .{ .UserSegment = Descriptor.USER_CODE64 };
}
/// Creates a TSS system descriptor for the given TSS.
pub fn tssSegment(tss: *x86_64.structures.tss.TaskStateSegment) Descriptor {
const ptr = @ptrToInt(tss);
var low = Descriptor.PRESENT;
// base
bitjuggle.setBits(&low, 16, 24, bitjuggle.getBits(ptr, 0, 24));
bitjuggle.setBits(&low, 56, 8, bitjuggle.getBits(ptr, 24, 8));
// limit (the `-1` is in needed since the bound is inclusive)
bitjuggle.setBits(&low, 0, 16, @as(u64, @sizeOf(x86_64.structures.tss.TaskStateSegment) - 1));
// type (0b1001 = available 64-bit tss)
bitjuggle.setBits(&low, 40, 4, 0b1001);
var high: u64 = 0;
bitjuggle.setBits(&high, 0, 32, bitjuggle.getBits(ptr, 32, 32));
return .{
.SystemSegment = .{
.low = low,
.high = high,
},
};
}
/// A 64-bit mode segment descriptor
///
/// Segmentation is no longer supported in 64-bit mode, so most of the descriptor
/// contents are ignored.
pub const Descriptor = union(enum) {
/// Set by the processor if this segment has been accessed. Only cleared by software.
pub const ACCESSED: u64 = 1 << 40;
/// For 32-bit data segments, sets the segment as writable. For 32-bit code segments,
/// sets the segment as _readable_. In 64-bit mode, ignored for all segments.
pub const WRITABLE: u64 = 1 << 41;
/// For code segments, sets the segment as “conforming”, influencing the
/// privilege checks that occur on control transfers. For 32-bit data segments,
/// sets the segment as "expand down". In 64-bit mode, ignored for data segments.
pub const CONFORMING: u64 = 1 << 42;
/// This flag must be set for code segments and unset for data segments.
pub const EXECUTABLE: u64 = 1 << 43;
/// This flag must be set for user segments (in contrast to system segments).
pub const USER_SEGMENT: u64 = 1 << 44;
/// The DPL for this descriptor is Ring 3. In 64-bit mode, ignored for data segments.
pub const DPL_RING_3: u64 = 3 << 45;
/// Must be set for any segment, causes a segment not present exception if not set.
pub const PRESENT: u64 = 1 << 47;
/// Available for use by the Operating System
pub const AVAILABLE: u64 = 1 << 52;
/// Must be set for 64-bit code segments, unset otherwise.
pub const LONG_MODE: u64 = 1 << 53;
/// Use 32-bit (as opposed to 16-bit) operands. If [`long_mode`] is set,
/// this must be unset. In 64-bit mode, ignored for data segments.
pub const DEFAULT_SIZE: u64 = 1 << 54;
/// Limit field is scaled by 4096 bytes. In 64-bit mode, ignored for all segments.
pub const GRANULARITY: u64 = 1 << 55;
/// Bits 0..=15 of the limit field (ignored in 64-bit mode)
pub const LIMIT_0_15: u64 = 0xFFFF;
/// Bits 16..=19 of the limit field (ignored in 64-bit mode)
pub const LIMIT_16_19: u64 = 0xF << 48;
/// Bits 0..=23 of the base field (ignored in 64-bit mode, except for fs and gs)
pub const BASE_0_23: u64 = 0xFF_FFFF << 16;
/// Bits 24..=31 of the base field (ignored in 64-bit mode, except for fs and gs)
pub const BASE_24_31: u64 = 0xFF << 56;
/// Flags that we set for all our default segments
pub const COMMON: u64 = USER_SEGMENT | PRESENT | WRITABLE | ACCESSED | LIMIT_0_15 | LIMIT_16_19 | GRANULARITY;
/// A kernel data segment (64-bit or flat 32-bit)
pub const KERNEL_DATA: u64 = COMMON | DEFAULT_SIZE;
/// A flat 32-bit kernel code segment
pub const KERNEL_CODE32: u64 = COMMON | EXECUTABLE | DEFAULT_SIZE;
/// A 64-bit kernel code segment
pub const KERNEL_CODE64: u64 = COMMON | EXECUTABLE | LONG_MODE;
/// A user data segment (64-bit or flat 32-bit)
pub const USER_DATA: u64 = KERNEL_DATA | DPL_RING_3;
/// A flat 32-bit user code segment
pub const USER_CODE32: u64 = KERNEL_CODE32 | DPL_RING_3;
/// A 64-bit user code segment
pub const USER_CODE64: u64 = KERNEL_CODE64 | DPL_RING_3;
/// Descriptor for a code or data segment.
///
/// Since segmentation is no longer supported in 64-bit mode, almost all of
/// code and data descriptors is ignored. Only some flags are still use
UserSegment: u64,
/// A system segment descriptor such as a LDT or TSS descriptor.
SystemSegment: SystemSegmentData,
pub const SystemSegmentData = struct {
low: u64,
high: u64,
};
test "Descriptors match linux" {
// Make sure our defaults match the ones used by the Linux kernel.
// Constants pulled from an old version of arch/x86/kernel/cpu/common.c
try std.testing.expectEqual(0x00af9b000000ffff, Descriptor.KERNEL_CODE64);
try std.testing.expectEqual(0x00cf9b000000ffff, Descriptor.KERNEL_CODE32);
try std.testing.expectEqual(0x00cf93000000ffff, Descriptor.KERNEL_DATA);
try std.testing.expectEqual(0x00affb000000ffff, Descriptor.USER_CODE64);
try std.testing.expectEqual(0x00cffb000000ffff, Descriptor.USER_CODE32);
try std.testing.expectEqual(0x00cff3000000ffff, Descriptor.USER_DATA);
}
comptime {
std.testing.refAllDecls(@This());
}
};
comptime {
std.testing.refAllDecls(@This());
} | src/structures/gdt.zig |
const std = @import("std");
const db = @import("db.zig");
pub fn main() anyerror!void {
var gpalloc = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = &gpalloc.allocator;
const stderr = std.io.getStdErr().writer();
const stdout = std.io.getStdOut().writer();
if (@import("builtin").os.tag == .windows)
_ = system("chcp 65001");
const cwd = std.fs.cwd(); //Current directory folder
try stdout.writeAll(
\\ ⚡ Welcome to Handy-Unicode Zig (huz) ⚡
\\(If the lightning bolt character didn't render, make sure your terminal is set up for UTF-8 support)
\\Write "help" if you need any 📕
\\
);
var db_exists = try db.checkDbExists();
try db.openDb();
defer db.closeDb();
if (!db_exists) {
try stdout.writeAll("Creating the db from allkeys.txt for the first time ⏳ (This could take a few minutes, do not close the program)\n");
var timer = try std.time.Timer.start();
try db.createTable();
{
const file = cwd.openFile("allkeys.txt", .{ .read = true }) catch |err| switch (err) {
error.FileNotFound, error.AccessDenied => {
try stderr.print("Could not open allkeys.txt 😢 ({})", .{err});
return;
},
else => return err,
};
try db.parseFileAndFillDb(file);
}
try stdout.print("Done! (took {}s)\n", .{@divTrunc(timer.read(), 1_000_000_000)});
}
var buffer: [1024]u8 = undefined;
while (try prompt(buffer[0..])) |_line| {
var buf2: [1024]u8 = undefined;
var line = _line;
line.ptr = &buf2;
line.len = std.mem.replacementSize(u8, _line, "\x0D", "");
_ = std.mem.replace(u8, _line, "\x0D", "", line);
if (line.len != 0) {
switch (line[0]) {
':' => {
try db.setSearch(allocator, line[1..]);
db.runQuery(allocator) catch |err| {
if (err == error.UnsafeQuery) {
try stderr.writeAll("Search has special characters and is unsafe at the moment. Please only use alphanum 🔠🔢\n");
} else return err;
};
},
'1'...'8' => {
var index: u3 = @truncate(u3, line[0] - '1');
db.select(allocator, index) catch |err| switch (err) {
error.doesNotExist => try stderr.print("Last search page does not have a result with index {c} 🤔\n", .{line[0]}),
else => return err,
};
},
//'a' => try db.testing.printAll(),
'q' => break,
'h' => try showHelp(),
else => try stderr.writeAll("Invalid command. Type \"help\" 📕\n"),
}
} else {
db.runQuery(allocator) catch |err| {
if (err == error.noSearch) {
try stderr.writeAll("No search was started. Write\":some words\" to start a query! 👓\n");
} else return err;
};
}
}
db.deallocQuery(allocator);
db.deallocSearch(allocator);
try stdout.writeAll("\nBye bye!\n");
}
fn prompt(buffer: []u8) !?[]u8 {
const stdout = std.io.getStdOut().writer();
const stdin = std.io.getStdIn().reader();
try stdout.writeAll("(⚡huz) > ");
return stdin.readUntilDelimiterOrEof(buffer, '\n');
}
fn showHelp() !void {
try std.io.getStdOut().writer().writeAll(@embedFile("help.txt"));
}
extern fn system(command: [*c]const u8) c_int; | src/main.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.