code
stringlengths 38
801k
| repo_path
stringlengths 6
263
|
|---|---|
// Altered source. Added: toArray. Altered: lookAt, perspective. Made column major. Removed Vec2/Vec4. Only kept necessary methods for examples. removed tests
const std = @import("std");
pub const Vec3 = extern struct {
const Self = @This();
x: f32,
y: f32,
z: f32,
pub fn length2(a: Self) f32 {
return Self.dot(a, a);
}
pub fn length(a: Self) f32 {
return std.math.sqrt(a.length2());
}
pub fn dot(a: Self, b: Self) f32 {
var result: f32 = 0;
inline for (@typeInfo(Self).Struct.fields) |fld| {
result += @field(a, fld.name) * @field(b, fld.name);
}
return result;
}
pub fn new(x: f32, y: f32, z: f32) Vec3 {
return Vec3{
.x = x,
.y = y,
.z = z,
};
}
pub fn scale(a: Self, b: f32) Self {
var result: Self = undefined;
inline for (@typeInfo(Self).Struct.fields) |fld| {
@field(result, fld.name) = @field(a, fld.name) * b;
}
return result;
}
pub fn cross(a: Self, b: Self) Self {
return Self{
.x = a.y * b.z - a.z * b.y,
.y = a.z * b.x - a.x * b.z,
.z = a.x * b.y - a.y * b.x,
};
}
pub fn normalize(vec: Self) Self {
return vec.scale(1.0 / vec.length());
}
pub fn sub(a: Self, b: Self) Self {
var result: Self = undefined;
inline for (@typeInfo(Self).Struct.fields) |fld| {
@field(result, fld.name) = @field(a, fld.name) - @field(b, fld.name);
}
return result;
}
};
pub const Mat4 = extern struct {
pub const Self = @This();
fields: [4][4]f32, // [col][row]
pub const zero = Self{
.fields = [4][4]f32{
[4]f32{ 0, 0, 0, 0 },
[4]f32{ 0, 0, 0, 0 },
[4]f32{ 0, 0, 0, 0 },
[4]f32{ 0, 0, 0, 0 },
},
};
pub const identity = Self{
.fields = [4][4]f32{
[4]f32{ 1, 0, 0, 0 },
[4]f32{ 0, 1, 0, 0 },
[4]f32{ 0, 0, 1, 0 },
[4]f32{ 0, 0, 0, 1 },
},
};
pub fn mul(a: Self, b: Self) Self {
var result: Self = undefined;
inline for ([_]comptime_int{ 0, 1, 2, 3 }) |col| {
inline for ([_]comptime_int{ 0, 1, 2, 3 }) |row| {
var sum: f32 = 0.0;
inline for ([_]comptime_int{ 0, 1, 2, 3 }) |i| {
sum += a.fields[i][row] * b.fields[col][i];
}
result.fields[col][row] = sum;
}
}
return result;
}
// taken from GLM implementation
pub fn createLook(eye: Vec3, direction: Vec3, up: Vec3) Self {
const f = direction.normalize();
const s = Vec3.cross(up, f).normalize();
const u = Vec3.cross(f, s);
var result = Self.identity;
result.fields[0][0] = s.x;
result.fields[1][0] = s.y;
result.fields[2][0] = s.z;
result.fields[0][1] = u.x;
result.fields[1][1] = u.y;
result.fields[2][1] = u.z;
result.fields[0][2] = f.x;
result.fields[1][2] = f.y;
result.fields[2][2] = f.z;
result.fields[3][0] = -Vec3.dot(s, eye);
result.fields[3][1] = -Vec3.dot(u, eye);
result.fields[3][2] = -Vec3.dot(f, eye);
return result;
}
pub fn createLookAt(eye: Vec3, center: Vec3, up: Vec3) Self {
return createLook(eye, Vec3.sub(eye, center), up);
}
// taken from GLM implementation
pub fn createPerspective(fov: f32, aspect: f32, near: f32, far: f32) Self {
std.debug.assert(std.math.fabs(aspect - 0.001) > 0);
std.debug.assert(far > near);
const tanHalfFov = std.math.tan(fov / 2);
var result = Self.zero;
result.fields[0][0] = 1.0 / (aspect * tanHalfFov);
result.fields[1][1] = 1.0 / (tanHalfFov);
result.fields[2][2] = -(far + near) / (far - near);
result.fields[2][3] = -1.0;
result.fields[3][2] = -(2.0 * far * near) / (far - near);
return result;
}
pub fn createAngleAxis(axis: Vec3, angle: f32) Self {
var cos = std.math.cos(angle);
var sin = std.math.sin(angle);
var x = axis.x;
var y = axis.y;
var z = axis.z;
return Self{
.fields = [4][4]f32{
[4]f32{ cos + x * x * (1 - cos), x * y * (1 - cos) - z * sin, x * z * (1 - cos) + y * sin, 0 },
[4]f32{ y * x * (1 - cos) + z * sin, cos + y * y * (1 - cos), y * z * (1 - cos) - x * sin, 0 },
[4]f32{ z * x * (1 * cos) - y * sin, z * y * (1 - cos) + x * sin, cos + z * z * (1 - cos), 0 },
[4]f32{ 0, 0, 0, 1 },
},
};
}
pub fn createOrthogonal(left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32) Self {
var result = Self.identity;
result.fields[0][0] = 2 / (right - left);
result.fields[1][1] = 2 / (top - bottom);
result.fields[2][2] = 1 / (far - near);
result.fields[3][0] = -(right + left) / (right - left);
result.fields[3][1] = -(top + bottom) / (top - bottom);
result.fields[3][2] = -near / (far - near);
return result;
}
pub fn toArray(m: Self) [16]f32 {
var result: [16]f32 = undefined;
var i :usize = 0;
inline for ([_]comptime_int{ 0, 1, 2, 3 }) |col| {
inline for ([_]comptime_int{ 0, 1, 2, 3 }) |row| {
result[i] = m.fields[col][row];
i += 1;
}
}
return result;
}
}; | src/math3d.zig |
const std = @import("std");
const c = @import("main.zig").c;
// Description of a glyph on the atlas i.e. a rectangle on the atlas which
// contains pixels of a glyph that can be found at the 'idx' in the atlas dict.
const AtlasGlyph = struct {
idx: u8,
rect: c.mu_Rect,
};
pub const dict: [256]c.mu_Rect = atlasDictGen(256, elements[0..]);
pub const white: u32 = c.MU_ICON_MAX;
pub const font: u32 = 0;
pub const scale: u16 = 2; // Scale of atlas exported from Aseprite
pub const height: u16 = 256 * scale;
pub const width: u16 = 256 * scale;
fn atlasRect(x: u32, y: u32, w: u32, h: u32) c.mu_Rect {
return .{ .y = @intCast(c_int, y), .x = @intCast(c_int, x), .w = @intCast(c_int, w), .h = @intCast(c_int, h) };
}
fn atlasGlyph(atlas_idx: u8, rect: c.mu_Rect) AtlasGlyph {
return AtlasGlyph{ .idx = atlas_idx, .rect = rect };
}
fn atlasDictGen(comptime dict_len: u32, comptime els: []const AtlasGlyph) [dict_len]c.mu_Rect {
var dict_buf: [dict_len]c.mu_Rect = std.mem.zeroes([dict_len]c.mu_Rect);
for (els) |el| {
const rect: c.mu_Rect = el.rect;
dict_buf[el.idx] = c.mu_Rect{ .x = rect.x * scale, .y = rect.y * scale, .w = rect.w * scale, .h = rect.h * scale };
}
return dict_buf;
}
const elements = [_]AtlasGlyph{
atlasGlyph(font + 'a', atlasRect(0, 0, 8, 16)),
atlasGlyph(font + 'b', atlasRect(8, 0, 8, 16)),
atlasGlyph(font + 'c', atlasRect(16, 0, 8, 16)),
atlasGlyph(font + 'd', atlasRect(24, 0, 8, 16)),
atlasGlyph(font + 'e', atlasRect(32, 0, 8, 16)),
atlasGlyph(font + 'f', atlasRect(40, 0, 8, 16)),
atlasGlyph(font + 'g', atlasRect(48, 0, 8, 16)),
atlasGlyph(font + 'h', atlasRect(56, 0, 8, 16)),
atlasGlyph(font + 'i', atlasRect(64, 0, 8, 16)),
atlasGlyph(font + 'j', atlasRect(72, 0, 8, 16)),
atlasGlyph(font + 'k', atlasRect(80, 0, 8, 16)),
atlasGlyph(font + 'l', atlasRect(88, 0, 8, 16)),
atlasGlyph(font + 'm', atlasRect(96, 0, 8, 16)),
atlasGlyph(font + 'n', atlasRect(104, 0, 8, 16)),
atlasGlyph(font + 'o', atlasRect(112, 0, 8, 16)),
atlasGlyph(font + 'p', atlasRect(120, 0, 8, 16)),
atlasGlyph(font + 'q', atlasRect(128, 0, 8, 16)),
atlasGlyph(font + 'r', atlasRect(136, 0, 8, 16)),
atlasGlyph(font + 's', atlasRect(144, 0, 8, 16)),
atlasGlyph(font + 't', atlasRect(152, 0, 8, 16)),
atlasGlyph(font + 'u', atlasRect(160, 0, 8, 16)),
atlasGlyph(font + 'v', atlasRect(168, 0, 8, 16)),
atlasGlyph(font + 'w', atlasRect(176, 0, 8, 16)),
atlasGlyph(font + 'x', atlasRect(184, 0, 8, 16)),
atlasGlyph(font + 'y', atlasRect(192, 0, 8, 16)),
atlasGlyph(font + 'z', atlasRect(200, 0, 8, 16)),
//
atlasGlyph(font + 'A', atlasRect(0, 16, 8, 16)),
atlasGlyph(font + 'B', atlasRect(8, 16, 8, 16)),
atlasGlyph(font + 'C', atlasRect(16, 16, 8, 16)),
atlasGlyph(font + 'D', atlasRect(24, 16, 8, 16)),
atlasGlyph(font + 'E', atlasRect(32, 16, 8, 16)),
atlasGlyph(font + 'F', atlasRect(40, 16, 8, 16)),
atlasGlyph(font + 'G', atlasRect(48, 16, 8, 16)),
atlasGlyph(font + 'H', atlasRect(56, 16, 8, 16)),
atlasGlyph(font + 'I', atlasRect(64, 16, 8, 16)),
atlasGlyph(font + 'J', atlasRect(72, 16, 8, 16)),
atlasGlyph(font + 'K', atlasRect(80, 16, 8, 16)),
atlasGlyph(font + 'L', atlasRect(88, 16, 8, 16)),
atlasGlyph(font + 'M', atlasRect(96, 16, 8, 16)),
atlasGlyph(font + 'N', atlasRect(104, 16, 8, 16)),
atlasGlyph(font + 'O', atlasRect(112, 16, 8, 16)),
atlasGlyph(font + 'P', atlasRect(120, 16, 8, 16)),
atlasGlyph(font + 'Q', atlasRect(128, 16, 8, 16)),
atlasGlyph(font + 'R', atlasRect(136, 16, 8, 16)),
atlasGlyph(font + 'S', atlasRect(144, 16, 8, 16)),
atlasGlyph(font + 'T', atlasRect(152, 16, 8, 16)),
atlasGlyph(font + 'U', atlasRect(160, 16, 8, 16)),
atlasGlyph(font + 'V', atlasRect(168, 16, 8, 16)),
atlasGlyph(font + 'W', atlasRect(176, 16, 8, 16)),
atlasGlyph(font + 'X', atlasRect(184, 16, 8, 16)),
atlasGlyph(font + 'Y', atlasRect(192, 16, 8, 16)),
atlasGlyph(font + 'Z', atlasRect(200, 16, 8, 16)),
//
atlasGlyph(font + '0', atlasRect(0, 32, 8, 16)),
atlasGlyph(font + '1', atlasRect(8, 32, 8, 16)),
atlasGlyph(font + '2', atlasRect(16, 32, 8, 16)),
atlasGlyph(font + '3', atlasRect(24, 32, 8, 16)),
atlasGlyph(font + '4', atlasRect(32, 32, 8, 16)),
atlasGlyph(font + '5', atlasRect(40, 32, 8, 16)),
atlasGlyph(font + '6', atlasRect(48, 32, 8, 16)),
atlasGlyph(font + '7', atlasRect(56, 32, 8, 16)),
atlasGlyph(font + '8', atlasRect(64, 32, 8, 16)),
atlasGlyph(font + '9', atlasRect(72, 32, 8, 16)),
//
atlasGlyph(font + ' ', atlasRect(80, 32, 8, 16)),
atlasGlyph(font + '!', atlasRect(88, 32, 8, 16)),
atlasGlyph(font + '"', atlasRect(96, 32, 8, 16)),
atlasGlyph(font + '#', atlasRect(104, 32, 8, 16)),
atlasGlyph(font + '$', atlasRect(112, 32, 8, 16)),
atlasGlyph(font + '%', atlasRect(120, 32, 8, 16)),
atlasGlyph(font + '&', atlasRect(128, 32, 8, 16)),
atlasGlyph(font + '\'', atlasRect(136, 32, 8, 16)),
atlasGlyph(font + '(', atlasRect(144, 32, 8, 16)),
atlasGlyph(font + ')', atlasRect(152, 32, 8, 16)),
atlasGlyph(font + '*', atlasRect(160, 32, 8, 16)),
atlasGlyph(font + '+', atlasRect(168, 32, 8, 16)),
atlasGlyph(font + ',', atlasRect(176, 32, 8, 16)),
atlasGlyph(font + '-', atlasRect(184, 32, 8, 16)),
atlasGlyph(font + '.', atlasRect(192, 32, 8, 16)),
atlasGlyph(font + '/', atlasRect(200, 32, 8, 16)),
atlasGlyph(font + ':', atlasRect(0, 48, 8, 16)),
atlasGlyph(font + ';', atlasRect(8, 48, 8, 16)),
atlasGlyph(font + '<', atlasRect(16, 48, 8, 16)),
atlasGlyph(font + '=', atlasRect(24, 48, 8, 16)),
atlasGlyph(font + '>', atlasRect(32, 48, 8, 16)),
atlasGlyph(font + '?', atlasRect(40, 48, 8, 16)),
atlasGlyph(font + '@', atlasRect(48, 48, 8, 16)),
atlasGlyph(font + '[', atlasRect(56, 48, 8, 16)),
atlasGlyph(font + '\\', atlasRect(64, 48, 8, 16)),
atlasGlyph(font + ']', atlasRect(72, 48, 8, 16)),
atlasGlyph(font + '^', atlasRect(80, 48, 8, 16)),
atlasGlyph(font + '_', atlasRect(88, 48, 8, 16)),
atlasGlyph(font + '`', atlasRect(96, 48, 8, 16)),
atlasGlyph(font + '{', atlasRect(104, 48, 8, 16)),
atlasGlyph(font + '|', atlasRect(112, 48, 8, 16)),
atlasGlyph(font + '}', atlasRect(120, 48, 8, 16)),
atlasGlyph(font + '~', atlasRect(128, 48, 8, 16)),
atlasGlyph(font + 127, atlasRect(136, 48, 8, 16)), // missing
//
atlasGlyph(c.MU_ICON_CLOSE, atlasRect(144, 48, 16, 16)),
atlasGlyph(c.MU_ICON_CHECK, atlasRect(160, 48, 16, 16)),
atlasGlyph(c.MU_ICON_EXPANDED, atlasRect(175, 48, 16, 16)),
atlasGlyph(c.MU_ICON_COLLAPSED, atlasRect(192, 48, 16, 16)),
atlasGlyph(white, atlasRect(208, 0, 3, 3)),
}; | src/atlas.zig |
const std = @import("std");
const testing = std.testing;
/// Provides a set of renderers for gemtext documents.
pub const renderer = struct {
pub const gemtext = @import("renderers/gemtext.zig").render;
pub const html = @import("renderers/html.zig").render;
pub const markdown = @import("renderers/markdown.zig").render;
pub const rtf = @import("renderers/rtf.zig").render;
};
/// The type of a `Fragment`.
pub const FragmentType = std.meta.TagType(Fragment);
/// A fragment is a part of a gemini text document.
/// It is either a basic line or contains several lines grouped into logical units.
pub const Fragment = union(enum) {
const Self = @This();
empty,
paragraph: [:0]const u8,
preformatted: Preformatted,
quote: TextLines,
link: Link,
list: TextLines,
heading: Heading,
pub fn free(self: *Self, allocator: *std.mem.Allocator) void {
switch (self.*) {
.empty => {},
.paragraph => |text| allocator.free(text),
.preformatted => |*preformatted| {
if (preformatted.alt_text) |alt|
allocator.free(alt);
freeTextLines(&preformatted.text, allocator);
},
.quote => |*quote| freeTextLines(quote, allocator),
.link => |link| {
if (link.title) |title|
allocator.free(title);
allocator.free(link.href);
},
.list => |*list| freeTextLines(list, allocator),
.heading => |heading| allocator.free(heading.text),
}
self.* = undefined;
}
};
fn freeTextLines(lines: *TextLines, allocator: *std.mem.Allocator) void {
for (lines.lines) |line| {
allocator.free(line);
}
allocator.free(lines.lines);
}
/// A grouped set of lines that appear in the same kind of formatting.
pub const TextLines = struct {
lines: []const [:0]const u8,
};
pub const Level = enum {
h1,
h2,
h3,
};
pub const Heading = struct {
level: Level,
text: [:0]const u8,
};
pub const Preformatted = struct {
alt_text: ?[:0]const u8,
text: TextLines,
};
pub const Link = struct {
href: [:0]const u8,
title: ?[:0]const u8,
};
/// A gemini text document
pub const Document = struct {
const Self = @This();
arena: std.heap.ArenaAllocator,
fragments: std.ArrayList(Fragment),
pub fn init(allocator: *std.mem.Allocator) Self {
return Self{
.arena = std.heap.ArenaAllocator.init(allocator),
.fragments = std.ArrayList(Fragment).init(allocator),
};
}
pub fn deinit(self: *Self) void {
self.arena.deinit();
self.fragments.deinit();
}
/// Renders the document into canonical gemini text.
pub fn render(self: Self, writer: anytype) !void {
try renderer.gemtext(self.fragments.items, writer);
}
/// Parses a document from a text string.
pub fn parseString(allocator: *std.mem.Allocator, text: []const u8) !Document {
var stream = std.io.fixedBufferStream(text);
return parse(allocator, stream.reader());
}
/// Parses a document from a stream.
pub fn parse(allocator: *std.mem.Allocator, reader: anytype) !Document {
var doc = Document.init(allocator);
errdefer doc.deinit();
var parser = Parser.init(allocator);
defer parser.deinit();
while (true) {
var buffer: [1024]u8 = undefined;
const len = try reader.readAll(&buffer);
if (len == 0)
break;
var offset: usize = 0;
while (offset < len) {
var res = try parser.feed(&doc.arena.allocator, buffer[offset..len]);
offset += res.consumed;
if (res.fragment) |*frag| {
errdefer frag.free(&doc.arena.allocator);
try doc.fragments.append(frag.*);
}
}
}
if (try parser.finalize(&doc.arena.allocator)) |*frag| {
errdefer frag.free(&doc.arena.allocator);
try doc.fragments.append(frag.*);
}
return doc;
}
};
/// this declares the strippable whitespace in a gemini text line
const legal_whitespace = "\t ";
fn trimLine(input: []const u8) []const u8 {
return std.mem.trim(u8, input, legal_whitespace);
}
fn dupeAndTrim(allocator: *std.mem.Allocator, input: []const u8) ![:0]u8 {
return try allocator.dupeZ(
u8,
trimLine(input),
);
}
/// A gemtext asynchronous push parser that will be non-blocking.
pub const Parser = struct {
const Self = @This();
comptime {
if (@sizeOf(@This()) > 128)
@compileError("Please adjust the limit here and include/gemtext.h to use the new parser size!");
if (@alignOf(@This()) > 16)
@compileError("Please adjust the limit here and include/gemtext.h to use the new parser alignment!");
}
const State = enum {
default,
block_quote,
preformatted,
list,
};
pub const Result = struct {
/// The number of bytes that were consumed form the input slice.
consumed: usize,
/// The fragment that was parsed.
fragment: ?Fragment,
};
allocator: *std.mem.Allocator,
line_buffer: std.ArrayList(u8),
text_block_buffer: std.ArrayList([]u8),
state: State,
/// Initialize a new parser.
pub fn init(allocator: *std.mem.Allocator) Self {
return Self{
.allocator = allocator,
.line_buffer = std.ArrayList(u8).init(allocator),
.text_block_buffer = std.ArrayList([]u8).init(allocator),
.state = .default,
};
}
/// Destroy the parser and all its allocated memory.
pub fn deinit(self: *Self) void {
for (self.text_block_buffer.items) |string| {
self.allocator.free(string);
}
self.text_block_buffer.deinit();
self.line_buffer.deinit();
self.* = undefined;
}
/// Feed a slice into the parser.
/// This will continue parsing the gemtext document. `slice` is the next bytes in the
/// document byte sequence.
/// The result will contain both the number of `consumed` bytes in `slice` and a `fragment` if any line was detected.
/// `fragment_allocator` will be used to allocate the memory returned in `Fragment` if any.
pub fn feed(self: *Self, fragment_allocator: *std.mem.Allocator, slice: []const u8) !Result {
var offset: usize = 0;
main_loop: while (offset < slice.len) : (offset += 1) {
if (slice[offset] == '\n') {
var line = self.line_buffer.items;
if (line.len > 0 and line[line.len - 1] == '\r') {
line = line[0 .. line.len - 1];
}
if (self.state == .preformatted and !std.mem.startsWith(u8, line, "```")) {
// we are in a preformatted block that is not terminated right now...
const line_buffer = try self.allocator.dupe(u8, line);
errdefer self.allocator.free(line_buffer);
try self.text_block_buffer.append(line_buffer);
self.line_buffer.shrinkRetainingCapacity(0);
continue :main_loop;
} else if (std.mem.startsWith(u8, line, "* ")) {
switch (self.state) {
.block_quote => {
var res = Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .block_quote),
};
self.state = .default;
return res;
},
.preformatted => {
var res = Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .preformatted),
};
self.state = .default;
return res;
},
.list, .default => {},
}
if (self.state != .list)
std.debug.assert(self.text_block_buffer.items.len == 0);
self.state = .list;
const line_buffer = try self.allocator.dupe(u8, trimLine(line[2..]));
errdefer self.allocator.free(line_buffer);
try self.text_block_buffer.append(line_buffer);
self.line_buffer.shrinkRetainingCapacity(0);
continue :main_loop;
} else if (std.mem.startsWith(u8, line, ">")) {
switch (self.state) {
.list => {
var res = Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .list),
};
self.state = .default;
return res;
},
.preformatted => {
var res = Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .preformatted),
};
self.state = .default;
return res;
},
.block_quote, .default => {},
}
if (self.state != .block_quote)
std.debug.assert(self.text_block_buffer.items.len == 0);
self.state = .block_quote;
const line_buffer = try self.allocator.dupe(u8, trimLine(line[1..]));
errdefer self.allocator.free(line_buffer);
try self.text_block_buffer.append(line_buffer);
self.line_buffer.shrinkRetainingCapacity(0);
continue :main_loop;
} else if (std.mem.startsWith(u8, line, "```")) {
switch (self.state) {
.list => {
self.state = .default;
return Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .list),
};
},
.block_quote => {
self.state = .default;
return Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = try self.createBlockFragment(fragment_allocator, .block_quote),
};
},
.preformatted => {
self.state = .default;
self.line_buffer.shrinkRetainingCapacity(0);
return Result{
.consumed = offset + 1,
.fragment = try self.createBlockFragment(fragment_allocator, .preformatted),
};
},
.default => {
std.debug.assert(self.text_block_buffer.items.len == 0);
self.state = .preformatted;
// preformatted text blocks are prefixed with a line that stores the alt text.
// if the alt text string is empty, we're storing a `null` there later.
const line_buffer = try self.allocator.dupe(u8, trimLine(line[3..]));
errdefer self.allocator.free(line_buffer);
try self.text_block_buffer.append(line_buffer);
self.line_buffer.shrinkRetainingCapacity(0);
continue :main_loop;
},
}
unreachable;
}
// If we get here, we are reading a line that is not in the block anymore, so
// we need to finalize and emit that block, then return that fragment
if (try self.createBlockFragmentFromStateAndResetState(fragment_allocator)) |fragment| {
return Result{
.consumed = offset, // one less so we will land here the next round again
.fragment = fragment,
};
}
// The defer must be after the processing of multi-line blocks, otherwise
// we lose the current line info.
defer self.line_buffer.shrinkRetainingCapacity(0);
std.debug.assert(self.state == .default);
var fragment: Fragment = if (std.mem.eql(u8, trimLine(line), ""))
Fragment{ .empty = {} }
else if (std.mem.startsWith(u8, line, "###"))
Fragment{ .heading = Heading{ .level = .h3, .text = try dupeAndTrim(fragment_allocator, line[3..]) } }
else if (std.mem.startsWith(u8, line, "##"))
Fragment{ .heading = Heading{ .level = .h2, .text = try dupeAndTrim(fragment_allocator, line[2..]) } }
else if (std.mem.startsWith(u8, line, "#"))
Fragment{ .heading = Heading{ .level = .h1, .text = try dupeAndTrim(fragment_allocator, line[1..]) } }
else if (std.mem.startsWith(u8, line, "=>")) blk: {
const temp = trimLine(line[2..]);
for (temp) |c, i| {
const str = [_]u8{c};
if (std.mem.indexOf(u8, legal_whitespace, &str) != null) {
break :blk Fragment{ .link = Link{
.href = try dupeAndTrim(fragment_allocator, trimLine(temp[0..i])),
.title = try dupeAndTrim(fragment_allocator, trimLine(temp[i + 1 ..])),
} };
}
} else {
break :blk Fragment{ .link = Link{
.href = try dupeAndTrim(fragment_allocator, temp),
.title = null,
} };
}
} else Fragment{ .paragraph = try dupeAndTrim(fragment_allocator, line) };
return Result{
.consumed = offset + 1,
.fragment = fragment,
};
} else {
try self.line_buffer.append(slice[offset]);
}
}
return Result{
.consumed = slice.len,
.fragment = null,
};
}
/// Notifies the parser that we've reached the end of the document.
/// This funtion makes sure every block is terminated properly and returned
/// even if the last line is not terminated.
/// `fragment_allocator` will be used to allocate the memory returned in `Fragment` if any.
pub fn finalize(self: *Self, fragment_allocator: *std.mem.Allocator) !?Fragment {
// for default state and an empty line, we can be sure that there is nothing
// to be done. If the line is empty, but we're still in a block, we still have to terminate
// that block to be sure
if (self.state == .default and self.line_buffer.items.len == 0)
return null;
// feed a line end sequence to guaranteed termination of the current line.
// This will either finish a normal line or complete the current block.
var res = try self.feed(fragment_allocator, "\n");
// when we get a fragment, we ended a normal line
if (res.fragment != null)
return res.fragment.?;
// if not, we are currently parsing a block and must now convert the block
// into a fragment.
std.debug.assert(self.state != .default);
var frag_or_null = try self.createBlockFragmentFromStateAndResetState(fragment_allocator);
return frag_or_null orelse unreachable;
}
const BlockType = enum { preformatted, block_quote, list };
fn createBlockFragment(self: *Self, fragment_allocator: *std.mem.Allocator, fragment_type: BlockType) !Fragment {
var alt_text: ?[:0]const u8 = if (fragment_type == .preformatted) blk: {
std.debug.assert(self.text_block_buffer.items.len > 0);
const src_alt_text = self.text_block_buffer.orderedRemove(0);
defer self.allocator.free(src_alt_text);
break :blk if (!std.mem.eql(u8, src_alt_text, ""))
try fragment_allocator.dupeZ(u8, src_alt_text)
else
null;
} else null;
errdefer if (alt_text) |text|
fragment_allocator.free(text);
var lines = try fragment_allocator.alloc([:0]const u8, self.text_block_buffer.items.len);
errdefer fragment_allocator.free(lines);
var offset: usize = 0;
errdefer while (offset > 0) {
offset -= 1;
fragment_allocator.free(lines[offset]);
};
while (offset < lines.len) : (offset += 1) {
lines[offset] = try fragment_allocator.dupeZ(u8, self.text_block_buffer.items[offset]);
}
for (self.text_block_buffer.items) |item| {
self.allocator.free(item);
}
self.text_block_buffer.shrinkRetainingCapacity(0);
return switch (fragment_type) {
.preformatted => Fragment{ .preformatted = Preformatted{
.alt_text = alt_text,
.text = TextLines{ .lines = lines },
} },
.block_quote => Fragment{ .quote = TextLines{ .lines = lines } },
.list => Fragment{ .list = TextLines{ .lines = lines } },
};
}
fn createBlockFragmentFromStateAndResetState(self: *Self, fragment_allocator: *std.mem.Allocator) !?Fragment {
defer self.state = .default;
return switch (self.state) {
.block_quote => try self.createBlockFragment(fragment_allocator, .block_quote),
.preformatted => try self.createBlockFragment(fragment_allocator, .preformatted),
.list => try self.createBlockFragment(fragment_allocator, .list),
.default => null,
};
}
}; | src/gemtext.zig |
const std = @import("std");
const iup = @import("iup.zig");
const MainLoop = iup.MainLoop;
const Dialog = iup.Dialog;
const Button = iup.Button;
const MessageDlg = iup.MessageDlg;
const Multiline = iup.Multiline;
const Label = iup.Label;
const Text = iup.Text;
const VBox = iup.VBox;
const HBox = iup.HBox;
const Menu = iup.Menu;
const SubMenu = iup.SubMenu;
const Separator = iup.Separator;
const Fill = iup.Fill;
const Item = iup.Item;
const FileDlg = iup.FileDlg;
const Toggle = iup.Toggle;
var allocator: std.mem.Allocator = undefined;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
allocator = gpa.allocator();
try MainLoop.open();
defer MainLoop.close();
var notepad = try Notepad.init();
defer notepad.deinit();
try notepad.show();
try MainLoop.beginLoop();
}
pub const Notepad = struct {
main_dialog: *Dialog = undefined,
pub const statusbar_name = "statusbar";
pub const toolbar_name = "toolbar";
pub const multiline_name = "multiline";
pub const Self = @This();
pub fn init() !Self {
var instance = Self{};
try instance.createComponents();
return instance;
}
pub fn deinit(self: *Self) void {
self.main_dialog.deinit();
}
pub fn show(self: *Self) !void {
try self.main_dialog.showXY(.Center, .Center);
}
fn createComponents(self: *Self) !void {
self.main_dialog = try (Dialog.init()
.setSize(.Half, .Half)
.setTitle("Simple Notepad")
.setChildren(
.{
createMenu(self),
VBox.init()
.setChildren(
.{
createToolbar(self),
Multiline.init()
.setCaretCallback(onCarret)
.setName(multiline_name)
.setMultiline(true)
.setExpand(.Yes),
Label.init()
.setName(statusbar_name)
.setExpand(.Horizontal)
.setPadding(10, 5),
},
),
},
).unwrap());
}
fn createMenu(self: *Self) Menu.Initializer {
_ = self;
return Menu.init()
.setChildren(
.{
SubMenu.init()
.setTitle("File")
.setChildren(
.{
Item.init()
.setTitle("&Open ...\tCtrl+O")
.setActionCallback(onItemOpen),
Item.init()
.setTitle("&Save ...\tCtrl+S"),
Separator.init(),
Item.init()
.setTitle("Close")
.setActionCallback(onItemClose),
},
),
SubMenu.init()
.setTitle("Edit")
.setChildren(
.{
Item.init().setTitle("Find ...\tCtrl+F"),
Item.init().setTitle("&Go To ...\tCtrl+G")
.setActionCallback(onGoTo),
},
),
SubMenu.init()
.setTitle("Format")
.setChildren(
.{
Item.init().setTitle("Font ..."),
},
),
SubMenu.init()
.setTitle("View")
.setChildren(
.{
Item.init().setTitle("Toolbar")
.setActionCallback(onToggleToolbar)
.setAutoToggle(true)
.setValue(.On),
Item.init().setTitle("Statusbar")
.setActionCallback(onToggleStatusbar)
.setAutoToggle(true)
.setValue(.On),
},
),
SubMenu.init()
.setTitle("Help")
.setChildren(
.{
Item.init().setTitle("About ..."),
},
),
},
);
}
fn createToolbar(_: *Self) HBox.Initializer {
return HBox.init()
.setName(toolbar_name)
.setMargin(5, 5)
.setGap(2)
.setChildren(
.{
Button.init()
.setActionCallback(onButtonOpen)
.setCanFocus(false)
.setFlat(true)
.setTip("Open (Crtl+O)")
.setImageHandleName("IUP_FileOpen"),
Button.init()
.setActionCallback(onButtonSave)
.setCanFocus(false)
.setFlat(true)
.setTip("Save (Crtl+S)")
.setImageHandleName("IUP_FileSave"),
Label.init().setSeparator(.Vertical),
Button.init()
.setActionCallback(onButtonFind)
.setCanFocus(false)
.setFlat(true)
.setTip("Find (Crtl+F)")
.setImageHandleName("IUP_EditFind"),
},
);
}
fn open(element: anytype) !void {
const filter = "Text Files|*.txt|All Files|*.*|";
var parent = element.getDialog() orelse unreachable;
var fileDlg: *FileDlg = try (FileDlg.init()
.setParentDialog(parent)
.setDialogType(.Open)
.setExtFilter(filter)
.unwrap());
defer fileDlg.deinit();
try fileDlg.popup(.CenterParent, .CenterParent);
if (fileDlg.getStatus() != .Cancelled) {
var fileName = fileDlg.getValue();
var file = std.fs.openFileAbsolute(fileName, .{}) catch {
return;
};
defer file.close();
var content = try file.readToEndAllocOptions(allocator, std.math.maxInt(u64), null, @alignOf(u8), 0);
defer allocator.free(content);
var text = element.getDialogChild(multiline_name).?.Multiline;
text.setValue(content);
try refreshStatusBar(text);
}
}
fn refreshStatusBar(sender: anytype) !void {
var text: *Multiline = sender.getDialogChild(multiline_name).?.Multiline;
var label: *Label = sender.getDialogChild(statusbar_name).?.Label;
var pos = text.getCaret();
var title = try std.fmt.allocPrintZ(allocator, "Lin {}, Col {}", .{ pos.lin, pos.col });
defer allocator.free(title);
label.setTitle(title);
}
fn find(text: *Multiline) !void {
_ = try find_dialog.popup(text);
}
fn onButtonOpen(button: *Button) !void {
try open(button);
}
fn onItemOpen(item: *Item) !void {
try open(item);
}
fn onButtonSave(_: *Button) !void {
//TODO
}
fn onButtonFind(button: *Button) !void {
var text = button.getDialogChild(multiline_name).?.Multiline;
try find(text);
}
fn onItemClose(_: *Item) !void {
MainLoop.close();
}
fn onGoTo(item: *Item) !void {
var text = item.getDialogChild(multiline_name).?.Multiline;
var success = try goto_dialog.popup(text);
if (success) try refreshStatusBar(item);
}
fn onToggleToolbar(item: *Item) !void {
var hbox = item.getDialogChild(toolbar_name).?.HBox;
var visible = if (item.getValue()) |value| value == .On else false;
hbox.setVisible(visible);
hbox.setFloating(if (visible) null else .Yes);
hbox.refresh();
}
fn onToggleStatusbar(item: *Item) !void {
var label = item.getDialogChild(statusbar_name).?.Label;
var visible = if (item.getValue()) |value| value == .On else false;
label.setVisible(visible);
label.setFloating(if (visible) null else .Yes);
label.refresh();
}
fn onCarret(text: *Multiline, lin: i32, col: i32, _: i32) !void {
_ = lin;
_ = col;
try refreshStatusBar(text);
}
};
const find_dialog = struct {
const multiline_name = "multiline";
const find_text_name = "find_text";
const case_toggle_name = "case";
///
/// Shows "Find" dialog
pub fn popup(text: *Multiline) !bool {
var parent = text.getDialog() orelse unreachable;
var dlg = createDialog(parent) catch unreachable;
defer dlg.deinit();
try dlg.popup(.CenterParent, .CenterParent);
return true;
}
fn onNext(button: *Button) !void {
try find(button);
}
fn onClose(button: *Button) !void {
var dialog = button.getDialog() orelse unreachable;
dialog.hide();
}
fn createDialog(parent: *Dialog) !*Dialog {
var multiline = parent.getDialogChild(multiline_name).?.Multiline;
var next_button: *Button = undefined;
var close_button: *Button = undefined;
return try (Dialog.init()
.setPtrAttribute(Multiline, multiline_name, multiline)
.setParentDialog(parent)
.setDialogFrame(true)
.setTitle("Find")
.setChildren(
.{
VBox.init()
.setMargin(10, 10)
.setGap(5)
.setChildren(
.{
Label.init()
.setTitle("Find what:"),
Text.init()
.setName(find_text_name)
.setVisibleColumns(20),
Toggle.init()
.setName(case_toggle_name)
.setTitle("Case sensitive"),
HBox.init()
.setNormalizeSize(.Horizontal)
.setChildren(
.{
Fill.init(),
Button.init()
.capture(&next_button)
.setActionCallback(onNext)
.setPadding(10, 2)
.setTitle("Find next"),
Button.init()
.capture(&close_button)
.setActionCallback(onClose)
.setPadding(10, 2)
.setTitle("Close"),
},
),
},
),
},
)
.setDefaultEsc(close_button)
.setDefaultEnter(next_button)
.unwrap());
}
fn find(element: anytype) !void {
var dlg = element.getDialog() orelse unreachable;
try MessageDlg.alert(dlg, null, "Not implemented!");
}
};
///
/// Goto-line dialog
const goto_dialog = struct {
const line_textbox = "line";
const line_count_attr = "line_count";
const go_to_attr = "go_to";
///
/// Shows "Go To line" dialog
pub fn popup(text: *Multiline) !bool {
var parent = text.getDialog() orelse unreachable;
var line_count = text.getLineCount();
var dlg = createDialog(parent, line_count) catch unreachable;
defer dlg.deinit();
try dlg.popup(.CenterParent, .CenterParent);
var go_to = dlg.getIntAttribute(go_to_attr);
if (go_to > 0) {
if (text.convertLinColToPos(go_to, 0)) |pos| {
text.setCaretPos(pos);
text.scrollTopOs(pos);
return true;
}
}
return false;
}
fn createDialog(parent: *Dialog, line_count: i32) !*Dialog {
var title = try std.fmt.allocPrintZ(allocator, "Line Number [1-{}]:", .{line_count});
defer allocator.free(title);
var ok_button: *Button = undefined;
var cancel_button: *Button = undefined;
return try (Dialog.init()
.setParentDialog(parent)
.setIntAttribute(line_count_attr, line_count)
.setTitle("Go To Line")
.setDialogFrame(true)
.setChildren(
.{
VBox.init()
.setMargin(10, 10)
.setGap(5)
.setChildren(
.{
Label.init()
.setTitle(title),
Text.init()
.setMask(iup.masks.u_int)
.setName(line_textbox)
.setVisibleColumns(20),
HBox.init().setChildren(
.{
Fill.init(),
Button.init()
.capture(&ok_button)
.setTitle("Go to line")
.setPadding(10, 2)
.setActionCallback(onButtonOk),
Button.init()
.capture(&cancel_button)
.setTitle("Cancel")
.setPadding(10, 2)
.setActionCallback(onButtonCancel),
},
),
},
),
},
)
.setDefaultEnter(ok_button)
.setDefaultEsc(cancel_button)
.unwrap());
}
fn onButtonOk(button: *Button) !void {
var dlg = button.getDialog() orelse unreachable;
var txt = dlg.getDialogChild(line_textbox).?.Text;
var go_to = std.fmt.parseInt(i32, txt.getValue(), 10) catch {
try MessageDlg.alert(dlg, null, "Invalid line number!");
return;
};
var line_count = dlg.getIntAttribute(line_count_attr);
if (go_to < 1 or go_to > line_count) {
try MessageDlg.alert(dlg, null, "Invalid line number!");
return;
}
dlg.setIntAttribute(go_to_attr, go_to);
dlg.hide();
}
fn onButtonCancel(button: *Button) !void {
var dlg = button.getDialog() orelse unreachable;
dlg.setIntAttribute(go_to_attr, 0);
dlg.hide();
}
}; | src/notepad_example.zig |
pub const PspGeContext = extern struct {
context: [512]c_uint,
};
pub const SceGeStack = extern struct {
stack: [8]c_uint,
};
pub const PspGeCallback = ?fn (c_int, ?*c_void) callconv(.C) void;
pub const PspGeCallbackData = extern struct {
signal_func: PspGeCallback,
signal_arg: ?*c_void,
finish_func: PspGeCallback,
finish_arg: ?*c_void,
};
pub const PspGeListArgs = extern struct {
size: c_uint,
context: [*c]PspGeContext,
numStacks: u32,
stacks: [*c]SceGeStack,
};
pub const PspGeBreakParam = extern struct {
buf: [4]c_uint,
};
pub const PspGeMatrixTypes = extern enum(c_int) {
Bone0 = 0,
Bone1 = 1,
Bone2 = 2,
Bone3 = 3,
Bone4 = 4,
Bone5 = 5,
Bone6 = 6,
Bone7 = 7,
World = 8,
View = 9,
Projection = 10,
Texgen = 11,
};
pub const PspGeStack = extern struct {
stack: [8]c_uint,
};
pub const PspGeListState = extern enum(c_int) {
Done = 0,
Queued = 1,
DrawingDone = 2,
StallReached = 3,
CancelDone = 4,
};
// Get the size of VRAM.
//
// @return The size of VRAM (in bytes).
pub extern fn sceGeEdramGetSize() c_uint;
// Get the eDRAM address.
//
// @return A pointer to the base of the eDRAM.
pub extern fn sceGeEdramGetAddr() ?*c_void;
// Retrieve the current value of a GE command.
//
// @param cmd - The GE command register to retrieve (0 to 0xFF, both included).
//
// @return The value of the GE command, < 0 on error.
pub extern fn sceGeGetCmd(cmd: c_int) c_uint;
// Retrieve a matrix of the given type.
//
// @param type - One of ::PspGeMatrixTypes.
// @param matrix - Pointer to a variable to store the matrix.
//
// @return < 0 on error.
pub extern fn sceGeGetMtx(typec: c_int, matrix: ?*c_void) c_int;
// Save the GE's current state.
//
// @param context - Pointer to a ::PspGeContext.
//
// @return < 0 on error.
pub extern fn sceGeSaveContext(context: [*c]PspGeContext) c_int;
// Restore a previously saved GE context.
//
// @param context - Pointer to a ::PspGeContext.
//
// @return < 0 on error.
pub extern fn sceGeRestoreContext(context: [*c]const PspGeContext) c_int;
// Enqueue a display list at the tail of the GE display list queue.
//
// @param list - The head of the list to queue.
// @param stall - The stall address.
// If NULL then no stall address is set and the list is transferred immediately.
// @param cbid - ID of the callback set by calling sceGeSetCallback
// @param arg - Structure containing GE context buffer address
//
// @return The ID of the queue, < 0 on error.
pub extern fn sceGeListEnQueue(list: ?*const c_void, stall: ?*c_void, cbid: c_int, arg: [*c]PspGeListArgs) c_int;
// Enqueue a display list at the head of the GE display list queue.
//
// @param list - The head of the list to queue.
// @param stall - The stall address.
// If NULL then no stall address is set and the list is transferred immediately.
// @param cbid - ID of the callback set by calling sceGeSetCallback
// @param arg - Structure containing GE context buffer address
//
// @return The ID of the queue, < 0 on error.
pub extern fn sceGeListEnQueueHead(list: ?*const c_void, stall: ?*c_void, cbid: c_int, arg: [*c]PspGeListArgs) c_int;
// Cancel a queued or running list.
//
// @param qid - The ID of the queue.
//
// @return < 0 on error.
pub extern fn sceGeListDeQueue(qid: c_int) c_int;
// Update the stall address for the specified queue.
//
// @param qid - The ID of the queue.
// @param stall - The new stall address.
//
// @return < 0 on error
pub extern fn sceGeListUpdateStallAddr(qid: c_int, stall: ?*c_void) c_int;
// Wait for syncronisation of a list.
//
// @param qid - The queue ID of the list to sync.
// @param syncType - 0 if you want to wait for the list to be completed, or 1 if you just want to peek the actual state.
//
// @return The specified queue status, one of ::PspGeListState.
pub extern fn sceGeListSync(qid: c_int, syncType: c_int) c_int;
// Wait for drawing to complete.
//
// @param syncType - 0 if you want to wait for the drawing to be completed, or 1 if you just want to peek the state of the display list currently being executed.
//
// @return The current queue status, one of ::PspGeListState.
pub extern fn sceGeDrawSync(syncType: c_int) c_int;
// Register callback handlers for the the GE.
//
// @param cb - Configured callback data structure.
//
// @return The callback ID, < 0 on error.
pub extern fn sceGeSetCallback(cb: *PspGeCallbackData) c_int;
// Unregister the callback handlers.
//
// @param cbid - The ID of the callbacks, returned by sceGeSetCallback().
//
// @return < 0 on error
pub extern fn sceGeUnsetCallback(cbid: c_int) c_int;
// Interrupt drawing queue.
//
// @param mode - If set to 1, reset all the queues.
// @param pParam - Unused (just K1-checked).
//
// @return The stopped queue ID if mode isn't set to 0, otherwise 0, and < 0 on error.
pub extern fn sceGeBreak(mode: c_int, pParam: [*c]PspGeBreakParam) c_int;
// Restart drawing queue.
//
// @return < 0 on error.
pub extern fn sceGeContinue() c_int;
// Set the eDRAM address translation mode.
//
// @param width - 0 to not set the translation width, otherwise 512, 1024, 2048 or 4096.
//
// @return The previous width if it was set, otherwise 0, < 0 on error.
pub extern fn sceGeEdramSetAddrTranslation(width: c_int) c_int; | src/psp/sdk/pspge.zig |
pub const CERT_COMPARE_SHIFT = @as(i32, 16);
pub const BCRYPT_OBJECT_ALIGNMENT = @as(u32, 16);
pub const KDF_HASH_ALGORITHM = @as(u32, 0);
pub const KDF_SECRET_PREPEND = @as(u32, 1);
pub const KDF_SECRET_APPEND = @as(u32, 2);
pub const KDF_HMAC_KEY = @as(u32, 3);
pub const KDF_TLS_PRF_LABEL = @as(u32, 4);
pub const KDF_TLS_PRF_SEED = @as(u32, 5);
pub const KDF_SECRET_HANDLE = @as(u32, 6);
pub const KDF_TLS_PRF_PROTOCOL = @as(u32, 7);
pub const KDF_ALGORITHMID = @as(u32, 8);
pub const KDF_PARTYUINFO = @as(u32, 9);
pub const KDF_PARTYVINFO = @as(u32, 10);
pub const KDF_SUPPPUBINFO = @as(u32, 11);
pub const KDF_SUPPPRIVINFO = @as(u32, 12);
pub const KDF_LABEL = @as(u32, 13);
pub const KDF_CONTEXT = @as(u32, 14);
pub const KDF_SALT = @as(u32, 15);
pub const KDF_ITERATION_COUNT = @as(u32, 16);
pub const KDF_GENERIC_PARAMETER = @as(u32, 17);
pub const KDF_KEYBITLENGTH = @as(u32, 18);
pub const KDF_HKDF_SALT = @as(u32, 19);
pub const KDF_HKDF_INFO = @as(u32, 20);
pub const KDF_USE_SECRET_AS_HMAC_KEY_FLAG = @as(u32, 1);
pub const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION = @as(u32, 1);
pub const BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG = @as(u32, 1);
pub const BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG = @as(u32, 2);
pub const BCRYPT_SUPPORTED_PAD_ROUTER = @as(u32, 1);
pub const BCRYPT_SUPPORTED_PAD_PKCS1_ENC = @as(u32, 2);
pub const BCRYPT_SUPPORTED_PAD_PKCS1_SIG = @as(u32, 4);
pub const BCRYPT_SUPPORTED_PAD_OAEP = @as(u32, 8);
pub const BCRYPT_SUPPORTED_PAD_PSS = @as(u32, 16);
pub const BCRYPT_BLOCK_PADDING = @as(u32, 1);
pub const BCRYPT_PAD_PKCS1_OPTIONAL_HASH_OID = @as(u32, 16);
pub const BCRYPTBUFFER_VERSION = @as(u32, 0);
pub const BCRYPT_ECDH_PUBLIC_P256_MAGIC = @as(u32, 827016005);
pub const BCRYPT_ECDH_PRIVATE_P256_MAGIC = @as(u32, 843793221);
pub const BCRYPT_ECDH_PUBLIC_P384_MAGIC = @as(u32, 860570437);
pub const BCRYPT_ECDH_PRIVATE_P384_MAGIC = @as(u32, 877347653);
pub const BCRYPT_ECDH_PUBLIC_P521_MAGIC = @as(u32, 894124869);
pub const BCRYPT_ECDH_PRIVATE_P521_MAGIC = @as(u32, 910902085);
pub const BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC = @as(u32, 1347109701);
pub const BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC = @as(u32, 1447772997);
pub const BCRYPT_ECDSA_PUBLIC_P256_MAGIC = @as(u32, 827540293);
pub const BCRYPT_ECDSA_PRIVATE_P256_MAGIC = @as(u32, 844317509);
pub const BCRYPT_ECDSA_PUBLIC_P384_MAGIC = @as(u32, 861094725);
pub const BCRYPT_ECDSA_PRIVATE_P384_MAGIC = @as(u32, 877871941);
pub const BCRYPT_ECDSA_PUBLIC_P521_MAGIC = @as(u32, 894649157);
pub const BCRYPT_ECDSA_PRIVATE_P521_MAGIC = @as(u32, 911426373);
pub const BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC = @as(u32, 1346650949);
pub const BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC = @as(u32, 1447314245);
pub const BCRYPT_ECC_FULLKEY_BLOB_V1 = @as(u32, 1);
pub const BCRYPT_DH_PARAMETERS_MAGIC = @as(u32, 1297107012);
pub const BCRYPT_DSA_PUBLIC_MAGIC_V2 = @as(u32, 843206724);
pub const BCRYPT_DSA_PRIVATE_MAGIC_V2 = @as(u32, 844517444);
pub const BCRYPT_KEY_DATA_BLOB_MAGIC = @as(u32, 1296188491);
pub const BCRYPT_KEY_DATA_BLOB_VERSION1 = @as(u32, 1);
pub const BCRYPT_DSA_PARAMETERS_MAGIC = @as(u32, 1297109828);
pub const BCRYPT_DSA_PARAMETERS_MAGIC_V2 = @as(u32, 843927620);
pub const BCRYPT_ECC_PARAMETERS_MAGIC = @as(u32, 1346585413);
pub const BCRYPT_KEY_DERIVATION_INTERFACE = @as(u32, 7);
pub const BCRYPT_MD2_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 1));
pub const BCRYPT_MD4_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 17));
pub const BCRYPT_MD5_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 33));
pub const BCRYPT_SHA1_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 49));
pub const BCRYPT_SHA256_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 65));
pub const BCRYPT_SHA384_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 81));
pub const BCRYPT_SHA512_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 97));
pub const BCRYPT_RC4_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 113));
pub const BCRYPT_RNG_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 129));
pub const BCRYPT_HMAC_MD5_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 145));
pub const BCRYPT_HMAC_SHA1_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 161));
pub const BCRYPT_HMAC_SHA256_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 177));
pub const BCRYPT_HMAC_SHA384_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 193));
pub const BCRYPT_HMAC_SHA512_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 209));
pub const BCRYPT_RSA_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 225));
pub const BCRYPT_ECDSA_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 241));
pub const BCRYPT_AES_CMAC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 257));
pub const BCRYPT_AES_GMAC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 273));
pub const BCRYPT_HMAC_MD2_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 289));
pub const BCRYPT_HMAC_MD4_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 305));
pub const BCRYPT_3DES_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 321));
pub const BCRYPT_3DES_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 337));
pub const BCRYPT_3DES_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 353));
pub const BCRYPT_3DES_112_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 369));
pub const BCRYPT_3DES_112_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 385));
pub const BCRYPT_3DES_112_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 401));
pub const BCRYPT_AES_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 417));
pub const BCRYPT_AES_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 433));
pub const BCRYPT_AES_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 449));
pub const BCRYPT_AES_CCM_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 465));
pub const BCRYPT_AES_GCM_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 481));
pub const BCRYPT_DES_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 497));
pub const BCRYPT_DES_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 513));
pub const BCRYPT_DES_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 529));
pub const BCRYPT_DESX_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 545));
pub const BCRYPT_DESX_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 561));
pub const BCRYPT_DESX_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 577));
pub const BCRYPT_RC2_CBC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 593));
pub const BCRYPT_RC2_ECB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 609));
pub const BCRYPT_RC2_CFB_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 625));
pub const BCRYPT_DH_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 641));
pub const BCRYPT_ECDH_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 657));
pub const BCRYPT_ECDH_P256_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 673));
pub const BCRYPT_ECDH_P384_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 689));
pub const BCRYPT_ECDH_P521_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 705));
pub const BCRYPT_DSA_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 721));
pub const BCRYPT_ECDSA_P256_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 737));
pub const BCRYPT_ECDSA_P384_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 753));
pub const BCRYPT_ECDSA_P521_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 769));
pub const BCRYPT_RSA_SIGN_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 785));
pub const BCRYPT_CAPI_KDF_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 801));
pub const BCRYPT_PBKDF2_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 817));
pub const BCRYPT_SP800108_CTR_HMAC_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 833));
pub const BCRYPT_SP80056A_CONCAT_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 849));
pub const BCRYPT_TLS1_1_KDF_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 865));
pub const BCRYPT_TLS1_2_KDF_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 881));
pub const BCRYPT_XTS_AES_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 897));
pub const BCRYPT_HKDF_ALG_HANDLE = @import("../../zig.zig").typedConst(BCRYPT_ALG_HANDLE, @as(u32, 913));
pub const BCRYPT_CAPI_AES_FLAG = @as(u32, 16);
pub const BCRYPT_MULTI_FLAG = @as(u32, 64);
pub const BCRYPT_TLS_CBC_HMAC_VERIFY_FLAG = @as(u32, 4);
pub const BCRYPT_BUFFERS_LOCKED_FLAG = @as(u32, 64);
pub const BCRYPT_EXTENDED_KEYSIZE = @as(u32, 128);
pub const BCRYPT_ENABLE_INCOMPATIBLE_FIPS_CHECKS = @as(u32, 256);
pub const BCRYPT_KEY_DERIVATION_OPERATION = @as(u32, 64);
pub const BCRYPT_PUBLIC_KEY_FLAG = @as(u32, 1);
pub const BCRYPT_PRIVATE_KEY_FLAG = @as(u32, 2);
pub const BCRYPT_NO_KEY_VALIDATION = @as(u32, 8);
pub const BCRYPT_RNG_USE_ENTROPY_IN_BUFFER = @as(u32, 1);
pub const BCRYPT_USE_SYSTEM_PREFERRED_RNG = @as(u32, 2);
pub const BCRYPT_HASH_INTERFACE_MAJORVERSION_2 = @as(u32, 2);
pub const CRYPT_OVERWRITE = @as(u32, 1);
pub const CRYPT_PRIORITY_TOP = @as(u32, 0);
pub const CRYPT_PRIORITY_BOTTOM = @as(u32, 4294967295);
pub const CRYTPDLG_FLAGS_MASK = @as(u32, 4278190080);
pub const CRYPTDLG_REVOCATION_DEFAULT = @as(u32, 0);
pub const CRYPTDLG_REVOCATION_ONLINE = @as(u32, 2147483648);
pub const CRYPTDLG_REVOCATION_CACHE = @as(u32, 1073741824);
pub const CRYPTDLG_REVOCATION_NONE = @as(u32, 536870912);
pub const CRYPTDLG_CACHE_ONLY_URL_RETRIEVAL = @as(u32, 268435456);
pub const CRYPTDLG_DISABLE_AIA = @as(u32, 134217728);
pub const CRYPTDLG_POLICY_MASK = @as(u32, 65535);
pub const POLICY_IGNORE_NON_CRITICAL_BC = @as(u32, 1);
pub const CRYPTDLG_ACTION_MASK = @as(u32, 4294901760);
pub const ACTION_REVOCATION_DEFAULT_ONLINE = @as(u32, 65536);
pub const ACTION_REVOCATION_DEFAULT_CACHE = @as(u32, 131072);
pub const CERT_DISPWELL_SELECT = @as(u32, 1);
pub const CERT_DISPWELL_TRUST_CA_CERT = @as(u32, 2);
pub const CERT_DISPWELL_TRUST_LEAF_CERT = @as(u32, 3);
pub const CERT_DISPWELL_TRUST_ADD_CA_CERT = @as(u32, 4);
pub const CERT_DISPWELL_TRUST_ADD_LEAF_CERT = @as(u32, 5);
pub const CERT_DISPWELL_DISTRUST_CA_CERT = @as(u32, 6);
pub const CERT_DISPWELL_DISTRUST_LEAF_CERT = @as(u32, 7);
pub const CERT_DISPWELL_DISTRUST_ADD_CA_CERT = @as(u32, 8);
pub const CERT_DISPWELL_DISTRUST_ADD_LEAF_CERT = @as(u32, 9);
pub const CSS_SELECTCERT_MASK = @as(u32, 16777215);
pub const SELCERT_PROPERTIES = @as(u32, 100);
pub const SELCERT_FINEPRINT = @as(u32, 101);
pub const SELCERT_CERTLIST = @as(u32, 102);
pub const SELCERT_ISSUED_TO = @as(u32, 103);
pub const SELCERT_VALIDITY = @as(u32, 104);
pub const SELCERT_ALGORITHM = @as(u32, 105);
pub const SELCERT_SERIAL_NUM = @as(u32, 106);
pub const SELCERT_THUMBPRINT = @as(u32, 107);
pub const CM_VIEWFLAGS_MASK = @as(u32, 16777215);
pub const CERTVIEW_CRYPTUI_LPARAM = @as(u32, 8388608);
pub const CERT_FILTER_OP_EXISTS = @as(u32, 1);
pub const CERT_FILTER_OP_NOT_EXISTS = @as(u32, 2);
pub const CERT_FILTER_OP_EQUALITY = @as(u32, 3);
pub const CERT_FILTER_INCLUDE_V1_CERTS = @as(u32, 1);
pub const CERT_FILTER_VALID_TIME_RANGE = @as(u32, 2);
pub const CERT_FILTER_VALID_SIGNATURE = @as(u32, 4);
pub const CERT_FILTER_LEAF_CERTS_ONLY = @as(u32, 8);
pub const CERT_FILTER_ISSUER_CERTS_ONLY = @as(u32, 16);
pub const CERT_FILTER_KEY_EXISTS = @as(u32, 32);
pub const CERT_VALIDITY_BEFORE_START = @as(u32, 1);
pub const CERT_VALIDITY_AFTER_END = @as(u32, 2);
pub const CERT_VALIDITY_SIGNATURE_FAILS = @as(u32, 4);
pub const CERT_VALIDITY_CERTIFICATE_REVOKED = @as(u32, 8);
pub const CERT_VALIDITY_KEY_USAGE_EXT_FAILURE = @as(u32, 16);
pub const CERT_VALIDITY_EXTENDED_USAGE_FAILURE = @as(u32, 32);
pub const CERT_VALIDITY_NAME_CONSTRAINTS_FAILURE = @as(u32, 64);
pub const CERT_VALIDITY_UNKNOWN_CRITICAL_EXTENSION = @as(u32, 128);
pub const CERT_VALIDITY_ISSUER_INVALID = @as(u32, 256);
pub const CERT_VALIDITY_OTHER_EXTENSION_FAILURE = @as(u32, 512);
pub const CERT_VALIDITY_PERIOD_NESTING_FAILURE = @as(u32, 1024);
pub const CERT_VALIDITY_OTHER_ERROR = @as(u32, 2048);
pub const CERT_VALIDITY_ISSUER_DISTRUST = @as(u32, 33554432);
pub const CERT_VALIDITY_EXPLICITLY_DISTRUSTED = @as(u32, 16777216);
pub const CERT_VALIDITY_NO_ISSUER_CERT_FOUND = @as(u32, 268435456);
pub const CERT_VALIDITY_NO_CRL_FOUND = @as(u32, 536870912);
pub const CERT_VALIDITY_CRL_OUT_OF_DATE = @as(u32, 1073741824);
pub const CERT_VALIDITY_NO_TRUST_DATA = @as(u32, 2147483648);
pub const CERT_VALIDITY_MASK_TRUST = @as(u32, 4294901760);
pub const CERT_VALIDITY_MASK_VALIDITY = @as(u32, 65535);
pub const CERT_TRUST_MASK = @as(u32, 16777215);
pub const CERT_TRUST_DO_FULL_SEARCH = @as(u32, 1);
pub const CERT_TRUST_PERMIT_MISSING_CRLS = @as(u32, 2);
pub const CERT_TRUST_DO_FULL_TRUST = @as(u32, 5);
pub const CERT_CREDENTIAL_PROVIDER_ID = @as(i32, -509);
pub const CRYPTUI_SELECT_ISSUEDTO_COLUMN = @as(u64, 1);
pub const CRYPTUI_SELECT_ISSUEDBY_COLUMN = @as(u64, 2);
pub const CRYPTUI_SELECT_INTENDEDUSE_COLUMN = @as(u64, 4);
pub const CRYPTUI_SELECT_FRIENDLYNAME_COLUMN = @as(u64, 8);
pub const CRYPTUI_SELECT_LOCATION_COLUMN = @as(u64, 16);
pub const CRYPTUI_SELECT_EXPIRATION_COLUMN = @as(u64, 32);
pub const CRYPTUI_CERT_MGR_TAB_MASK = @as(u32, 15);
pub const CRYPTUI_CERT_MGR_PUBLISHER_TAB = @as(u32, 4);
pub const CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG = @as(u32, 32768);
pub const CRYPTUI_WIZ_DIGITAL_SIGN_EXCLUDE_PAGE_HASHES = @as(u32, 2);
pub const CRYPTUI_WIZ_DIGITAL_SIGN_INCLUDE_PAGE_HASHES = @as(u32, 4);
pub const CRYPTUI_WIZ_EXPORT_FORMAT_SERIALIZED_CERT_STORE = @as(u32, 5);
pub const CRYPT_XML_BLOB_MAX = @as(u32, 2147483640);
pub const CRYPT_XML_ID_MAX = @as(u32, 256);
pub const CRYPT_XML_SIGNATURES_MAX = @as(u32, 16);
pub const CRYPT_XML_TRANSFORM_MAX = @as(u32, 16);
pub const CRYPT_XML_SIGNATURE_VALUE_MAX = @as(u32, 2048);
pub const CRYPT_XML_DIGEST_VALUE_MAX = @as(u32, 128);
pub const CRYPT_XML_OBJECTS_MAX = @as(u32, 256);
pub const CRYPT_XML_REFERENCES_MAX = @as(u32, 32760);
pub const CRYPT_XML_E_BASE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885376));
pub const CRYPT_XML_E_LARGE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885375));
pub const CRYPT_XML_E_TOO_MANY_TRANSFORMS = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885374));
pub const CRYPT_XML_E_ENCODING = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885373));
pub const CRYPT_XML_E_ALGORITHM = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885372));
pub const CRYPT_XML_E_TRANSFORM = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885371));
pub const CRYPT_XML_E_HANDLE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885370));
pub const CRYPT_XML_E_OPERATION = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885369));
pub const CRYPT_XML_E_UNRESOLVED_REFERENCE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885368));
pub const CRYPT_XML_E_INVALID_DIGEST = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885367));
pub const CRYPT_XML_E_INVALID_SIGNATURE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885366));
pub const CRYPT_XML_E_HASH_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885365));
pub const CRYPT_XML_E_SIGN_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885364));
pub const CRYPT_XML_E_VERIFY_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885363));
pub const CRYPT_XML_E_TOO_MANY_SIGNATURES = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885362));
pub const CRYPT_XML_E_INVALID_KEYVALUE = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885361));
pub const CRYPT_XML_E_UNEXPECTED_XML = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885360));
pub const CRYPT_XML_E_SIGNER = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885359));
pub const CRYPT_XML_E_NON_UNIQUE_ID = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885358));
pub const CRYPT_XML_E_LAST = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2146885358));
pub const CRYPT_XML_FLAG_ALWAYS_RETURN_ENCODED_OBJECT = @as(u32, 1073741824);
pub const CRYPT_XML_FLAG_ENFORCE_ID_NCNAME_FORMAT = @as(u32, 536870912);
pub const CRYPT_XML_FLAG_ENFORCE_ID_NAME_FORMAT = @as(u32, 134217728);
pub const CRYPT_XML_FLAG_ECDSA_DSIG11 = @as(u32, 67108864);
pub const CRYPT_XML_STATUS_NO_ERROR = @as(u32, 0);
pub const CRYPT_XML_FLAG_ADD_OBJECT_CREATE_COPY = @as(u32, 1);
pub const CRYPT_XML_FLAG_CREATE_REFERENCE_AS_OBJECT = @as(u32, 1);
pub const CRYPT_XML_DIGEST_REFERENCE_DATA_TRANSFORMED = @as(u32, 1);
pub const CRYPT_XML_GROUP_ID_HASH = @as(u32, 1);
pub const CRYPT_XML_GROUP_ID_SIGN = @as(u32, 2);
pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_URI = @as(u32, 1);
pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_NAME = @as(u32, 2);
pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_CNG_ALGID = @as(u32, 3);
pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_CNG_SIGN_ALGID = @as(u32, 4);
pub const NCRYPT_MAX_KEY_NAME_LENGTH = @as(u32, 512);
pub const NCRYPT_MAX_ALG_ID_LENGTH = @as(u32, 512);
pub const NCRYPT_KEY_PROTECTION_INTERFACE = @as(u32, 65540);
pub const NCRYPTBUFFER_VERSION = @as(u32, 0);
pub const NCRYPTBUFFER_EMPTY = @as(u32, 0);
pub const NCRYPTBUFFER_DATA = @as(u32, 1);
pub const NCRYPTBUFFER_PROTECTION_DESCRIPTOR_STRING = @as(u32, 3);
pub const NCRYPTBUFFER_PROTECTION_FLAGS = @as(u32, 4);
pub const NCRYPTBUFFER_SSL_CLIENT_RANDOM = @as(u32, 20);
pub const NCRYPTBUFFER_SSL_SERVER_RANDOM = @as(u32, 21);
pub const NCRYPTBUFFER_SSL_HIGHEST_VERSION = @as(u32, 22);
pub const NCRYPTBUFFER_SSL_CLEAR_KEY = @as(u32, 23);
pub const NCRYPTBUFFER_SSL_KEY_ARG_DATA = @as(u32, 24);
pub const NCRYPTBUFFER_SSL_SESSION_HASH = @as(u32, 25);
pub const NCRYPTBUFFER_PKCS_OID = @as(u32, 40);
pub const NCRYPTBUFFER_PKCS_ALG_OID = @as(u32, 41);
pub const NCRYPTBUFFER_PKCS_ALG_PARAM = @as(u32, 42);
pub const NCRYPTBUFFER_PKCS_ALG_ID = @as(u32, 43);
pub const NCRYPTBUFFER_PKCS_ATTRS = @as(u32, 44);
pub const NCRYPTBUFFER_PKCS_KEY_NAME = @as(u32, 45);
pub const NCRYPTBUFFER_PKCS_SECRET = @as(u32, 46);
pub const NCRYPTBUFFER_CERT_BLOB = @as(u32, 47);
pub const NCRYPTBUFFER_CLAIM_IDBINDING_NONCE = @as(u32, 48);
pub const NCRYPTBUFFER_CLAIM_KEYATTESTATION_NONCE = @as(u32, 49);
pub const NCRYPTBUFFER_KEY_PROPERTY_FLAGS = @as(u32, 50);
pub const NCRYPTBUFFER_ATTESTATIONSTATEMENT_BLOB = @as(u32, 51);
pub const NCRYPTBUFFER_ATTESTATION_CLAIM_TYPE = @as(u32, 52);
pub const NCRYPTBUFFER_ATTESTATION_CLAIM_CHALLENGE_REQUIRED = @as(u32, 53);
pub const NCRYPTBUFFER_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS = @as(u32, 54);
pub const NCRYPTBUFFER_ECC_CURVE_NAME = @as(u32, 60);
pub const NCRYPTBUFFER_ECC_PARAMETERS = @as(u32, 61);
pub const NCRYPTBUFFER_TPM_SEAL_PASSWORD = @as(u32, 70);
pub const NCRYPTBUFFER_TPM_SEAL_POLICYINFO = @as(u32, 71);
pub const NCRYPTBUFFER_TPM_SEAL_TICKET = @as(u32, 72);
pub const NCRYPTBUFFER_TPM_SEAL_NO_DA_PROTECTION = @as(u32, 73);
pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_PCR_MASK = @as(u32, 80);
pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_NONCE = @as(u32, 81);
pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_STATIC_CREATE = @as(u32, 82);
pub const NCRYPT_CIPHER_NO_PADDING_FLAG = @as(u32, 0);
pub const NCRYPT_CIPHER_BLOCK_PADDING_FLAG = @as(u32, 1);
pub const NCRYPT_CIPHER_OTHER_PADDING_FLAG = @as(u32, 2);
pub const NCRYPT_PLATFORM_ATTEST_MAGIC = @as(u32, 1146110288);
pub const NCRYPT_KEY_ATTEST_MAGIC = @as(u32, 1146110283);
pub const NCRYPT_CLAIM_AUTHORITY_ONLY = @as(u32, 1);
pub const NCRYPT_CLAIM_SUBJECT_ONLY = @as(u32, 2);
pub const NCRYPT_CLAIM_WEB_AUTH_SUBJECT_ONLY = @as(u32, 258);
pub const NCRYPT_CLAIM_AUTHORITY_AND_SUBJECT = @as(u32, 3);
pub const NCRYPT_CLAIM_VSM_KEY_ATTESTATION_STATEMENT = @as(u32, 4);
pub const NCRYPT_CLAIM_UNKNOWN = @as(u32, 4096);
pub const NCRYPT_CLAIM_PLATFORM = @as(u32, 65536);
pub const NCRYPT_ISOLATED_KEY_FLAG_CREATED_IN_ISOLATION = @as(u32, 1);
pub const NCRYPT_ISOLATED_KEY_FLAG_IMPORT_ONLY = @as(u32, 2);
pub const NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES_V0 = @as(u32, 0);
pub const NCRYPT_VSM_KEY_ATTESTATION_STATEMENT_V0 = @as(u32, 0);
pub const NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS_V0 = @as(u32, 0);
pub const NCRYPT_EXPORTED_ISOLATED_KEY_HEADER_V0 = @as(u32, 0);
pub const NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT_V0 = @as(u32, 0);
pub const NCRYPT_PAD_CIPHER_FLAG = @as(u32, 16);
pub const NCRYPT_ATTESTATION_FLAG = @as(u32, 32);
pub const NCRYPT_SEALING_FLAG = @as(u32, 256);
pub const NCRYPT_DO_NOT_FINALIZE_FLAG = @as(u32, 1024);
pub const NCRYPT_EXPORT_LEGACY_FLAG = @as(u32, 2048);
pub const NCRYPT_IGNORE_DEVICE_STATE_FLAG = @as(u32, 4096);
pub const NCRYPT_TREAT_NIST_AS_GENERIC_ECC_FLAG = @as(u32, 8192);
pub const NCRYPT_NO_CACHED_PASSWORD = @as(u32, 16384);
pub const NCRYPT_PROTECT_TO_LOCAL_SYSTEM = @as(u32, 32768);
pub const NCRYPT_PREFER_VIRTUAL_ISOLATION_FLAG = @as(u32, 65536);
pub const NCRYPT_USE_VIRTUAL_ISOLATION_FLAG = @as(u32, 131072);
pub const NCRYPT_USE_PER_BOOT_KEY_FLAG = @as(u32, 262144);
pub const NCRYPT_AUTHORITY_KEY_FLAG = @as(u32, 256);
pub const NCRYPT_TPM_PSS_SALT_SIZE_UNKNOWN = @as(u32, 0);
pub const NCRYPT_TPM_PSS_SALT_SIZE_MAXIMUM = @as(u32, 1);
pub const NCRYPT_TPM_PSS_SALT_SIZE_HASHSIZE = @as(u32, 2);
pub const NCRYPT_TPM_PAD_PSS_IGNORE_SALT = @as(u32, 32);
pub const IFX_RSA_KEYGEN_VUL_NOT_AFFECTED = @as(u32, 0);
pub const IFX_RSA_KEYGEN_VUL_AFFECTED_LEVEL_1 = @as(u32, 1);
pub const IFX_RSA_KEYGEN_VUL_AFFECTED_LEVEL_2 = @as(u32, 2);
pub const NCRYPT_TPM12_PROVIDER = @as(u32, 65536);
pub const NCRYPT_PCP_SIGNATURE_KEY = @as(u32, 1);
pub const NCRYPT_PCP_ENCRYPTION_KEY = @as(u32, 2);
pub const NCRYPT_PCP_STORAGE_KEY = @as(u32, 4);
pub const NCRYPT_PCP_IDENTITY_KEY = @as(u32, 8);
pub const NCRYPT_PCP_HMACVERIFICATION_KEY = @as(u32, 16);
pub const NCRYPT_MAX_PROPERTY_NAME = @as(u32, 64);
pub const NCRYPT_MAX_PROPERTY_DATA = @as(u32, 1048576);
pub const NCRYPT_ALLOW_EXPORT_FLAG = @as(u32, 1);
pub const NCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAG = @as(u32, 2);
pub const NCRYPT_ALLOW_ARCHIVING_FLAG = @as(u32, 4);
pub const NCRYPT_ALLOW_PLAINTEXT_ARCHIVING_FLAG = @as(u32, 8);
pub const NCRYPT_IMPL_HARDWARE_FLAG = @as(u32, 1);
pub const NCRYPT_IMPL_SOFTWARE_FLAG = @as(u32, 2);
pub const NCRYPT_IMPL_REMOVABLE_FLAG = @as(u32, 8);
pub const NCRYPT_IMPL_HARDWARE_RNG_FLAG = @as(u32, 16);
pub const NCRYPT_IMPL_VIRTUAL_ISOLATION_FLAG = @as(u32, 32);
pub const NCRYPT_ALLOW_DECRYPT_FLAG = @as(u32, 1);
pub const NCRYPT_ALLOW_SIGNING_FLAG = @as(u32, 2);
pub const NCRYPT_ALLOW_KEY_AGREEMENT_FLAG = @as(u32, 4);
pub const NCRYPT_ALLOW_KEY_IMPORT_FLAG = @as(u32, 8);
pub const NCRYPT_ALLOW_ALL_USAGES = @as(u32, 16777215);
pub const NCRYPT_UI_PROTECT_KEY_FLAG = @as(u32, 1);
pub const NCRYPT_UI_FORCE_HIGH_PROTECTION_FLAG = @as(u32, 2);
pub const NCRYPT_UI_FINGERPRINT_PROTECTION_FLAG = @as(u32, 4);
pub const NCRYPT_UI_APPCONTAINER_ACCESS_MEDIUM_FLAG = @as(u32, 8);
pub const NCRYPT_PIN_CACHE_DISABLE_DPL_FLAG = @as(u32, 1);
pub const NCRYPT_PIN_CACHE_REQUIRE_GESTURE_FLAG = @as(u32, 1);
pub const NCRYPT_PIN_CACHE_PIN_BYTE_LENGTH = @as(u32, 90);
pub const NCRYPT_PIN_CACHE_APPLICATION_TICKET_BYTE_LENGTH = @as(u32, 90);
pub const NCRYPT_PIN_CACHE_CLEAR_FOR_CALLING_PROCESS_OPTION = @as(u32, 1);
pub const NCRYPT_KEY_ACCESS_POLICY_VERSION = @as(u32, 1);
pub const NCRYPT_ALLOW_SILENT_KEY_ACCESS = @as(u32, 1);
pub const NCRYPT_CIPHER_KEY_BLOB_MAGIC = @as(u32, 1380470851);
pub const NCRYPT_KDF_KEY_BLOB_MAGIC = @as(u32, 826688587);
pub const NCRYPT_PROTECTED_KEY_BLOB_MAGIC = @as(u32, 1263817296);
pub const NCRYPT_TPM_LOADABLE_KEY_BLOB_MAGIC = @as(u32, 1297371211);
pub const NCRYPT_NAMED_DESCRIPTOR_FLAG = @as(u32, 1);
pub const NCRYPT_PROTECTION_INFO_TYPE_DESCRIPTOR_STRING = @as(u32, 1);
pub const ALG_CLASS_ANY = @as(u32, 0);
pub const ALG_CLASS_SIGNATURE = @as(u32, 8192);
pub const ALG_CLASS_MSG_ENCRYPT = @as(u32, 16384);
pub const ALG_CLASS_DATA_ENCRYPT = @as(u32, 24576);
pub const ALG_CLASS_HASH = @as(u32, 32768);
pub const ALG_CLASS_KEY_EXCHANGE = @as(u32, 40960);
pub const ALG_CLASS_ALL = @as(u32, 57344);
pub const ALG_TYPE_ANY = @as(u32, 0);
pub const ALG_TYPE_DSS = @as(u32, 512);
pub const ALG_TYPE_RSA = @as(u32, 1024);
pub const ALG_TYPE_BLOCK = @as(u32, 1536);
pub const ALG_TYPE_STREAM = @as(u32, 2048);
pub const ALG_TYPE_DH = @as(u32, 2560);
pub const ALG_TYPE_SECURECHANNEL = @as(u32, 3072);
pub const ALG_TYPE_ECDH = @as(u32, 3584);
pub const ALG_TYPE_THIRDPARTY = @as(u32, 4096);
pub const ALG_SID_ANY = @as(u32, 0);
pub const ALG_SID_THIRDPARTY_ANY = @as(u32, 0);
pub const ALG_SID_RSA_ANY = @as(u32, 0);
pub const ALG_SID_RSA_PKCS = @as(u32, 1);
pub const ALG_SID_RSA_MSATWORK = @as(u32, 2);
pub const ALG_SID_RSA_ENTRUST = @as(u32, 3);
pub const ALG_SID_RSA_PGP = @as(u32, 4);
pub const ALG_SID_DSS_ANY = @as(u32, 0);
pub const ALG_SID_DSS_PKCS = @as(u32, 1);
pub const ALG_SID_DSS_DMS = @as(u32, 2);
pub const ALG_SID_ECDSA = @as(u32, 3);
pub const ALG_SID_DES = @as(u32, 1);
pub const ALG_SID_3DES = @as(u32, 3);
pub const ALG_SID_DESX = @as(u32, 4);
pub const ALG_SID_IDEA = @as(u32, 5);
pub const ALG_SID_CAST = @as(u32, 6);
pub const ALG_SID_SAFERSK64 = @as(u32, 7);
pub const ALG_SID_SAFERSK128 = @as(u32, 8);
pub const ALG_SID_3DES_112 = @as(u32, 9);
pub const ALG_SID_CYLINK_MEK = @as(u32, 12);
pub const ALG_SID_RC5 = @as(u32, 13);
pub const ALG_SID_AES_128 = @as(u32, 14);
pub const ALG_SID_AES_192 = @as(u32, 15);
pub const ALG_SID_AES_256 = @as(u32, 16);
pub const ALG_SID_AES = @as(u32, 17);
pub const ALG_SID_SKIPJACK = @as(u32, 10);
pub const ALG_SID_TEK = @as(u32, 11);
pub const CRYPT_MODE_CBCI = @as(u32, 6);
pub const CRYPT_MODE_CFBP = @as(u32, 7);
pub const CRYPT_MODE_OFBP = @as(u32, 8);
pub const CRYPT_MODE_CBCOFM = @as(u32, 9);
pub const CRYPT_MODE_CBCOFMI = @as(u32, 10);
pub const ALG_SID_RC2 = @as(u32, 2);
pub const ALG_SID_RC4 = @as(u32, 1);
pub const ALG_SID_SEAL = @as(u32, 2);
pub const ALG_SID_DH_SANDF = @as(u32, 1);
pub const ALG_SID_DH_EPHEM = @as(u32, 2);
pub const ALG_SID_AGREED_KEY_ANY = @as(u32, 3);
pub const ALG_SID_KEA = @as(u32, 4);
pub const ALG_SID_ECDH = @as(u32, 5);
pub const ALG_SID_ECDH_EPHEM = @as(u32, 6);
pub const ALG_SID_MD2 = @as(u32, 1);
pub const ALG_SID_MD4 = @as(u32, 2);
pub const ALG_SID_MD5 = @as(u32, 3);
pub const ALG_SID_SHA = @as(u32, 4);
pub const ALG_SID_SHA1 = @as(u32, 4);
pub const ALG_SID_MAC = @as(u32, 5);
pub const ALG_SID_RIPEMD = @as(u32, 6);
pub const ALG_SID_RIPEMD160 = @as(u32, 7);
pub const ALG_SID_SSL3SHAMD5 = @as(u32, 8);
pub const ALG_SID_HMAC = @as(u32, 9);
pub const ALG_SID_TLS1PRF = @as(u32, 10);
pub const ALG_SID_HASH_REPLACE_OWF = @as(u32, 11);
pub const ALG_SID_SHA_256 = @as(u32, 12);
pub const ALG_SID_SHA_384 = @as(u32, 13);
pub const ALG_SID_SHA_512 = @as(u32, 14);
pub const ALG_SID_SSL3_MASTER = @as(u32, 1);
pub const ALG_SID_SCHANNEL_MASTER_HASH = @as(u32, 2);
pub const ALG_SID_SCHANNEL_MAC_KEY = @as(u32, 3);
pub const ALG_SID_PCT1_MASTER = @as(u32, 4);
pub const ALG_SID_SSL2_MASTER = @as(u32, 5);
pub const ALG_SID_TLS1_MASTER = @as(u32, 6);
pub const ALG_SID_SCHANNEL_ENC_KEY = @as(u32, 7);
pub const ALG_SID_ECMQV = @as(u32, 1);
pub const ALG_SID_EXAMPLE = @as(u32, 80);
pub const SIGNATURE_RESOURCE_NUMBER = @as(u32, 666);
pub const CRYPT_VERIFYCONTEXT = @as(u32, 4026531840);
pub const CRYPT_NEWKEYSET = @as(u32, 8);
pub const CRYPT_DELETEKEYSET = @as(u32, 16);
pub const CRYPT_SILENT = @as(u32, 64);
pub const CRYPT_DEFAULT_CONTAINER_OPTIONAL = @as(u32, 128);
pub const CRYPT_UPDATE_KEY = @as(u32, 8);
pub const CRYPT_USER_PROTECTED_STRONG = @as(u32, 1048576);
pub const RSA1024BIT_KEY = @as(u32, 67108864);
pub const CRYPT_SERVER = @as(u32, 1024);
pub const KEY_LENGTH_MASK = @as(u32, 4294901760);
pub const CRYPT_DECRYPT_RSA_NO_PADDING_CHECK = @as(u32, 32);
pub const CRYPT_SECRETDIGEST = @as(u32, 1);
pub const CRYPT_OWF_REPL_LM_HASH = @as(u32, 1);
pub const CRYPT_LITTLE_ENDIAN = @as(u32, 1);
pub const CRYPT_NOHASHOID = @as(u32, 1);
pub const CRYPT_TYPE2_FORMAT = @as(u32, 2);
pub const CRYPT_X931_FORMAT = @as(u32, 4);
pub const CRYPT_MACHINE_DEFAULT = @as(u32, 1);
pub const CRYPT_USER_DEFAULT = @as(u32, 2);
pub const CRYPT_DELETE_DEFAULT = @as(u32, 4);
pub const SIMPLEBLOB = @as(u32, 1);
pub const PUBLICKEYBLOB = @as(u32, 6);
pub const PRIVATEKEYBLOB = @as(u32, 7);
pub const PLAINTEXTKEYBLOB = @as(u32, 8);
pub const OPAQUEKEYBLOB = @as(u32, 9);
pub const PUBLICKEYBLOBEX = @as(u32, 10);
pub const SYMMETRICWRAPKEYBLOB = @as(u32, 11);
pub const KEYSTATEBLOB = @as(u32, 12);
pub const CRYPT_USERDATA = @as(u32, 1);
pub const KP_IV = @as(u32, 1);
pub const KP_PADDING = @as(u32, 3);
pub const KP_MODE = @as(u32, 4);
pub const KP_MODE_BITS = @as(u32, 5);
pub const KP_P = @as(u32, 11);
pub const KP_G = @as(u32, 12);
pub const KP_Q = @as(u32, 13);
pub const KP_X = @as(u32, 14);
pub const KP_Y = @as(u32, 15);
pub const KP_RA = @as(u32, 16);
pub const KP_RB = @as(u32, 17);
pub const KP_INFO = @as(u32, 18);
pub const KP_EFFECTIVE_KEYLEN = @as(u32, 19);
pub const KP_SCHANNEL_ALG = @as(u32, 20);
pub const KP_CLIENT_RANDOM = @as(u32, 21);
pub const KP_SERVER_RANDOM = @as(u32, 22);
pub const KP_RP = @as(u32, 23);
pub const KP_PRECOMP_MD5 = @as(u32, 24);
pub const KP_PRECOMP_SHA = @as(u32, 25);
pub const KP_CLEAR_KEY = @as(u32, 27);
pub const KP_PUB_EX_LEN = @as(u32, 28);
pub const KP_PUB_EX_VAL = @as(u32, 29);
pub const KP_KEYVAL = @as(u32, 30);
pub const KP_ADMIN_PIN = @as(u32, 31);
pub const KP_KEYEXCHANGE_PIN = @as(u32, 32);
pub const KP_SIGNATURE_PIN = @as(u32, 33);
pub const KP_PREHASH = @as(u32, 34);
pub const KP_ROUNDS = @as(u32, 35);
pub const KP_OAEP_PARAMS = @as(u32, 36);
pub const KP_CMS_KEY_INFO = @as(u32, 37);
pub const KP_CMS_DH_KEY_INFO = @as(u32, 38);
pub const KP_PUB_PARAMS = @as(u32, 39);
pub const KP_VERIFY_PARAMS = @as(u32, 40);
pub const KP_HIGHEST_VERSION = @as(u32, 41);
pub const KP_PIN_ID = @as(u32, 43);
pub const KP_PIN_INFO = @as(u32, 44);
pub const PKCS5_PADDING = @as(u32, 1);
pub const RANDOM_PADDING = @as(u32, 2);
pub const ZERO_PADDING = @as(u32, 3);
pub const CRYPT_MODE_CBC = @as(u32, 1);
pub const CRYPT_MODE_ECB = @as(u32, 2);
pub const CRYPT_MODE_OFB = @as(u32, 3);
pub const CRYPT_MODE_CFB = @as(u32, 4);
pub const CRYPT_MODE_CTS = @as(u32, 5);
pub const CRYPT_ENCRYPT = @as(u32, 1);
pub const CRYPT_DECRYPT = @as(u32, 2);
pub const CRYPT_EXPORT = @as(u32, 4);
pub const CRYPT_READ = @as(u32, 8);
pub const CRYPT_WRITE = @as(u32, 16);
pub const CRYPT_MAC = @as(u32, 32);
pub const CRYPT_EXPORT_KEY = @as(u32, 64);
pub const CRYPT_IMPORT_KEY = @as(u32, 128);
pub const CRYPT_ARCHIVE = @as(u32, 256);
pub const HP_ALGID = @as(u32, 1);
pub const HP_HASHSIZE = @as(u32, 4);
pub const HP_TLS1PRF_LABEL = @as(u32, 6);
pub const HP_TLS1PRF_SEED = @as(u32, 7);
pub const CRYPT_FAILED = @as(u32, 0);
pub const CRYPT_SUCCEED = @as(u32, 1);
pub const PP_ENUMALGS = @as(u32, 1);
pub const PP_ENUMCONTAINERS = @as(u32, 2);
pub const PP_IMPTYPE = @as(u32, 3);
pub const PP_NAME = @as(u32, 4);
pub const PP_VERSION = @as(u32, 5);
pub const PP_CONTAINER = @as(u32, 6);
pub const PP_CHANGE_PASSWORD = @as(u32, 7);
pub const PP_CERTCHAIN = @as(u32, 9);
pub const PP_KEY_TYPE_SUBTYPE = @as(u32, 10);
pub const PP_PROVTYPE = @as(u32, 16);
pub const PP_KEYSTORAGE = @as(u32, 17);
pub const PP_APPLI_CERT = @as(u32, 18);
pub const PP_SYM_KEYSIZE = @as(u32, 19);
pub const PP_SESSION_KEYSIZE = @as(u32, 20);
pub const PP_ENUMALGS_EX = @as(u32, 22);
pub const PP_ENUMMANDROOTS = @as(u32, 25);
pub const PP_ENUMELECTROOTS = @as(u32, 26);
pub const PP_KEYSET_TYPE = @as(u32, 27);
pub const PP_ADMIN_PIN = @as(u32, 31);
pub const PP_SIG_KEYSIZE_INC = @as(u32, 34);
pub const PP_KEYX_KEYSIZE_INC = @as(u32, 35);
pub const PP_UNIQUE_CONTAINER = @as(u32, 36);
pub const PP_SGC_INFO = @as(u32, 37);
pub const PP_KEYSPEC = @as(u32, 39);
pub const PP_ENUMEX_SIGNING_PROT = @as(u32, 40);
pub const PP_CRYPT_COUNT_KEY_USE = @as(u32, 41);
pub const PP_SMARTCARD_GUID = @as(u32, 45);
pub const PP_SMARTCARD_READER_ICON = @as(u32, 47);
pub const CRYPT_FIRST = @as(u32, 1);
pub const CRYPT_NEXT = @as(u32, 2);
pub const CRYPT_SGC_ENUM = @as(u32, 4);
pub const CRYPT_IMPL_HARDWARE = @as(u32, 1);
pub const CRYPT_IMPL_SOFTWARE = @as(u32, 2);
pub const CRYPT_IMPL_MIXED = @as(u32, 3);
pub const CRYPT_IMPL_UNKNOWN = @as(u32, 4);
pub const CRYPT_IMPL_REMOVABLE = @as(u32, 8);
pub const CRYPT_SEC_DESCR = @as(u32, 1);
pub const CRYPT_PSTORE = @as(u32, 2);
pub const CRYPT_UI_PROMPT = @as(u32, 4);
pub const CRYPT_FLAG_PCT1 = @as(u32, 1);
pub const CRYPT_FLAG_SSL2 = @as(u32, 2);
pub const CRYPT_FLAG_SSL3 = @as(u32, 4);
pub const CRYPT_FLAG_TLS1 = @as(u32, 8);
pub const CRYPT_FLAG_IPSEC = @as(u32, 16);
pub const CRYPT_FLAG_SIGNING = @as(u32, 32);
pub const CRYPT_SGC = @as(u32, 1);
pub const CRYPT_FASTSGC = @as(u32, 2);
pub const PP_CONTEXT_INFO = @as(u32, 11);
pub const PP_DISMISS_PIN_UI_SEC = @as(u32, 49);
pub const PROV_RSA_FULL = @as(u32, 1);
pub const PROV_RSA_SIG = @as(u32, 2);
pub const PROV_DSS = @as(u32, 3);
pub const PROV_FORTEZZA = @as(u32, 4);
pub const PROV_MS_EXCHANGE = @as(u32, 5);
pub const PROV_SSL = @as(u32, 6);
pub const PROV_RSA_SCHANNEL = @as(u32, 12);
pub const PROV_DSS_DH = @as(u32, 13);
pub const PROV_EC_ECDSA_SIG = @as(u32, 14);
pub const PROV_EC_ECNRA_SIG = @as(u32, 15);
pub const PROV_EC_ECDSA_FULL = @as(u32, 16);
pub const PROV_EC_ECNRA_FULL = @as(u32, 17);
pub const PROV_DH_SCHANNEL = @as(u32, 18);
pub const PROV_SPYRUS_LYNKS = @as(u32, 20);
pub const PROV_RNG = @as(u32, 21);
pub const PROV_INTEL_SEC = @as(u32, 22);
pub const PROV_REPLACE_OWF = @as(u32, 23);
pub const PROV_RSA_AES = @as(u32, 24);
pub const PROV_STT_MER = @as(u32, 7);
pub const PROV_STT_ACQ = @as(u32, 8);
pub const PROV_STT_BRND = @as(u32, 9);
pub const PROV_STT_ROOT = @as(u32, 10);
pub const PROV_STT_ISS = @as(u32, 11);
pub const MAXUIDLEN = @as(u32, 64);
pub const CUR_BLOB_VERSION = @as(u32, 2);
pub const SCHANNEL_MAC_KEY = @as(u32, 0);
pub const SCHANNEL_ENC_KEY = @as(u32, 1);
pub const INTERNATIONAL_USAGE = @as(u32, 1);
pub const CERT_RDN_TYPE_MASK = @as(u32, 255);
pub const CERT_RDN_FLAGS_MASK = @as(u32, 4278190080);
pub const CERT_RDN_ENABLE_T61_UNICODE_FLAG = @as(u32, 2147483648);
pub const CERT_RDN_ENABLE_UTF8_UNICODE_FLAG = @as(u32, 536870912);
pub const CERT_RDN_FORCE_UTF8_UNICODE_FLAG = @as(u32, 268435456);
pub const CERT_RDN_DISABLE_CHECK_TYPE_FLAG = @as(u32, 1073741824);
pub const CERT_RDN_DISABLE_IE4_UTF8_FLAG = @as(u32, 16777216);
pub const CERT_RDN_ENABLE_PUNYCODE_FLAG = @as(u32, 33554432);
pub const CRYPT_ECC_PRIVATE_KEY_INFO_v1 = @as(u32, 1);
pub const CERT_V1 = @as(u32, 0);
pub const CERT_V2 = @as(u32, 1);
pub const CERT_V3 = @as(u32, 2);
pub const CERT_INFO_VERSION_FLAG = @as(u32, 1);
pub const CERT_INFO_SERIAL_NUMBER_FLAG = @as(u32, 2);
pub const CERT_INFO_SIGNATURE_ALGORITHM_FLAG = @as(u32, 3);
pub const CERT_INFO_ISSUER_FLAG = @as(u32, 4);
pub const CERT_INFO_NOT_BEFORE_FLAG = @as(u32, 5);
pub const CERT_INFO_NOT_AFTER_FLAG = @as(u32, 6);
pub const CERT_INFO_SUBJECT_FLAG = @as(u32, 7);
pub const CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG = @as(u32, 8);
pub const CERT_INFO_ISSUER_UNIQUE_ID_FLAG = @as(u32, 9);
pub const CERT_INFO_SUBJECT_UNIQUE_ID_FLAG = @as(u32, 10);
pub const CERT_INFO_EXTENSION_FLAG = @as(u32, 11);
pub const CRL_V1 = @as(u32, 0);
pub const CRL_V2 = @as(u32, 1);
pub const CERT_BUNDLE_CERTIFICATE = @as(u32, 0);
pub const CERT_BUNDLE_CRL = @as(u32, 1);
pub const CERT_REQUEST_V1 = @as(u32, 0);
pub const CERT_KEYGEN_REQUEST_V1 = @as(u32, 0);
pub const CTL_V1 = @as(u32, 0);
pub const CERT_ENCODING_TYPE_MASK = @as(u32, 65535);
pub const CMSG_ENCODING_TYPE_MASK = @as(u32, 4294901760);
pub const CRYPT_ASN_ENCODING = @as(u32, 1);
pub const CRYPT_NDR_ENCODING = @as(u32, 2);
pub const X509_NDR_ENCODING = @as(u32, 2);
pub const PKCS_7_NDR_ENCODING = @as(u32, 131072);
pub const CRYPT_FORMAT_STR_MULTI_LINE = @as(u32, 1);
pub const CRYPT_FORMAT_STR_NO_HEX = @as(u32, 16);
pub const CRYPT_FORMAT_SIMPLE = @as(u32, 1);
pub const CRYPT_FORMAT_X509 = @as(u32, 2);
pub const CRYPT_FORMAT_OID = @as(u32, 4);
pub const CRYPT_FORMAT_RDN_SEMICOLON = @as(u32, 256);
pub const CRYPT_FORMAT_RDN_CRLF = @as(u32, 512);
pub const CRYPT_FORMAT_RDN_UNQUOTE = @as(u32, 1024);
pub const CRYPT_FORMAT_RDN_REVERSE = @as(u32, 2048);
pub const CRYPT_FORMAT_COMMA = @as(u32, 4096);
pub const CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG = @as(u32, 8);
pub const CRYPT_SORTED_CTL_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG = @as(u32, 65536);
pub const CRYPT_ENCODE_ENABLE_UTF8PERCENT_FLAG = @as(u32, 262144);
pub const CRYPT_DECODE_NOCOPY_FLAG = @as(u32, 1);
pub const CRYPT_DECODE_TO_BE_SIGNED_FLAG = @as(u32, 2);
pub const CRYPT_DECODE_SHARE_OID_STRING_FLAG = @as(u32, 4);
pub const CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG = @as(u32, 8);
pub const CRYPT_DECODE_ALLOC_FLAG = @as(u32, 32768);
pub const CRYPT_DECODE_ENABLE_PUNYCODE_FLAG = @as(u32, 33554432);
pub const CRYPT_DECODE_ENABLE_UTF8PERCENT_FLAG = @as(u32, 67108864);
pub const CRYPT_ENCODE_DECODE_NONE = @as(u32, 0);
pub const SITE_PIN_RULES_ALL_SUBDOMAINS_FLAG = @as(u32, 1);
pub const CERT_ROOT_PROGRAM_FLAG_OU = @as(u32, 16);
pub const CERT_ROOT_PROGRAM_FLAG_ADDRESS = @as(u32, 8);
pub const CERT_UNICODE_RDN_ERR_INDEX_MASK = @as(u32, 1023);
pub const CERT_UNICODE_RDN_ERR_INDEX_SHIFT = @as(u32, 22);
pub const CERT_UNICODE_ATTR_ERR_INDEX_MASK = @as(u32, 63);
pub const CERT_UNICODE_ATTR_ERR_INDEX_SHIFT = @as(u32, 16);
pub const CERT_UNICODE_VALUE_ERR_INDEX_MASK = @as(u32, 65535);
pub const CERT_UNICODE_VALUE_ERR_INDEX_SHIFT = @as(u32, 0);
pub const CERT_DIGITAL_SIGNATURE_KEY_USAGE = @as(u32, 128);
pub const CERT_NON_REPUDIATION_KEY_USAGE = @as(u32, 64);
pub const CERT_KEY_ENCIPHERMENT_KEY_USAGE = @as(u32, 32);
pub const CERT_DATA_ENCIPHERMENT_KEY_USAGE = @as(u32, 16);
pub const CERT_KEY_AGREEMENT_KEY_USAGE = @as(u32, 8);
pub const CERT_KEY_CERT_SIGN_KEY_USAGE = @as(u32, 4);
pub const CERT_OFFLINE_CRL_SIGN_KEY_USAGE = @as(u32, 2);
pub const CERT_CRL_SIGN_KEY_USAGE = @as(u32, 2);
pub const CERT_ENCIPHER_ONLY_KEY_USAGE = @as(u32, 1);
pub const CERT_DECIPHER_ONLY_KEY_USAGE = @as(u32, 128);
pub const CERT_ALT_NAME_X400_ADDRESS = @as(u32, 4);
pub const CERT_ALT_NAME_EDI_PARTY_NAME = @as(u32, 6);
pub const CERT_ALT_NAME_ENTRY_ERR_INDEX_MASK = @as(u32, 255);
pub const CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT = @as(u32, 16);
pub const CERT_ALT_NAME_VALUE_ERR_INDEX_MASK = @as(u32, 65535);
pub const CERT_ALT_NAME_VALUE_ERR_INDEX_SHIFT = @as(u32, 0);
pub const CERT_CA_SUBJECT_FLAG = @as(u32, 128);
pub const CERT_END_ENTITY_SUBJECT_FLAG = @as(u32, 64);
pub const CRL_REASON_PRIVILEGE_WITHDRAWN = @as(u32, 9);
pub const CRL_REASON_AA_COMPROMISE = @as(u32, 10);
pub const CRL_DIST_POINT_NO_NAME = @as(u32, 0);
pub const CRL_DIST_POINT_FULL_NAME = @as(u32, 1);
pub const CRL_DIST_POINT_ISSUER_RDN_NAME = @as(u32, 2);
pub const CRL_REASON_UNUSED_FLAG = @as(u32, 128);
pub const CRL_REASON_KEY_COMPROMISE_FLAG = @as(u32, 64);
pub const CRL_REASON_CA_COMPROMISE_FLAG = @as(u32, 32);
pub const CRL_REASON_AFFILIATION_CHANGED_FLAG = @as(u32, 16);
pub const CRL_REASON_SUPERSEDED_FLAG = @as(u32, 8);
pub const CRL_REASON_CESSATION_OF_OPERATION_FLAG = @as(u32, 4);
pub const CRL_REASON_CERTIFICATE_HOLD_FLAG = @as(u32, 2);
pub const CRL_REASON_PRIVILEGE_WITHDRAWN_FLAG = @as(u32, 1);
pub const CRL_REASON_AA_COMPROMISE_FLAG = @as(u32, 128);
pub const CRL_DIST_POINT_ERR_INDEX_MASK = @as(u32, 127);
pub const CRL_DIST_POINT_ERR_INDEX_SHIFT = @as(u32, 24);
pub const CRL_DIST_POINT_ERR_CRL_ISSUER_BIT = @as(i32, -2147483648);
pub const CROSS_CERT_DIST_POINT_ERR_INDEX_MASK = @as(u32, 255);
pub const CROSS_CERT_DIST_POINT_ERR_INDEX_SHIFT = @as(u32, 24);
pub const CERT_EXCLUDED_SUBTREE_BIT = @as(i32, -2147483648);
pub const SORTED_CTL_EXT_HASHED_SUBJECT_IDENTIFIER_FLAG = @as(u32, 1);
pub const CERT_DSS_R_LEN = @as(u32, 20);
pub const CERT_DSS_S_LEN = @as(u32, 20);
pub const CRYPT_X942_COUNTER_BYTE_LENGTH = @as(u32, 4);
pub const CRYPT_X942_KEY_LENGTH_BYTE_LENGTH = @as(u32, 4);
pub const CRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTH = @as(u32, 4);
pub const CRYPT_RC2_40BIT_VERSION = @as(u32, 160);
pub const CRYPT_RC2_56BIT_VERSION = @as(u32, 52);
pub const CRYPT_RC2_64BIT_VERSION = @as(u32, 120);
pub const CRYPT_RC2_128BIT_VERSION = @as(u32, 58);
pub const PKCS_RSA_SSA_PSS_TRAILER_FIELD_BC = @as(u32, 1);
pub const NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE = @as(u32, 128);
pub const NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE = @as(u32, 64);
pub const NETSCAPE_SMIME_CERT_TYPE = @as(u32, 32);
pub const NETSCAPE_SIGN_CERT_TYPE = @as(u32, 16);
pub const NETSCAPE_SSL_CA_CERT_TYPE = @as(u32, 4);
pub const NETSCAPE_SMIME_CA_CERT_TYPE = @as(u32, 2);
pub const NETSCAPE_SIGN_CA_CERT_TYPE = @as(u32, 1);
pub const CMC_TAGGED_CERT_REQUEST_CHOICE = @as(u32, 1);
pub const CMC_OTHER_INFO_NO_CHOICE = @as(u32, 0);
pub const CMC_OTHER_INFO_FAIL_CHOICE = @as(u32, 1);
pub const CMC_OTHER_INFO_PEND_CHOICE = @as(u32, 2);
pub const CMC_STATUS_SUCCESS = @as(u32, 0);
pub const CMC_STATUS_FAILED = @as(u32, 2);
pub const CMC_STATUS_PENDING = @as(u32, 3);
pub const CMC_STATUS_NO_SUPPORT = @as(u32, 4);
pub const CMC_STATUS_CONFIRM_REQUIRED = @as(u32, 5);
pub const CMC_FAIL_BAD_ALG = @as(u32, 0);
pub const CMC_FAIL_BAD_MESSAGE_CHECK = @as(u32, 1);
pub const CMC_FAIL_BAD_REQUEST = @as(u32, 2);
pub const CMC_FAIL_BAD_TIME = @as(u32, 3);
pub const CMC_FAIL_BAD_CERT_ID = @as(u32, 4);
pub const CMC_FAIL_UNSUPORTED_EXT = @as(u32, 5);
pub const CMC_FAIL_MUST_ARCHIVE_KEYS = @as(u32, 6);
pub const CMC_FAIL_BAD_IDENTITY = @as(u32, 7);
pub const CMC_FAIL_POP_REQUIRED = @as(u32, 8);
pub const CMC_FAIL_POP_FAILED = @as(u32, 9);
pub const CMC_FAIL_NO_KEY_REUSE = @as(u32, 10);
pub const CMC_FAIL_INTERNAL_CA_ERROR = @as(u32, 11);
pub const CMC_FAIL_TRY_LATER = @as(u32, 12);
pub const CERT_BIOMETRIC_PICTURE_TYPE = @as(u32, 0);
pub const CERT_BIOMETRIC_SIGNATURE_TYPE = @as(u32, 1);
pub const OCSP_REQUEST_V1 = @as(u32, 0);
pub const OCSP_SUCCESSFUL_RESPONSE = @as(u32, 0);
pub const OCSP_MALFORMED_REQUEST_RESPONSE = @as(u32, 1);
pub const OCSP_INTERNAL_ERROR_RESPONSE = @as(u32, 2);
pub const OCSP_TRY_LATER_RESPONSE = @as(u32, 3);
pub const OCSP_SIG_REQUIRED_RESPONSE = @as(u32, 5);
pub const OCSP_UNAUTHORIZED_RESPONSE = @as(u32, 6);
pub const OCSP_BASIC_GOOD_CERT_STATUS = @as(u32, 0);
pub const OCSP_BASIC_REVOKED_CERT_STATUS = @as(u32, 1);
pub const OCSP_BASIC_UNKNOWN_CERT_STATUS = @as(u32, 2);
pub const OCSP_BASIC_RESPONSE_V1 = @as(u32, 0);
pub const OCSP_BASIC_BY_NAME_RESPONDER_ID = @as(u32, 1);
pub const OCSP_BASIC_BY_KEY_RESPONDER_ID = @as(u32, 2);
pub const CRYPT_INSTALL_OID_FUNC_BEFORE_FLAG = @as(u32, 1);
pub const CRYPT_GET_INSTALLED_OID_FUNC_FLAG = @as(u32, 1);
pub const CRYPT_REGISTER_FIRST_INDEX = @as(u32, 0);
pub const CRYPT_REGISTER_LAST_INDEX = @as(u32, 4294967295);
pub const CRYPT_MATCH_ANY_ENCODING_TYPE = @as(u32, 4294967295);
pub const CALG_OID_INFO_CNG_ONLY = @as(u32, 4294967295);
pub const CALG_OID_INFO_PARAMETERS = @as(u32, 4294967294);
pub const CRYPT_HASH_ALG_OID_GROUP_ID = @as(u32, 1);
pub const CRYPT_ENCRYPT_ALG_OID_GROUP_ID = @as(u32, 2);
pub const CRYPT_PUBKEY_ALG_OID_GROUP_ID = @as(u32, 3);
pub const CRYPT_SIGN_ALG_OID_GROUP_ID = @as(u32, 4);
pub const CRYPT_RDN_ATTR_OID_GROUP_ID = @as(u32, 5);
pub const CRYPT_EXT_OR_ATTR_OID_GROUP_ID = @as(u32, 6);
pub const CRYPT_ENHKEY_USAGE_OID_GROUP_ID = @as(u32, 7);
pub const CRYPT_POLICY_OID_GROUP_ID = @as(u32, 8);
pub const CRYPT_TEMPLATE_OID_GROUP_ID = @as(u32, 9);
pub const CRYPT_KDF_OID_GROUP_ID = @as(u32, 10);
pub const CRYPT_LAST_OID_GROUP_ID = @as(u32, 10);
pub const CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG = @as(u32, 1);
pub const CRYPT_OID_USE_PUBKEY_PARA_FOR_PKCS7_FLAG = @as(u32, 2);
pub const CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG = @as(u32, 4);
pub const CRYPT_OID_PUBKEY_SIGN_ONLY_FLAG = @as(u32, 2147483648);
pub const CRYPT_OID_PUBKEY_ENCRYPT_ONLY_FLAG = @as(u32, 1073741824);
pub const CRYPT_OID_USE_CURVE_NAME_FOR_ENCODE_FLAG = @as(u32, 536870912);
pub const CRYPT_OID_USE_CURVE_PARAMETERS_FOR_ENCODE_FLAG = @as(u32, 268435456);
pub const CRYPT_OID_INFO_OID_KEY = @as(u32, 1);
pub const CRYPT_OID_INFO_NAME_KEY = @as(u32, 2);
pub const CRYPT_OID_INFO_ALGID_KEY = @as(u32, 3);
pub const CRYPT_OID_INFO_SIGN_KEY = @as(u32, 4);
pub const CRYPT_OID_INFO_CNG_ALGID_KEY = @as(u32, 5);
pub const CRYPT_OID_INFO_CNG_SIGN_KEY = @as(u32, 6);
pub const CRYPT_OID_INFO_OID_KEY_FLAGS_MASK = @as(u32, 4294901760);
pub const CRYPT_OID_DISABLE_SEARCH_DS_FLAG = @as(u32, 2147483648);
pub const CRYPT_OID_PREFER_CNG_ALGID_FLAG = @as(u32, 1073741824);
pub const CRYPT_OID_INFO_OID_GROUP_BIT_LEN_MASK = @as(u32, 268369920);
pub const CRYPT_OID_INFO_OID_GROUP_BIT_LEN_SHIFT = @as(u32, 16);
pub const CRYPT_INSTALL_OID_INFO_BEFORE_FLAG = @as(u32, 1);
pub const CRYPT_LOCALIZED_NAME_ENCODING_TYPE = @as(u32, 0);
pub const CERT_STRONG_SIGN_SERIALIZED_INFO_CHOICE = @as(u32, 1);
pub const CERT_STRONG_SIGN_OID_INFO_CHOICE = @as(u32, 2);
pub const CMSG_ENCRYPTED = @as(u32, 6);
pub const CMSG_MAIL_LIST_HANDLE_KEY_CHOICE = @as(u32, 1);
pub const CMSG_KEY_TRANS_RECIPIENT = @as(u32, 1);
pub const CMSG_KEY_AGREE_RECIPIENT = @as(u32, 2);
pub const CMSG_MAIL_LIST_RECIPIENT = @as(u32, 3);
pub const CMSG_SP3_COMPATIBLE_ENCRYPT_FLAG = @as(u32, 2147483648);
pub const CMSG_RC4_NO_SALT_FLAG = @as(u32, 1073741824);
pub const CMSG_INDEFINITE_LENGTH = @as(u32, 4294967295);
pub const CMSG_BARE_CONTENT_FLAG = @as(u32, 1);
pub const CMSG_LENGTH_ONLY_FLAG = @as(u32, 2);
pub const CMSG_DETACHED_FLAG = @as(u32, 4);
pub const CMSG_AUTHENTICATED_ATTRIBUTES_FLAG = @as(u32, 8);
pub const CMSG_CONTENTS_OCTETS_FLAG = @as(u32, 16);
pub const CMSG_MAX_LENGTH_FLAG = @as(u32, 32);
pub const CMSG_CMS_ENCAPSULATED_CONTENT_FLAG = @as(u32, 64);
pub const CMSG_SIGNED_DATA_NO_SIGN_FLAG = @as(u32, 128);
pub const CMSG_CRYPT_RELEASE_CONTEXT_FLAG = @as(u32, 32768);
pub const CMSG_TYPE_PARAM = @as(u32, 1);
pub const CMSG_CONTENT_PARAM = @as(u32, 2);
pub const CMSG_BARE_CONTENT_PARAM = @as(u32, 3);
pub const CMSG_INNER_CONTENT_TYPE_PARAM = @as(u32, 4);
pub const CMSG_SIGNER_COUNT_PARAM = @as(u32, 5);
pub const CMSG_SIGNER_INFO_PARAM = @as(u32, 6);
pub const CMSG_SIGNER_CERT_INFO_PARAM = @as(u32, 7);
pub const CMSG_SIGNER_HASH_ALGORITHM_PARAM = @as(u32, 8);
pub const CMSG_SIGNER_AUTH_ATTR_PARAM = @as(u32, 9);
pub const CMSG_SIGNER_UNAUTH_ATTR_PARAM = @as(u32, 10);
pub const CMSG_CERT_COUNT_PARAM = @as(u32, 11);
pub const CMSG_CERT_PARAM = @as(u32, 12);
pub const CMSG_CRL_COUNT_PARAM = @as(u32, 13);
pub const CMSG_CRL_PARAM = @as(u32, 14);
pub const CMSG_ENVELOPE_ALGORITHM_PARAM = @as(u32, 15);
pub const CMSG_RECIPIENT_COUNT_PARAM = @as(u32, 17);
pub const CMSG_RECIPIENT_INDEX_PARAM = @as(u32, 18);
pub const CMSG_RECIPIENT_INFO_PARAM = @as(u32, 19);
pub const CMSG_HASH_ALGORITHM_PARAM = @as(u32, 20);
pub const CMSG_HASH_DATA_PARAM = @as(u32, 21);
pub const CMSG_COMPUTED_HASH_PARAM = @as(u32, 22);
pub const CMSG_ENCRYPT_PARAM = @as(u32, 26);
pub const CMSG_ENCRYPTED_DIGEST = @as(u32, 27);
pub const CMSG_ENCODED_SIGNER = @as(u32, 28);
pub const CMSG_ENCODED_MESSAGE = @as(u32, 29);
pub const CMSG_VERSION_PARAM = @as(u32, 30);
pub const CMSG_ATTR_CERT_COUNT_PARAM = @as(u32, 31);
pub const CMSG_ATTR_CERT_PARAM = @as(u32, 32);
pub const CMSG_CMS_RECIPIENT_COUNT_PARAM = @as(u32, 33);
pub const CMSG_CMS_RECIPIENT_INDEX_PARAM = @as(u32, 34);
pub const CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM = @as(u32, 35);
pub const CMSG_CMS_RECIPIENT_INFO_PARAM = @as(u32, 36);
pub const CMSG_UNPROTECTED_ATTR_PARAM = @as(u32, 37);
pub const CMSG_SIGNER_CERT_ID_PARAM = @as(u32, 38);
pub const CMSG_CMS_SIGNER_INFO_PARAM = @as(u32, 39);
pub const CMSG_SIGNED_DATA_V1 = @as(u32, 1);
pub const CMSG_SIGNED_DATA_V3 = @as(u32, 3);
pub const CMSG_SIGNER_INFO_V1 = @as(u32, 1);
pub const CMSG_SIGNER_INFO_V3 = @as(u32, 3);
pub const CMSG_HASHED_DATA_V0 = @as(u32, 0);
pub const CMSG_HASHED_DATA_V2 = @as(u32, 2);
pub const CMSG_ENVELOPED_DATA_V0 = @as(u32, 0);
pub const CMSG_ENVELOPED_DATA_V2 = @as(u32, 2);
pub const CMSG_ENVELOPED_RECIPIENT_V0 = @as(u32, 0);
pub const CMSG_ENVELOPED_RECIPIENT_V2 = @as(u32, 2);
pub const CMSG_ENVELOPED_RECIPIENT_V3 = @as(u32, 3);
pub const CMSG_ENVELOPED_RECIPIENT_V4 = @as(u32, 4);
pub const CMSG_CTRL_VERIFY_SIGNATURE = @as(u32, 1);
pub const CMSG_CTRL_DECRYPT = @as(u32, 2);
pub const CMSG_CTRL_VERIFY_HASH = @as(u32, 5);
pub const CMSG_CTRL_ADD_SIGNER = @as(u32, 6);
pub const CMSG_CTRL_DEL_SIGNER = @as(u32, 7);
pub const CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR = @as(u32, 8);
pub const CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR = @as(u32, 9);
pub const CMSG_CTRL_ADD_CERT = @as(u32, 10);
pub const CMSG_CTRL_DEL_CERT = @as(u32, 11);
pub const CMSG_CTRL_ADD_CRL = @as(u32, 12);
pub const CMSG_CTRL_DEL_CRL = @as(u32, 13);
pub const CMSG_CTRL_ADD_ATTR_CERT = @as(u32, 14);
pub const CMSG_CTRL_DEL_ATTR_CERT = @as(u32, 15);
pub const CMSG_CTRL_KEY_TRANS_DECRYPT = @as(u32, 16);
pub const CMSG_CTRL_KEY_AGREE_DECRYPT = @as(u32, 17);
pub const CMSG_CTRL_MAIL_LIST_DECRYPT = @as(u32, 18);
pub const CMSG_CTRL_VERIFY_SIGNATURE_EX = @as(u32, 19);
pub const CMSG_CTRL_ADD_CMS_SIGNER_INFO = @as(u32, 20);
pub const CMSG_CTRL_ENABLE_STRONG_SIGNATURE = @as(u32, 21);
pub const CMSG_VERIFY_SIGNER_PUBKEY = @as(u32, 1);
pub const CMSG_VERIFY_SIGNER_CERT = @as(u32, 2);
pub const CMSG_VERIFY_SIGNER_CHAIN = @as(u32, 3);
pub const CMSG_VERIFY_SIGNER_NULL = @as(u32, 4);
pub const CMSG_VERIFY_COUNTER_SIGN_ENABLE_STRONG_FLAG = @as(u32, 1);
pub const CMSG_CONTENT_ENCRYPT_PAD_ENCODED_LEN_FLAG = @as(u32, 1);
pub const CMSG_CONTENT_ENCRYPT_FREE_PARA_FLAG = @as(u32, 1);
pub const CMSG_CONTENT_ENCRYPT_FREE_OBJID_FLAG = @as(u32, 2);
pub const CMSG_CONTENT_ENCRYPT_RELEASE_CONTEXT_FLAG = @as(u32, 32768);
pub const CMSG_KEY_TRANS_ENCRYPT_FREE_PARA_FLAG = @as(u32, 1);
pub const CMSG_KEY_TRANS_ENCRYPT_FREE_OBJID_FLAG = @as(u32, 2);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PARA_FLAG = @as(u32, 1);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_MATERIAL_FLAG = @as(u32, 2);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_ALG_FLAG = @as(u32, 4);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_PARA_FLAG = @as(u32, 8);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_BITS_FLAG = @as(u32, 16);
pub const CMSG_KEY_AGREE_ENCRYPT_FREE_OBJID_FLAG = @as(u32, 32);
pub const CMSG_MAIL_LIST_ENCRYPT_FREE_PARA_FLAG = @as(u32, 1);
pub const CMSG_MAIL_LIST_ENCRYPT_FREE_OBJID_FLAG = @as(u32, 2);
pub const CERT_KEY_PROV_HANDLE_PROP_ID = @as(u32, 1);
pub const CERT_KEY_PROV_INFO_PROP_ID = @as(u32, 2);
pub const CERT_SHA1_HASH_PROP_ID = @as(u32, 3);
pub const CERT_MD5_HASH_PROP_ID = @as(u32, 4);
pub const CERT_KEY_CONTEXT_PROP_ID = @as(u32, 5);
pub const CERT_KEY_SPEC_PROP_ID = @as(u32, 6);
pub const CERT_IE30_RESERVED_PROP_ID = @as(u32, 7);
pub const CERT_PUBKEY_HASH_RESERVED_PROP_ID = @as(u32, 8);
pub const CERT_ENHKEY_USAGE_PROP_ID = @as(u32, 9);
pub const CERT_NEXT_UPDATE_LOCATION_PROP_ID = @as(u32, 10);
pub const CERT_FRIENDLY_NAME_PROP_ID = @as(u32, 11);
pub const CERT_PVK_FILE_PROP_ID = @as(u32, 12);
pub const CERT_DESCRIPTION_PROP_ID = @as(u32, 13);
pub const CERT_ACCESS_STATE_PROP_ID = @as(u32, 14);
pub const CERT_SIGNATURE_HASH_PROP_ID = @as(u32, 15);
pub const CERT_SMART_CARD_DATA_PROP_ID = @as(u32, 16);
pub const CERT_EFS_PROP_ID = @as(u32, 17);
pub const CERT_FORTEZZA_DATA_PROP_ID = @as(u32, 18);
pub const CERT_ARCHIVED_PROP_ID = @as(u32, 19);
pub const CERT_KEY_IDENTIFIER_PROP_ID = @as(u32, 20);
pub const CERT_AUTO_ENROLL_PROP_ID = @as(u32, 21);
pub const CERT_PUBKEY_ALG_PARA_PROP_ID = @as(u32, 22);
pub const CERT_CROSS_CERT_DIST_POINTS_PROP_ID = @as(u32, 23);
pub const CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID = @as(u32, 24);
pub const CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID = @as(u32, 25);
pub const CERT_ENROLLMENT_PROP_ID = @as(u32, 26);
pub const CERT_DATE_STAMP_PROP_ID = @as(u32, 27);
pub const CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID = @as(u32, 28);
pub const CERT_SUBJECT_NAME_MD5_HASH_PROP_ID = @as(u32, 29);
pub const CERT_EXTENDED_ERROR_INFO_PROP_ID = @as(u32, 30);
pub const CERT_RENEWAL_PROP_ID = @as(u32, 64);
pub const CERT_ARCHIVED_KEY_HASH_PROP_ID = @as(u32, 65);
pub const CERT_AUTO_ENROLL_RETRY_PROP_ID = @as(u32, 66);
pub const CERT_AIA_URL_RETRIEVED_PROP_ID = @as(u32, 67);
pub const CERT_AUTHORITY_INFO_ACCESS_PROP_ID = @as(u32, 68);
pub const CERT_BACKED_UP_PROP_ID = @as(u32, 69);
pub const CERT_OCSP_RESPONSE_PROP_ID = @as(u32, 70);
pub const CERT_REQUEST_ORIGINATOR_PROP_ID = @as(u32, 71);
pub const CERT_SOURCE_LOCATION_PROP_ID = @as(u32, 72);
pub const CERT_SOURCE_URL_PROP_ID = @as(u32, 73);
pub const CERT_NEW_KEY_PROP_ID = @as(u32, 74);
pub const CERT_OCSP_CACHE_PREFIX_PROP_ID = @as(u32, 75);
pub const CERT_SMART_CARD_ROOT_INFO_PROP_ID = @as(u32, 76);
pub const CERT_NO_AUTO_EXPIRE_CHECK_PROP_ID = @as(u32, 77);
pub const CERT_NCRYPT_KEY_HANDLE_PROP_ID = @as(u32, 78);
pub const CERT_HCRYPTPROV_OR_NCRYPT_KEY_HANDLE_PROP_ID = @as(u32, 79);
pub const CERT_SUBJECT_INFO_ACCESS_PROP_ID = @as(u32, 80);
pub const CERT_CA_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID = @as(u32, 81);
pub const CERT_CA_DISABLE_CRL_PROP_ID = @as(u32, 82);
pub const CERT_ROOT_PROGRAM_CERT_POLICIES_PROP_ID = @as(u32, 83);
pub const CERT_ROOT_PROGRAM_NAME_CONSTRAINTS_PROP_ID = @as(u32, 84);
pub const CERT_SUBJECT_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID = @as(u32, 85);
pub const CERT_SUBJECT_DISABLE_CRL_PROP_ID = @as(u32, 86);
pub const CERT_CEP_PROP_ID = @as(u32, 87);
pub const CERT_SIGN_HASH_CNG_ALG_PROP_ID = @as(u32, 89);
pub const CERT_SCARD_PIN_ID_PROP_ID = @as(u32, 90);
pub const CERT_SCARD_PIN_INFO_PROP_ID = @as(u32, 91);
pub const CERT_SUBJECT_PUB_KEY_BIT_LENGTH_PROP_ID = @as(u32, 92);
pub const CERT_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID = @as(u32, 93);
pub const CERT_ISSUER_PUB_KEY_BIT_LENGTH_PROP_ID = @as(u32, 94);
pub const CERT_ISSUER_CHAIN_SIGN_HASH_CNG_ALG_PROP_ID = @as(u32, 95);
pub const CERT_ISSUER_CHAIN_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID = @as(u32, 96);
pub const CERT_NO_EXPIRE_NOTIFICATION_PROP_ID = @as(u32, 97);
pub const CERT_AUTH_ROOT_SHA256_HASH_PROP_ID = @as(u32, 98);
pub const CERT_NCRYPT_KEY_HANDLE_TRANSFER_PROP_ID = @as(u32, 99);
pub const CERT_HCRYPTPROV_TRANSFER_PROP_ID = @as(u32, 100);
pub const CERT_SMART_CARD_READER_PROP_ID = @as(u32, 101);
pub const CERT_SEND_AS_TRUSTED_ISSUER_PROP_ID = @as(u32, 102);
pub const CERT_KEY_REPAIR_ATTEMPTED_PROP_ID = @as(u32, 103);
pub const CERT_DISALLOWED_FILETIME_PROP_ID = @as(u32, 104);
pub const CERT_ROOT_PROGRAM_CHAIN_POLICIES_PROP_ID = @as(u32, 105);
pub const CERT_SMART_CARD_READER_NON_REMOVABLE_PROP_ID = @as(u32, 106);
pub const CERT_SHA256_HASH_PROP_ID = @as(u32, 107);
pub const CERT_SCEP_SERVER_CERTS_PROP_ID = @as(u32, 108);
pub const CERT_SCEP_RA_SIGNATURE_CERT_PROP_ID = @as(u32, 109);
pub const CERT_SCEP_RA_ENCRYPTION_CERT_PROP_ID = @as(u32, 110);
pub const CERT_SCEP_CA_CERT_PROP_ID = @as(u32, 111);
pub const CERT_SCEP_SIGNER_CERT_PROP_ID = @as(u32, 112);
pub const CERT_SCEP_NONCE_PROP_ID = @as(u32, 113);
pub const CERT_SCEP_ENCRYPT_HASH_CNG_ALG_PROP_ID = @as(u32, 114);
pub const CERT_SCEP_FLAGS_PROP_ID = @as(u32, 115);
pub const CERT_SCEP_GUID_PROP_ID = @as(u32, 116);
pub const CERT_SERIALIZABLE_KEY_CONTEXT_PROP_ID = @as(u32, 117);
pub const CERT_ISOLATED_KEY_PROP_ID = @as(u32, 118);
pub const CERT_SERIAL_CHAIN_PROP_ID = @as(u32, 119);
pub const CERT_KEY_CLASSIFICATION_PROP_ID = @as(u32, 120);
pub const CERT_OCSP_MUST_STAPLE_PROP_ID = @as(u32, 121);
pub const CERT_DISALLOWED_ENHKEY_USAGE_PROP_ID = @as(u32, 122);
pub const CERT_NONCOMPLIANT_ROOT_URL_PROP_ID = @as(u32, 123);
pub const CERT_PIN_SHA256_HASH_PROP_ID = @as(u32, 124);
pub const CERT_CLR_DELETE_KEY_PROP_ID = @as(u32, 125);
pub const CERT_NOT_BEFORE_FILETIME_PROP_ID = @as(u32, 126);
pub const CERT_NOT_BEFORE_ENHKEY_USAGE_PROP_ID = @as(u32, 127);
pub const CERT_FIRST_RESERVED_PROP_ID = @as(u32, 128);
pub const CERT_LAST_RESERVED_PROP_ID = @as(u32, 32767);
pub const CERT_FIRST_USER_PROP_ID = @as(u32, 32768);
pub const CERT_LAST_USER_PROP_ID = @as(u32, 65535);
pub const CERT_ACCESS_STATE_WRITE_PERSIST_FLAG = @as(u32, 1);
pub const CERT_ACCESS_STATE_SYSTEM_STORE_FLAG = @as(u32, 2);
pub const CERT_ACCESS_STATE_LM_SYSTEM_STORE_FLAG = @as(u32, 4);
pub const CERT_ACCESS_STATE_GP_SYSTEM_STORE_FLAG = @as(u32, 8);
pub const CERT_ACCESS_STATE_SHARED_USER_FLAG = @as(u32, 16);
pub const CERT_STORE_SIGNATURE_FLAG = @as(u32, 1);
pub const CERT_STORE_TIME_VALIDITY_FLAG = @as(u32, 2);
pub const CERT_STORE_REVOCATION_FLAG = @as(u32, 4);
pub const CERT_STORE_NO_CRL_FLAG = @as(u32, 65536);
pub const CERT_STORE_NO_ISSUER_FLAG = @as(u32, 131072);
pub const CERT_STORE_BASE_CRL_FLAG = @as(u32, 256);
pub const CERT_STORE_DELTA_CRL_FLAG = @as(u32, 512);
pub const CERT_STORE_UNSAFE_PHYSICAL_FLAG = @as(u32, 32);
pub const CERT_STORE_SHARE_STORE_FLAG = @as(u32, 64);
pub const CERT_STORE_MANIFOLD_FLAG = @as(u32, 256);
pub const CERT_SYSTEM_STORE_MASK = @as(u32, 4294901760);
pub const CERT_SYSTEM_STORE_UNPROTECTED_FLAG = @as(u32, 1073741824);
pub const CERT_SYSTEM_STORE_DEFER_READ_FLAG = @as(u32, 536870912);
pub const CERT_SYSTEM_STORE_LOCATION_SHIFT = @as(u32, 16);
pub const CERT_SYSTEM_STORE_CURRENT_USER_ID = @as(u32, 1);
pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_ID = @as(u32, 2);
pub const CERT_SYSTEM_STORE_CURRENT_SERVICE_ID = @as(u32, 4);
pub const CERT_SYSTEM_STORE_SERVICES_ID = @as(u32, 5);
pub const CERT_SYSTEM_STORE_USERS_ID = @as(u32, 6);
pub const CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID = @as(u32, 7);
pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID = @as(u32, 8);
pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID = @as(u32, 9);
pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_WCOS_ID = @as(u32, 10);
pub const CERT_PROT_ROOT_DISABLE_CURRENT_USER_FLAG = @as(u32, 1);
pub const CERT_PROT_ROOT_INHIBIT_ADD_AT_INIT_FLAG = @as(u32, 2);
pub const CERT_PROT_ROOT_INHIBIT_PURGE_LM_FLAG = @as(u32, 4);
pub const CERT_PROT_ROOT_DISABLE_LM_AUTH_FLAG = @as(u32, 8);
pub const CERT_PROT_ROOT_ONLY_LM_GPT_FLAG = @as(u32, 8);
pub const CERT_PROT_ROOT_DISABLE_NT_AUTH_REQUIRED_FLAG = @as(u32, 16);
pub const CERT_PROT_ROOT_DISABLE_NOT_DEFINED_NAME_CONSTRAINT_FLAG = @as(u32, 32);
pub const CERT_PROT_ROOT_DISABLE_PEER_TRUST = @as(u32, 65536);
pub const CERT_TRUST_PUB_ALLOW_TRUST_MASK = @as(u32, 3);
pub const CERT_TRUST_PUB_ALLOW_END_USER_TRUST = @as(u32, 0);
pub const CERT_TRUST_PUB_ALLOW_MACHINE_ADMIN_TRUST = @as(u32, 1);
pub const CERT_TRUST_PUB_ALLOW_ENTERPRISE_ADMIN_TRUST = @as(u32, 2);
pub const CERT_TRUST_PUB_CHECK_PUBLISHER_REV_FLAG = @as(u32, 256);
pub const CERT_TRUST_PUB_CHECK_TIMESTAMP_REV_FLAG = @as(u32, 512);
pub const CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_UNTRUSTED_ROOT_LOGGING_FLAG = @as(u32, 1);
pub const CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_PARTIAL_CHAIN_LOGGING_FLAG = @as(u32, 2);
pub const CERT_AUTO_UPDATE_DISABLE_RANDOM_QUERY_STRING_FLAG = @as(u32, 4);
pub const CERT_REGISTRY_STORE_REMOTE_FLAG = @as(u32, 65536);
pub const CERT_REGISTRY_STORE_SERIALIZED_FLAG = @as(u32, 131072);
pub const CERT_REGISTRY_STORE_CLIENT_GPT_FLAG = @as(u32, 2147483648);
pub const CERT_REGISTRY_STORE_LM_GPT_FLAG = @as(u32, 16777216);
pub const CERT_REGISTRY_STORE_ROAMING_FLAG = @as(u32, 262144);
pub const CERT_REGISTRY_STORE_MY_IE_DIRTY_FLAG = @as(u32, 524288);
pub const CERT_REGISTRY_STORE_EXTERNAL_FLAG = @as(u32, 1048576);
pub const CERT_FILE_STORE_COMMIT_ENABLE_FLAG = @as(u32, 65536);
pub const CERT_LDAP_STORE_SIGN_FLAG = @as(u32, 65536);
pub const CERT_LDAP_STORE_AREC_EXCLUSIVE_FLAG = @as(u32, 131072);
pub const CERT_LDAP_STORE_OPENED_FLAG = @as(u32, 262144);
pub const CERT_LDAP_STORE_UNBIND_FLAG = @as(u32, 524288);
pub const CERT_STORE_PROV_GP_SYSTEM_STORE_FLAG = @as(u32, 32);
pub const CERT_STORE_PROV_SHARED_USER_FLAG = @as(u32, 64);
pub const CERT_STORE_PROV_CLOSE_FUNC = @as(u32, 0);
pub const CERT_STORE_PROV_READ_CERT_FUNC = @as(u32, 1);
pub const CERT_STORE_PROV_WRITE_CERT_FUNC = @as(u32, 2);
pub const CERT_STORE_PROV_DELETE_CERT_FUNC = @as(u32, 3);
pub const CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC = @as(u32, 4);
pub const CERT_STORE_PROV_READ_CRL_FUNC = @as(u32, 5);
pub const CERT_STORE_PROV_WRITE_CRL_FUNC = @as(u32, 6);
pub const CERT_STORE_PROV_DELETE_CRL_FUNC = @as(u32, 7);
pub const CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC = @as(u32, 8);
pub const CERT_STORE_PROV_READ_CTL_FUNC = @as(u32, 9);
pub const CERT_STORE_PROV_WRITE_CTL_FUNC = @as(u32, 10);
pub const CERT_STORE_PROV_DELETE_CTL_FUNC = @as(u32, 11);
pub const CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC = @as(u32, 12);
pub const CERT_STORE_PROV_CONTROL_FUNC = @as(u32, 13);
pub const CERT_STORE_PROV_FIND_CERT_FUNC = @as(u32, 14);
pub const CERT_STORE_PROV_FREE_FIND_CERT_FUNC = @as(u32, 15);
pub const CERT_STORE_PROV_GET_CERT_PROPERTY_FUNC = @as(u32, 16);
pub const CERT_STORE_PROV_FIND_CRL_FUNC = @as(u32, 17);
pub const CERT_STORE_PROV_FREE_FIND_CRL_FUNC = @as(u32, 18);
pub const CERT_STORE_PROV_GET_CRL_PROPERTY_FUNC = @as(u32, 19);
pub const CERT_STORE_PROV_FIND_CTL_FUNC = @as(u32, 20);
pub const CERT_STORE_PROV_FREE_FIND_CTL_FUNC = @as(u32, 21);
pub const CERT_STORE_PROV_GET_CTL_PROPERTY_FUNC = @as(u32, 22);
pub const CERT_STORE_PROV_WRITE_ADD_FLAG = @as(u32, 1);
pub const CERT_STORE_SAVE_AS_PKCS12 = @as(u32, 3);
pub const CERT_CLOSE_STORE_FORCE_FLAG = @as(u32, 1);
pub const CERT_CLOSE_STORE_CHECK_FLAG = @as(u32, 2);
pub const CERT_COMPARE_MASK = @as(u32, 65535);
pub const CERT_COMPARE_ANY = @as(u32, 0);
pub const CERT_COMPARE_SHA1_HASH = @as(u32, 1);
pub const CERT_COMPARE_NAME = @as(u32, 2);
pub const CERT_COMPARE_ATTR = @as(u32, 3);
pub const CERT_COMPARE_MD5_HASH = @as(u32, 4);
pub const CERT_COMPARE_PROPERTY = @as(u32, 5);
pub const CERT_COMPARE_PUBLIC_KEY = @as(u32, 6);
pub const CERT_COMPARE_NAME_STR_A = @as(u32, 7);
pub const CERT_COMPARE_NAME_STR_W = @as(u32, 8);
pub const CERT_COMPARE_KEY_SPEC = @as(u32, 9);
pub const CERT_COMPARE_ENHKEY_USAGE = @as(u32, 10);
pub const CERT_COMPARE_SUBJECT_CERT = @as(u32, 11);
pub const CERT_COMPARE_ISSUER_OF = @as(u32, 12);
pub const CERT_COMPARE_EXISTING = @as(u32, 13);
pub const CERT_COMPARE_SIGNATURE_HASH = @as(u32, 14);
pub const CERT_COMPARE_KEY_IDENTIFIER = @as(u32, 15);
pub const CERT_COMPARE_CERT_ID = @as(u32, 16);
pub const CERT_COMPARE_CROSS_CERT_DIST_POINTS = @as(u32, 17);
pub const CERT_COMPARE_PUBKEY_MD5_HASH = @as(u32, 18);
pub const CERT_COMPARE_SUBJECT_INFO_ACCESS = @as(u32, 19);
pub const CERT_COMPARE_HASH_STR = @as(u32, 20);
pub const CERT_COMPARE_HAS_PRIVATE_KEY = @as(u32, 21);
pub const CERT_SET_PROPERTY_IGNORE_PERSIST_ERROR_FLAG = @as(u32, 2147483648);
pub const CERT_SET_PROPERTY_INHIBIT_PERSIST_FLAG = @as(u32, 1073741824);
pub const CTL_ENTRY_FROM_PROP_CHAIN_FLAG = @as(u32, 1);
pub const CRL_FIND_ANY = @as(u32, 0);
pub const CRL_FIND_ISSUED_BY = @as(u32, 1);
pub const CRL_FIND_EXISTING = @as(u32, 2);
pub const CRL_FIND_ISSUED_FOR = @as(u32, 3);
pub const CRL_FIND_ISSUED_BY_AKI_FLAG = @as(u32, 1);
pub const CRL_FIND_ISSUED_BY_SIGNATURE_FLAG = @as(u32, 2);
pub const CRL_FIND_ISSUED_BY_DELTA_FLAG = @as(u32, 4);
pub const CRL_FIND_ISSUED_BY_BASE_FLAG = @as(u32, 8);
pub const CRL_FIND_ISSUED_FOR_SET_STRONG_PROPERTIES_FLAG = @as(u32, 16);
pub const CERT_STORE_ADD_NEW = @as(u32, 1);
pub const CERT_STORE_ADD_USE_EXISTING = @as(u32, 2);
pub const CERT_STORE_ADD_REPLACE_EXISTING = @as(u32, 3);
pub const CERT_STORE_ADD_ALWAYS = @as(u32, 4);
pub const CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES = @as(u32, 5);
pub const CERT_STORE_ADD_NEWER = @as(u32, 6);
pub const CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES = @as(u32, 7);
pub const CERT_STORE_CERTIFICATE_CONTEXT = @as(u32, 1);
pub const CERT_STORE_CRL_CONTEXT = @as(u32, 2);
pub const CERT_STORE_CTL_CONTEXT = @as(u32, 3);
pub const CTL_ANY_SUBJECT_TYPE = @as(u32, 1);
pub const CTL_CERT_SUBJECT_TYPE = @as(u32, 2);
pub const CTL_FIND_NO_LIST_ID_CBDATA = @as(u32, 4294967295);
pub const CERT_STORE_CTRL_RESYNC = @as(u32, 1);
pub const CERT_STORE_CTRL_NOTIFY_CHANGE = @as(u32, 2);
pub const CERT_STORE_CTRL_COMMIT = @as(u32, 3);
pub const CERT_STORE_CTRL_AUTO_RESYNC = @as(u32, 4);
pub const CERT_STORE_CTRL_CANCEL_NOTIFY = @as(u32, 5);
pub const CERT_STORE_LOCALIZED_NAME_PROP_ID = @as(u32, 4096);
pub const CERT_CREATE_CONTEXT_NOCOPY_FLAG = @as(u32, 1);
pub const CERT_CREATE_CONTEXT_SORTED_FLAG = @as(u32, 2);
pub const CERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAG = @as(u32, 4);
pub const CERT_CREATE_CONTEXT_NO_ENTRY_FLAG = @as(u32, 8);
pub const CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG = @as(u32, 1);
pub const CERT_PHYSICAL_STORE_OPEN_DISABLE_FLAG = @as(u32, 2);
pub const CERT_PHYSICAL_STORE_REMOTE_OPEN_DISABLE_FLAG = @as(u32, 4);
pub const CERT_PHYSICAL_STORE_INSERT_COMPUTER_NAME_ENABLE_FLAG = @as(u32, 8);
pub const CERT_PHYSICAL_STORE_PREDEFINED_ENUM_FLAG = @as(u32, 1);
pub const CMSG_TRUSTED_SIGNER_FLAG = @as(u32, 1);
pub const CMSG_SIGNER_ONLY_FLAG = @as(u32, 2);
pub const CMSG_USE_SIGNER_INDEX_FLAG = @as(u32, 4);
pub const CMSG_CMS_ENCAPSULATED_CTL_FLAG = @as(u32, 32768);
pub const CMSG_ENCODE_SORTED_CTL_FLAG = @as(u32, 1);
pub const CMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG = @as(u32, 2);
pub const CERT_VERIFY_INHIBIT_CTL_UPDATE_FLAG = @as(u32, 1);
pub const CERT_VERIFY_TRUSTED_SIGNERS_FLAG = @as(u32, 2);
pub const CERT_VERIFY_NO_TIME_CHECK_FLAG = @as(u32, 4);
pub const CERT_VERIFY_ALLOW_MORE_USAGE_FLAG = @as(u32, 8);
pub const CERT_VERIFY_UPDATED_CTL_FLAG = @as(u32, 1);
pub const CERT_CONTEXT_REVOCATION_TYPE = @as(u32, 1);
pub const CERT_VERIFY_REV_CHAIN_FLAG = @as(u32, 1);
pub const CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION = @as(u32, 2);
pub const CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG = @as(u32, 4);
pub const CERT_VERIFY_REV_SERVER_OCSP_FLAG = @as(u32, 8);
pub const CERT_VERIFY_REV_NO_OCSP_FAILOVER_TO_CRL_FLAG = @as(u32, 16);
pub const CERT_VERIFY_REV_SERVER_OCSP_WIRE_ONLY_FLAG = @as(u32, 32);
pub const CERT_UNICODE_IS_RDN_ATTRS_FLAG = @as(u32, 1);
pub const CERT_CASE_INSENSITIVE_IS_RDN_ATTRS_FLAG = @as(u32, 2);
pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOB = @as(u32, 1);
pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT = @as(u32, 2);
pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_CRL = @as(u32, 3);
pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_OCSP_BASIC_SIGNED_RESPONSE = @as(u32, 4);
pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_PUBKEY = @as(u32, 1);
pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT = @as(u32, 2);
pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_CHAIN = @as(u32, 3);
pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_NULL = @as(u32, 4);
pub const CRYPT_VERIFY_CERT_SIGN_CHECK_WEAK_HASH_FLAG = @as(u32, 8);
pub const CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG = @as(u32, 128);
pub const CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK = @as(u32, 458752);
pub const CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG = @as(u32, 65536);
pub const CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = @as(u32, 131072);
pub const CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG = @as(u32, 262144);
pub const CERT_XML_NAME_STR = @as(u32, 4);
pub const CERT_NAME_STR_SEMICOLON_FLAG = @as(u32, 1073741824);
pub const CERT_NAME_STR_NO_PLUS_FLAG = @as(u32, 536870912);
pub const CERT_NAME_STR_NO_QUOTING_FLAG = @as(u32, 268435456);
pub const CERT_NAME_STR_CRLF_FLAG = @as(u32, 134217728);
pub const CERT_NAME_STR_COMMA_FLAG = @as(u32, 67108864);
pub const CERT_NAME_STR_REVERSE_FLAG = @as(u32, 33554432);
pub const CERT_NAME_STR_FORWARD_FLAG = @as(u32, 16777216);
pub const CERT_NAME_STR_DISABLE_IE4_UTF8_FLAG = @as(u32, 65536);
pub const CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG = @as(u32, 131072);
pub const CERT_NAME_STR_ENABLE_UTF8_UNICODE_FLAG = @as(u32, 262144);
pub const CERT_NAME_STR_FORCE_UTF8_DIR_STR_FLAG = @as(u32, 524288);
pub const CERT_NAME_STR_DISABLE_UTF8_DIR_STR_FLAG = @as(u32, 1048576);
pub const CERT_NAME_STR_ENABLE_PUNYCODE_FLAG = @as(u32, 2097152);
pub const CERT_NAME_EMAIL_TYPE = @as(u32, 1);
pub const CERT_NAME_RDN_TYPE = @as(u32, 2);
pub const CERT_NAME_ATTR_TYPE = @as(u32, 3);
pub const CERT_NAME_SIMPLE_DISPLAY_TYPE = @as(u32, 4);
pub const CERT_NAME_FRIENDLY_DISPLAY_TYPE = @as(u32, 5);
pub const CERT_NAME_DNS_TYPE = @as(u32, 6);
pub const CERT_NAME_URL_TYPE = @as(u32, 7);
pub const CERT_NAME_UPN_TYPE = @as(u32, 8);
pub const CERT_NAME_ISSUER_FLAG = @as(u32, 1);
pub const CERT_NAME_DISABLE_IE4_UTF8_FLAG = @as(u32, 65536);
pub const CERT_NAME_SEARCH_ALL_NAMES_FLAG = @as(u32, 2);
pub const CRYPT_MESSAGE_BARE_CONTENT_OUT_FLAG = @as(u32, 1);
pub const CRYPT_MESSAGE_ENCAPSULATED_CONTENT_OUT_FLAG = @as(u32, 2);
pub const CRYPT_MESSAGE_KEYID_SIGNER_FLAG = @as(u32, 4);
pub const CRYPT_MESSAGE_SILENT_KEYSET_FLAG = @as(u32, 64);
pub const CRYPT_MESSAGE_KEYID_RECIPIENT_FLAG = @as(u32, 4);
pub const CRYPT_RETRIEVE_MULTIPLE_OBJECTS = @as(u32, 1);
pub const CRYPT_CACHE_ONLY_RETRIEVAL = @as(u32, 2);
pub const CRYPT_WIRE_ONLY_RETRIEVAL = @as(u32, 4);
pub const CRYPT_DONT_CACHE_RESULT = @as(u32, 8);
pub const CRYPT_ASYNC_RETRIEVAL = @as(u32, 16);
pub const CRYPT_STICKY_CACHE_RETRIEVAL = @as(u32, 4096);
pub const CRYPT_LDAP_SCOPE_BASE_ONLY_RETRIEVAL = @as(u32, 8192);
pub const CRYPT_OFFLINE_CHECK_RETRIEVAL = @as(u32, 16384);
pub const CRYPT_LDAP_INSERT_ENTRY_ATTRIBUTE = @as(u32, 32768);
pub const CRYPT_LDAP_SIGN_RETRIEVAL = @as(u32, 65536);
pub const CRYPT_NO_AUTH_RETRIEVAL = @as(u32, 131072);
pub const CRYPT_LDAP_AREC_EXCLUSIVE_RETRIEVAL = @as(u32, 262144);
pub const CRYPT_AIA_RETRIEVAL = @as(u32, 524288);
pub const CRYPT_HTTP_POST_RETRIEVAL = @as(u32, 1048576);
pub const CRYPT_PROXY_CACHE_RETRIEVAL = @as(u32, 2097152);
pub const CRYPT_NOT_MODIFIED_RETRIEVAL = @as(u32, 4194304);
pub const CRYPT_ENABLE_SSL_REVOCATION_RETRIEVAL = @as(u32, 8388608);
pub const CRYPT_RANDOM_QUERY_STRING_RETRIEVAL = @as(u32, 67108864);
pub const CRYPT_ENABLE_FILE_RETRIEVAL = @as(u32, 134217728);
pub const CRYPT_CREATE_NEW_FLUSH_ENTRY = @as(u32, 268435456);
pub const CRYPT_VERIFY_CONTEXT_SIGNATURE = @as(u32, 32);
pub const CRYPT_VERIFY_DATA_HASH = @as(u32, 64);
pub const CRYPT_KEEP_TIME_VALID = @as(u32, 128);
pub const CRYPT_DONT_VERIFY_SIGNATURE = @as(u32, 256);
pub const CRYPT_DONT_CHECK_TIME_VALIDITY = @as(u32, 512);
pub const CRYPT_CHECK_FRESHNESS_TIME_VALIDITY = @as(u32, 1024);
pub const CRYPT_ACCUMULATIVE_TIMEOUT = @as(u32, 2048);
pub const CRYPT_OCSP_ONLY_RETRIEVAL = @as(u32, 16777216);
pub const CRYPT_NO_OCSP_FAILOVER_TO_CRL_RETRIEVAL = @as(u32, 33554432);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_NONE = @as(u32, 0);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_BLOB = @as(u32, 1);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_CRL = @as(u32, 2);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_OCSP = @as(u32, 3);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_AUTOROOT_CAB = @as(u32, 5);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_DISALLOWED_CERT_CAB = @as(u32, 6);
pub const CRYPTNET_URL_CACHE_PRE_FETCH_PIN_RULES_CAB = @as(u32, 7);
pub const CRYPTNET_URL_CACHE_DEFAULT_FLUSH = @as(u32, 0);
pub const CRYPTNET_URL_CACHE_DISABLE_FLUSH = @as(u32, 4294967295);
pub const CRYPTNET_URL_CACHE_RESPONSE_NONE = @as(u32, 0);
pub const CRYPTNET_URL_CACHE_RESPONSE_HTTP = @as(u32, 1);
pub const CRYPTNET_URL_CACHE_RESPONSE_VALIDATED = @as(u32, 32768);
pub const CRYPT_RETRIEVE_MAX_ERROR_CONTENT_LENGTH = @as(u32, 4096);
pub const CRYPT_KEYID_MACHINE_FLAG = @as(u32, 32);
pub const CRYPT_KEYID_ALLOC_FLAG = @as(u32, 32768);
pub const CRYPT_KEYID_DELETE_FLAG = @as(u32, 16);
pub const CRYPT_KEYID_SET_NEW_FLAG = @as(u32, 8192);
pub const CERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_DEFAULT = @as(u32, 5);
pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_DEFAULT = @as(u32, 3);
pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_DEFAULT = @as(u32, 100000);
pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_DEFAULT = @as(u32, 10);
pub const CERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DEFAULT = @as(u32, 5);
pub const CERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DISABLE = @as(u32, 4294967295);
pub const CERT_CHAIN_ENABLE_MD2_MD4_FLAG = @as(u32, 1);
pub const CERT_CHAIN_ENABLE_WEAK_RSA_ROOT_FLAG = @as(u32, 2);
pub const CERT_CHAIN_ENABLE_WEAK_LOGGING_FLAG = @as(u32, 4);
pub const CERT_CHAIN_ENABLE_ONLY_WEAK_LOGGING_FLAG = @as(u32, 8);
pub const CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DEFAULT = @as(u32, 1023);
pub const CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DISABLE = @as(u32, 4294967295);
pub const CERT_CHAIN_MIN_PUB_KEY_BIT_LENGTH_DISABLE = @as(u32, 4294967295);
pub const CERT_CHAIN_ENABLE_WEAK_SETTINGS_FLAG = @as(u32, 2147483648);
pub const CERT_CHAIN_DISABLE_ALL_EKU_WEAK_FLAG = @as(u32, 65536);
pub const CERT_CHAIN_ENABLE_ALL_EKU_HYGIENE_FLAG = @as(u32, 131072);
pub const CERT_CHAIN_DISABLE_OPT_IN_SERVER_AUTH_WEAK_FLAG = @as(u32, 262144);
pub const CERT_CHAIN_DISABLE_SERVER_AUTH_WEAK_FLAG = @as(u32, 1048576);
pub const CERT_CHAIN_ENABLE_SERVER_AUTH_HYGIENE_FLAG = @as(u32, 2097152);
pub const CERT_CHAIN_DISABLE_CODE_SIGNING_WEAK_FLAG = @as(u32, 4194304);
pub const CERT_CHAIN_DISABLE_MOTW_CODE_SIGNING_WEAK_FLAG = @as(u32, 8388608);
pub const CERT_CHAIN_ENABLE_CODE_SIGNING_HYGIENE_FLAG = @as(u32, 16777216);
pub const CERT_CHAIN_ENABLE_MOTW_CODE_SIGNING_HYGIENE_FLAG = @as(u32, 33554432);
pub const CERT_CHAIN_DISABLE_TIMESTAMP_WEAK_FLAG = @as(u32, 67108864);
pub const CERT_CHAIN_DISABLE_MOTW_TIMESTAMP_WEAK_FLAG = @as(u32, 134217728);
pub const CERT_CHAIN_ENABLE_TIMESTAMP_HYGIENE_FLAG = @as(u32, 268435456);
pub const CERT_CHAIN_ENABLE_MOTW_TIMESTAMP_HYGIENE_FLAG = @as(u32, 536870912);
pub const CERT_CHAIN_MOTW_IGNORE_AFTER_TIME_WEAK_FLAG = @as(u32, 1073741824);
pub const CERT_CHAIN_DISABLE_FILE_HASH_WEAK_FLAG = @as(u32, 4096);
pub const CERT_CHAIN_DISABLE_MOTW_FILE_HASH_WEAK_FLAG = @as(u32, 8192);
pub const CERT_CHAIN_DISABLE_TIMESTAMP_HASH_WEAK_FLAG = @as(u32, 16384);
pub const CERT_CHAIN_DISABLE_MOTW_TIMESTAMP_HASH_WEAK_FLAG = @as(u32, 32768);
pub const CERT_CHAIN_AUTO_CURRENT_USER = @as(u32, 1);
pub const CERT_CHAIN_AUTO_LOCAL_MACHINE = @as(u32, 2);
pub const CERT_CHAIN_AUTO_IMPERSONATED = @as(u32, 3);
pub const CERT_CHAIN_AUTO_PROCESS_INFO = @as(u32, 4);
pub const CERT_CHAIN_AUTO_PINRULE_INFO = @as(u32, 5);
pub const CERT_CHAIN_AUTO_NETWORK_INFO = @as(u32, 6);
pub const CERT_CHAIN_AUTO_SERIAL_LOCAL_MACHINE = @as(u32, 7);
pub const CERT_CHAIN_AUTO_HPKP_RULE_INFO = @as(u32, 8);
pub const CERT_CHAIN_AUTO_FLUSH_DISABLE_FLAG = @as(u32, 1);
pub const CERT_CHAIN_AUTO_LOG_CREATE_FLAG = @as(u32, 2);
pub const CERT_CHAIN_AUTO_LOG_FREE_FLAG = @as(u32, 4);
pub const CERT_CHAIN_AUTO_LOG_FLUSH_FLAG = @as(u32, 8);
pub const CERT_SRV_OCSP_RESP_MIN_SYNC_CERT_FILE_SECONDS_DEFAULT = @as(u32, 5);
pub const CRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_DEFAULT = @as(u32, 500);
pub const CRYPTNET_OCSP_AFTER_CRL_DISABLE = @as(u32, 4294967295);
pub const CRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_DEFAULT = @as(u32, 10);
pub const CRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT = @as(u32, 20);
pub const CRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT = @as(u32, 10);
pub const CRYPTNET_PRE_FETCH_TRIGGER_DISABLE = @as(u32, 4294967295);
pub const CRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_DEFAULT = @as(u32, 60);
pub const CRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_DEFAULT = @as(u32, 50);
pub const CRYPTNET_CRL_BEFORE_OCSP_ENABLE = @as(u32, 4294967295);
pub const CERT_CHAIN_OPTION_DISABLE_AIA_URL_RETRIEVAL = @as(u32, 2);
pub const CERT_CHAIN_OPTION_ENABLE_SIA_URL_RETRIEVAL = @as(u32, 4);
pub const CERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_DEFAULT = @as(u32, 12);
pub const CERT_CHAIN_CACHE_END_CERT = @as(u32, 1);
pub const CERT_CHAIN_THREAD_STORE_SYNC = @as(u32, 2);
pub const CERT_CHAIN_CACHE_ONLY_URL_RETRIEVAL = @as(u32, 4);
pub const CERT_CHAIN_USE_LOCAL_MACHINE_STORE = @as(u32, 8);
pub const CERT_CHAIN_ENABLE_CACHE_AUTO_UPDATE = @as(u32, 16);
pub const CERT_CHAIN_ENABLE_SHARE_STORE = @as(u32, 32);
pub const CERT_CHAIN_EXCLUSIVE_ENABLE_CA_FLAG = @as(u32, 1);
pub const CERT_TRUST_NO_ERROR = @as(u32, 0);
pub const CERT_TRUST_IS_NOT_TIME_VALID = @as(u32, 1);
pub const CERT_TRUST_IS_NOT_TIME_NESTED = @as(u32, 2);
pub const CERT_TRUST_IS_REVOKED = @as(u32, 4);
pub const CERT_TRUST_IS_NOT_SIGNATURE_VALID = @as(u32, 8);
pub const CERT_TRUST_IS_NOT_VALID_FOR_USAGE = @as(u32, 16);
pub const CERT_TRUST_IS_UNTRUSTED_ROOT = @as(u32, 32);
pub const CERT_TRUST_REVOCATION_STATUS_UNKNOWN = @as(u32, 64);
pub const CERT_TRUST_IS_CYCLIC = @as(u32, 128);
pub const CERT_TRUST_INVALID_EXTENSION = @as(u32, 256);
pub const CERT_TRUST_INVALID_POLICY_CONSTRAINTS = @as(u32, 512);
pub const CERT_TRUST_INVALID_BASIC_CONSTRAINTS = @as(u32, 1024);
pub const CERT_TRUST_INVALID_NAME_CONSTRAINTS = @as(u32, 2048);
pub const CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT = @as(u32, 4096);
pub const CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT = @as(u32, 8192);
pub const CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT = @as(u32, 16384);
pub const CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT = @as(u32, 32768);
pub const CERT_TRUST_IS_OFFLINE_REVOCATION = @as(u32, 16777216);
pub const CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY = @as(u32, 33554432);
pub const CERT_TRUST_IS_EXPLICIT_DISTRUST = @as(u32, 67108864);
pub const CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT = @as(u32, 134217728);
pub const CERT_TRUST_HAS_WEAK_SIGNATURE = @as(u32, 1048576);
pub const CERT_TRUST_HAS_WEAK_HYGIENE = @as(u32, 2097152);
pub const CERT_TRUST_IS_PARTIAL_CHAIN = @as(u32, 65536);
pub const CERT_TRUST_CTL_IS_NOT_TIME_VALID = @as(u32, 131072);
pub const CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID = @as(u32, 262144);
pub const CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE = @as(u32, 524288);
pub const CERT_TRUST_HAS_EXACT_MATCH_ISSUER = @as(u32, 1);
pub const CERT_TRUST_HAS_KEY_MATCH_ISSUER = @as(u32, 2);
pub const CERT_TRUST_HAS_NAME_MATCH_ISSUER = @as(u32, 4);
pub const CERT_TRUST_IS_SELF_SIGNED = @as(u32, 8);
pub const CERT_TRUST_AUTO_UPDATE_CA_REVOCATION = @as(u32, 16);
pub const CERT_TRUST_AUTO_UPDATE_END_REVOCATION = @as(u32, 32);
pub const CERT_TRUST_NO_OCSP_FAILOVER_TO_CRL = @as(u32, 64);
pub const CERT_TRUST_IS_KEY_ROLLOVER = @as(u32, 128);
pub const CERT_TRUST_SSL_HANDSHAKE_OCSP = @as(u32, 262144);
pub const CERT_TRUST_SSL_TIME_VALID_OCSP = @as(u32, 524288);
pub const CERT_TRUST_SSL_RECONNECT_OCSP = @as(u32, 1048576);
pub const CERT_TRUST_HAS_PREFERRED_ISSUER = @as(u32, 256);
pub const CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY = @as(u32, 512);
pub const CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS = @as(u32, 1024);
pub const CERT_TRUST_IS_PEER_TRUSTED = @as(u32, 2048);
pub const CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED = @as(u32, 4096);
pub const CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE = @as(u32, 8192);
pub const CERT_TRUST_IS_CA_TRUSTED = @as(u32, 16384);
pub const CERT_TRUST_HAS_AUTO_UPDATE_WEAK_SIGNATURE = @as(u32, 32768);
pub const CERT_TRUST_HAS_ALLOW_WEAK_SIGNATURE = @as(u32, 131072);
pub const CERT_TRUST_IS_COMPLEX_CHAIN = @as(u32, 65536);
pub const CERT_TRUST_SSL_TIME_VALID = @as(u32, 16777216);
pub const CERT_TRUST_NO_TIME_CHECK = @as(u32, 33554432);
pub const USAGE_MATCH_TYPE_AND = @as(u32, 0);
pub const USAGE_MATCH_TYPE_OR = @as(u32, 1);
pub const CERT_CHAIN_STRONG_SIGN_DISABLE_END_CHECK_FLAG = @as(u32, 1);
pub const CERT_CHAIN_REVOCATION_CHECK_END_CERT = @as(u32, 268435456);
pub const CERT_CHAIN_REVOCATION_CHECK_CHAIN = @as(u32, 536870912);
pub const CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = @as(u32, 1073741824);
pub const CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY = @as(u32, 2147483648);
pub const CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT = @as(u32, 134217728);
pub const CERT_CHAIN_REVOCATION_CHECK_OCSP_CERT = @as(u32, 67108864);
pub const CERT_CHAIN_DISABLE_PASS1_QUALITY_FILTERING = @as(u32, 64);
pub const CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS = @as(u32, 128);
pub const CERT_CHAIN_DISABLE_AUTH_ROOT_AUTO_UPDATE = @as(u32, 256);
pub const CERT_CHAIN_TIMESTAMP_TIME = @as(u32, 512);
pub const CERT_CHAIN_ENABLE_PEER_TRUST = @as(u32, 1024);
pub const CERT_CHAIN_DISABLE_MY_PEER_TRUST = @as(u32, 2048);
pub const CERT_CHAIN_DISABLE_MD2_MD4 = @as(u32, 4096);
pub const CERT_CHAIN_DISABLE_AIA = @as(u32, 8192);
pub const CERT_CHAIN_HAS_MOTW = @as(u32, 16384);
pub const CERT_CHAIN_ONLY_ADDITIONAL_AND_AUTH_ROOT = @as(u32, 32768);
pub const CERT_CHAIN_OPT_IN_WEAK_SIGNATURE = @as(u32, 65536);
pub const CERT_CHAIN_FIND_BY_ISSUER = @as(u32, 1);
pub const CERT_CHAIN_POLICY_IGNORE_WEAK_SIGNATURE_FLAG = @as(u32, 134217728);
pub const BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_CA_FLAG = @as(u32, 2147483648);
pub const BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_END_ENTITY_FLAG = @as(u32, 1073741824);
pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_ENABLE_TEST_ROOT_FLAG = @as(u32, 65536);
pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_CHECK_APPLICATION_ROOT_FLAG = @as(u32, 131072);
pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_DISABLE_FLIGHT_ROOT_FLAG = @as(u32, 262144);
pub const SSL_F12_ERROR_TEXT_LENGTH = @as(u32, 256);
pub const CERT_CHAIN_POLICY_SSL_F12_SUCCESS_LEVEL = @as(u32, 0);
pub const CERT_CHAIN_POLICY_SSL_F12_WARNING_LEVEL = @as(u32, 1);
pub const CERT_CHAIN_POLICY_SSL_F12_ERROR_LEVEL = @as(u32, 2);
pub const CERT_CHAIN_POLICY_SSL_F12_NONE_CATEGORY = @as(u32, 0);
pub const CERT_CHAIN_POLICY_SSL_F12_WEAK_CRYPTO_CATEGORY = @as(u32, 1);
pub const CERT_CHAIN_POLICY_SSL_F12_ROOT_PROGRAM_CATEGORY = @as(u32, 2);
pub const SSL_HPKP_PKP_HEADER_INDEX = @as(u32, 0);
pub const SSL_HPKP_PKP_RO_HEADER_INDEX = @as(u32, 1);
pub const SSL_HPKP_HEADER_COUNT = @as(u32, 2);
pub const SSL_KEY_PIN_ERROR_TEXT_LENGTH = @as(u32, 512);
pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_ERROR = @as(i32, -2);
pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_ERROR = @as(i32, -1);
pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_SUCCESS = @as(u32, 0);
pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_WARNING = @as(u32, 1);
pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_WARNING = @as(u32, 2);
pub const CRYPT_STRING_BASE64URI = @as(u32, 13);
pub const CRYPT_STRING_ENCODEMASK = @as(u32, 255);
pub const CRYPT_STRING_RESERVED100 = @as(u32, 256);
pub const CRYPT_STRING_RESERVED200 = @as(u32, 512);
pub const CRYPT_STRING_PERCENTESCAPE = @as(u32, 134217728);
pub const CRYPT_STRING_HASHDATA = @as(u32, 268435456);
pub const CRYPT_STRING_NOCRLF = @as(u32, 1073741824);
pub const CRYPT_STRING_NOCR = @as(u32, 2147483648);
pub const PKCS12_IMPORT_SILENT = @as(u32, 64);
pub const PKCS12_ONLY_CERTIFICATES = @as(u32, 1024);
pub const PKCS12_ONLY_NOT_ENCRYPTED_CERTIFICATES = @as(u32, 2048);
pub const PKCS12_VIRTUAL_ISOLATION_KEY = @as(u32, 65536);
pub const PKCS12_IMPORT_RESERVED_MASK = @as(u32, 4294901760);
pub const PKCS12_ONLY_CERTIFICATES_PROVIDER_TYPE = @as(u32, 0);
pub const REPORT_NO_PRIVATE_KEY = @as(u32, 1);
pub const REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY = @as(u32, 2);
pub const EXPORT_PRIVATE_KEYS = @as(u32, 4);
pub const PKCS12_PROTECT_TO_DOMAIN_SIDS = @as(u32, 32);
pub const PKCS12_EXPORT_SILENT = @as(u32, 64);
pub const PKCS12_EXPORT_PBES2_PARAMS = @as(u32, 128);
pub const PKCS12_DISABLE_ENCRYPT_CERTIFICATES = @as(u32, 256);
pub const PKCS12_ENCRYPT_CERTIFICATES = @as(u32, 512);
pub const PKCS12_EXPORT_ECC_CURVE_PARAMETERS = @as(u32, 4096);
pub const PKCS12_EXPORT_ECC_CURVE_OID = @as(u32, 8192);
pub const PKCS12_EXPORT_RESERVED_MASK = @as(u32, 4294901760);
pub const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA_READ_FLAG = @as(u32, 1);
pub const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA_WRITE_FLAG = @as(u32, 2);
pub const CERT_SERVER_OCSP_RESPONSE_ASYNC_FLAG = @as(u32, 1);
pub const CERT_SELECT_MAX_PARA = @as(u32, 500);
pub const CERT_SELECT_BY_ISSUER_DISPLAYNAME = @as(u32, 12);
pub const CERT_SELECT_BY_FRIENDLYNAME = @as(u32, 13);
pub const CERT_SELECT_BY_THUMBPRINT = @as(u32, 14);
pub const CERT_SELECT_ALLOW_EXPIRED = @as(u32, 1);
pub const CERT_SELECT_TRUSTED_ROOT = @as(u32, 2);
pub const CERT_SELECT_DISALLOW_SELFSIGNED = @as(u32, 4);
pub const CERT_SELECT_HAS_PRIVATE_KEY = @as(u32, 8);
pub const CERT_SELECT_HAS_KEY_FOR_SIGNATURE = @as(u32, 16);
pub const CERT_SELECT_HAS_KEY_FOR_KEY_EXCHANGE = @as(u32, 32);
pub const CERT_SELECT_HARDWARE_ONLY = @as(u32, 64);
pub const CERT_SELECT_ALLOW_DUPLICATES = @as(u32, 128);
pub const CERT_SELECT_IGNORE_AUTOSELECT = @as(u32, 256);
pub const TIMESTAMP_FAILURE_BAD_ALG = @as(u32, 0);
pub const TIMESTAMP_FAILURE_BAD_REQUEST = @as(u32, 2);
pub const TIMESTAMP_FAILURE_BAD_FORMAT = @as(u32, 5);
pub const TIMESTAMP_FAILURE_TIME_NOT_AVAILABLE = @as(u32, 14);
pub const TIMESTAMP_FAILURE_POLICY_NOT_SUPPORTED = @as(u32, 15);
pub const TIMESTAMP_FAILURE_EXTENSION_NOT_SUPPORTED = @as(u32, 16);
pub const TIMESTAMP_FAILURE_INFO_NOT_AVAILABLE = @as(u32, 17);
pub const TIMESTAMP_FAILURE_SYSTEM_FAILURE = @as(u32, 25);
pub const TIMESTAMP_DONT_HASH_DATA = @as(u32, 1);
pub const TIMESTAMP_VERIFY_CONTEXT_SIGNATURE = @as(u32, 32);
pub const TIMESTAMP_NO_AUTH_RETRIEVAL = @as(u32, 131072);
pub const CRYPT_OBJECT_LOCATOR_SPN_NAME_TYPE = @as(u32, 1);
pub const CRYPT_OBJECT_LOCATOR_LAST_RESERVED_NAME_TYPE = @as(u32, 32);
pub const CRYPT_OBJECT_LOCATOR_FIRST_RESERVED_USER_NAME_TYPE = @as(u32, 33);
pub const CRYPT_OBJECT_LOCATOR_LAST_RESERVED_USER_NAME_TYPE = @as(u32, 65535);
pub const CERT_FILE_HASH_USE_TYPE = @as(u32, 1);
pub const CERT_TIMESTAMP_HASH_USE_TYPE = @as(u32, 2);
//--------------------------------------------------------------------------------
// Section: Types (580)
//--------------------------------------------------------------------------------
pub const BCRYPT_OPERATION = enum(u32) {
CIPHER_OPERATION = 1,
HASH_OPERATION = 2,
ASYMMETRIC_ENCRYPTION_OPERATION = 4,
SECRET_AGREEMENT_OPERATION = 8,
SIGNATURE_OPERATION = 16,
RNG_OPERATION = 32,
_,
pub fn initFlags(o: struct {
CIPHER_OPERATION: u1 = 0,
HASH_OPERATION: u1 = 0,
ASYMMETRIC_ENCRYPTION_OPERATION: u1 = 0,
SECRET_AGREEMENT_OPERATION: u1 = 0,
SIGNATURE_OPERATION: u1 = 0,
RNG_OPERATION: u1 = 0,
}) BCRYPT_OPERATION {
return @intToEnum(BCRYPT_OPERATION,
(if (o.CIPHER_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.CIPHER_OPERATION) else 0)
| (if (o.HASH_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.HASH_OPERATION) else 0)
| (if (o.ASYMMETRIC_ENCRYPTION_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.ASYMMETRIC_ENCRYPTION_OPERATION) else 0)
| (if (o.SECRET_AGREEMENT_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.SECRET_AGREEMENT_OPERATION) else 0)
| (if (o.SIGNATURE_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.SIGNATURE_OPERATION) else 0)
| (if (o.RNG_OPERATION == 1) @enumToInt(BCRYPT_OPERATION.RNG_OPERATION) else 0)
);
}
};
pub const BCRYPT_CIPHER_OPERATION = BCRYPT_OPERATION.CIPHER_OPERATION;
pub const BCRYPT_HASH_OPERATION = BCRYPT_OPERATION.HASH_OPERATION;
pub const BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION = BCRYPT_OPERATION.ASYMMETRIC_ENCRYPTION_OPERATION;
pub const BCRYPT_SECRET_AGREEMENT_OPERATION = BCRYPT_OPERATION.SECRET_AGREEMENT_OPERATION;
pub const BCRYPT_SIGNATURE_OPERATION = BCRYPT_OPERATION.SIGNATURE_OPERATION;
pub const BCRYPT_RNG_OPERATION = BCRYPT_OPERATION.RNG_OPERATION;
pub const NCRYPT_OPERATION = enum(u32) {
CIPHER_OPERATION = 1,
HASH_OPERATION = 2,
ASYMMETRIC_ENCRYPTION_OPERATION = 4,
SECRET_AGREEMENT_OPERATION = 8,
SIGNATURE_OPERATION = 16,
_,
pub fn initFlags(o: struct {
CIPHER_OPERATION: u1 = 0,
HASH_OPERATION: u1 = 0,
ASYMMETRIC_ENCRYPTION_OPERATION: u1 = 0,
SECRET_AGREEMENT_OPERATION: u1 = 0,
SIGNATURE_OPERATION: u1 = 0,
}) NCRYPT_OPERATION {
return @intToEnum(NCRYPT_OPERATION,
(if (o.CIPHER_OPERATION == 1) @enumToInt(NCRYPT_OPERATION.CIPHER_OPERATION) else 0)
| (if (o.HASH_OPERATION == 1) @enumToInt(NCRYPT_OPERATION.HASH_OPERATION) else 0)
| (if (o.ASYMMETRIC_ENCRYPTION_OPERATION == 1) @enumToInt(NCRYPT_OPERATION.ASYMMETRIC_ENCRYPTION_OPERATION) else 0)
| (if (o.SECRET_AGREEMENT_OPERATION == 1) @enumToInt(NCRYPT_OPERATION.SECRET_AGREEMENT_OPERATION) else 0)
| (if (o.SIGNATURE_OPERATION == 1) @enumToInt(NCRYPT_OPERATION.SIGNATURE_OPERATION) else 0)
);
}
};
pub const NCRYPT_CIPHER_OPERATION = NCRYPT_OPERATION.CIPHER_OPERATION;
pub const NCRYPT_HASH_OPERATION = NCRYPT_OPERATION.HASH_OPERATION;
pub const NCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION = NCRYPT_OPERATION.ASYMMETRIC_ENCRYPTION_OPERATION;
pub const NCRYPT_SECRET_AGREEMENT_OPERATION = NCRYPT_OPERATION.SECRET_AGREEMENT_OPERATION;
pub const NCRYPT_SIGNATURE_OPERATION = NCRYPT_OPERATION.SIGNATURE_OPERATION;
pub const CERT_FIND_FLAGS = enum(u32) {
ANY = 0,
CERT_ID = 1048576,
CTL_USAGE = 655360,
// ENHKEY_USAGE = 655360, this enum value conflicts with CTL_USAGE
EXISTING = 851968,
HASH = 65536,
HAS_PRIVATE_KEY = 1376256,
ISSUER_ATTR = 196612,
ISSUER_NAME = 131076,
ISSUER_OF = 786432,
ISSUER_STR = 524292,
KEY_IDENTIFIER = 983040,
KEY_SPEC = 589824,
MD5_HASH = 262144,
PROPERTY = 327680,
PUBLIC_KEY = 393216,
// SHA1_HASH = 65536, this enum value conflicts with HASH
SIGNATURE_HASH = 917504,
SUBJECT_ATTR = 196615,
SUBJECT_CERT = 720896,
SUBJECT_NAME = 131079,
SUBJECT_STR = 524295,
CROSS_CERT_DIST_POINTS = 1114112,
PUBKEY_MD5_HASH = 1179648,
SUBJECT_STR_A = 458759,
// SUBJECT_STR_W = 524295, this enum value conflicts with SUBJECT_STR
ISSUER_STR_A = 458756,
// ISSUER_STR_W = 524292, this enum value conflicts with ISSUER_STR
SUBJECT_INFO_ACCESS = 1245184,
HASH_STR = 1310720,
OPTIONAL_ENHKEY_USAGE_FLAG = 1,
EXT_ONLY_ENHKEY_USAGE_FLAG = 2,
PROP_ONLY_ENHKEY_USAGE_FLAG = 4,
NO_ENHKEY_USAGE_FLAG = 8,
OR_ENHKEY_USAGE_FLAG = 16,
VALID_ENHKEY_USAGE_FLAG = 32,
// OPTIONAL_CTL_USAGE_FLAG = 1, this enum value conflicts with OPTIONAL_ENHKEY_USAGE_FLAG
// EXT_ONLY_CTL_USAGE_FLAG = 2, this enum value conflicts with EXT_ONLY_ENHKEY_USAGE_FLAG
// PROP_ONLY_CTL_USAGE_FLAG = 4, this enum value conflicts with PROP_ONLY_ENHKEY_USAGE_FLAG
// NO_CTL_USAGE_FLAG = 8, this enum value conflicts with NO_ENHKEY_USAGE_FLAG
// OR_CTL_USAGE_FLAG = 16, this enum value conflicts with OR_ENHKEY_USAGE_FLAG
// VALID_CTL_USAGE_FLAG = 32, this enum value conflicts with VALID_ENHKEY_USAGE_FLAG
_,
pub fn initFlags(o: struct {
ANY: u1 = 0,
CERT_ID: u1 = 0,
CTL_USAGE: u1 = 0,
EXISTING: u1 = 0,
HASH: u1 = 0,
HAS_PRIVATE_KEY: u1 = 0,
ISSUER_ATTR: u1 = 0,
ISSUER_NAME: u1 = 0,
ISSUER_OF: u1 = 0,
ISSUER_STR: u1 = 0,
KEY_IDENTIFIER: u1 = 0,
KEY_SPEC: u1 = 0,
MD5_HASH: u1 = 0,
PROPERTY: u1 = 0,
PUBLIC_KEY: u1 = 0,
SIGNATURE_HASH: u1 = 0,
SUBJECT_ATTR: u1 = 0,
SUBJECT_CERT: u1 = 0,
SUBJECT_NAME: u1 = 0,
SUBJECT_STR: u1 = 0,
CROSS_CERT_DIST_POINTS: u1 = 0,
PUBKEY_MD5_HASH: u1 = 0,
SUBJECT_STR_A: u1 = 0,
ISSUER_STR_A: u1 = 0,
SUBJECT_INFO_ACCESS: u1 = 0,
HASH_STR: u1 = 0,
OPTIONAL_ENHKEY_USAGE_FLAG: u1 = 0,
EXT_ONLY_ENHKEY_USAGE_FLAG: u1 = 0,
PROP_ONLY_ENHKEY_USAGE_FLAG: u1 = 0,
NO_ENHKEY_USAGE_FLAG: u1 = 0,
OR_ENHKEY_USAGE_FLAG: u1 = 0,
VALID_ENHKEY_USAGE_FLAG: u1 = 0,
}) CERT_FIND_FLAGS {
return @intToEnum(CERT_FIND_FLAGS,
(if (o.ANY == 1) @enumToInt(CERT_FIND_FLAGS.ANY) else 0)
| (if (o.CERT_ID == 1) @enumToInt(CERT_FIND_FLAGS.CERT_ID) else 0)
| (if (o.CTL_USAGE == 1) @enumToInt(CERT_FIND_FLAGS.CTL_USAGE) else 0)
| (if (o.EXISTING == 1) @enumToInt(CERT_FIND_FLAGS.EXISTING) else 0)
| (if (o.HASH == 1) @enumToInt(CERT_FIND_FLAGS.HASH) else 0)
| (if (o.HAS_PRIVATE_KEY == 1) @enumToInt(CERT_FIND_FLAGS.HAS_PRIVATE_KEY) else 0)
| (if (o.ISSUER_ATTR == 1) @enumToInt(CERT_FIND_FLAGS.ISSUER_ATTR) else 0)
| (if (o.ISSUER_NAME == 1) @enumToInt(CERT_FIND_FLAGS.ISSUER_NAME) else 0)
| (if (o.ISSUER_OF == 1) @enumToInt(CERT_FIND_FLAGS.ISSUER_OF) else 0)
| (if (o.ISSUER_STR == 1) @enumToInt(CERT_FIND_FLAGS.ISSUER_STR) else 0)
| (if (o.KEY_IDENTIFIER == 1) @enumToInt(CERT_FIND_FLAGS.KEY_IDENTIFIER) else 0)
| (if (o.KEY_SPEC == 1) @enumToInt(CERT_FIND_FLAGS.KEY_SPEC) else 0)
| (if (o.MD5_HASH == 1) @enumToInt(CERT_FIND_FLAGS.MD5_HASH) else 0)
| (if (o.PROPERTY == 1) @enumToInt(CERT_FIND_FLAGS.PROPERTY) else 0)
| (if (o.PUBLIC_KEY == 1) @enumToInt(CERT_FIND_FLAGS.PUBLIC_KEY) else 0)
| (if (o.SIGNATURE_HASH == 1) @enumToInt(CERT_FIND_FLAGS.SIGNATURE_HASH) else 0)
| (if (o.SUBJECT_ATTR == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_ATTR) else 0)
| (if (o.SUBJECT_CERT == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_CERT) else 0)
| (if (o.SUBJECT_NAME == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_NAME) else 0)
| (if (o.SUBJECT_STR == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_STR) else 0)
| (if (o.CROSS_CERT_DIST_POINTS == 1) @enumToInt(CERT_FIND_FLAGS.CROSS_CERT_DIST_POINTS) else 0)
| (if (o.PUBKEY_MD5_HASH == 1) @enumToInt(CERT_FIND_FLAGS.PUBKEY_MD5_HASH) else 0)
| (if (o.SUBJECT_STR_A == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_STR_A) else 0)
| (if (o.ISSUER_STR_A == 1) @enumToInt(CERT_FIND_FLAGS.ISSUER_STR_A) else 0)
| (if (o.SUBJECT_INFO_ACCESS == 1) @enumToInt(CERT_FIND_FLAGS.SUBJECT_INFO_ACCESS) else 0)
| (if (o.HASH_STR == 1) @enumToInt(CERT_FIND_FLAGS.HASH_STR) else 0)
| (if (o.OPTIONAL_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.OPTIONAL_ENHKEY_USAGE_FLAG) else 0)
| (if (o.EXT_ONLY_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.EXT_ONLY_ENHKEY_USAGE_FLAG) else 0)
| (if (o.PROP_ONLY_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.PROP_ONLY_ENHKEY_USAGE_FLAG) else 0)
| (if (o.NO_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.NO_ENHKEY_USAGE_FLAG) else 0)
| (if (o.OR_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.OR_ENHKEY_USAGE_FLAG) else 0)
| (if (o.VALID_ENHKEY_USAGE_FLAG == 1) @enumToInt(CERT_FIND_FLAGS.VALID_ENHKEY_USAGE_FLAG) else 0)
);
}
};
pub const CERT_FIND_ANY = CERT_FIND_FLAGS.ANY;
pub const CERT_FIND_CERT_ID = CERT_FIND_FLAGS.CERT_ID;
pub const CERT_FIND_CTL_USAGE = CERT_FIND_FLAGS.CTL_USAGE;
pub const CERT_FIND_ENHKEY_USAGE = CERT_FIND_FLAGS.CTL_USAGE;
pub const CERT_FIND_EXISTING = CERT_FIND_FLAGS.EXISTING;
pub const CERT_FIND_HASH = CERT_FIND_FLAGS.HASH;
pub const CERT_FIND_HAS_PRIVATE_KEY = CERT_FIND_FLAGS.HAS_PRIVATE_KEY;
pub const CERT_FIND_ISSUER_ATTR = CERT_FIND_FLAGS.ISSUER_ATTR;
pub const CERT_FIND_ISSUER_NAME = CERT_FIND_FLAGS.ISSUER_NAME;
pub const CERT_FIND_ISSUER_OF = CERT_FIND_FLAGS.ISSUER_OF;
pub const CERT_FIND_ISSUER_STR = CERT_FIND_FLAGS.ISSUER_STR;
pub const CERT_FIND_KEY_IDENTIFIER = CERT_FIND_FLAGS.KEY_IDENTIFIER;
pub const CERT_FIND_KEY_SPEC = CERT_FIND_FLAGS.KEY_SPEC;
pub const CERT_FIND_MD5_HASH = CERT_FIND_FLAGS.MD5_HASH;
pub const CERT_FIND_PROPERTY = CERT_FIND_FLAGS.PROPERTY;
pub const CERT_FIND_PUBLIC_KEY = CERT_FIND_FLAGS.PUBLIC_KEY;
pub const CERT_FIND_SHA1_HASH = CERT_FIND_FLAGS.HASH;
pub const CERT_FIND_SIGNATURE_HASH = CERT_FIND_FLAGS.SIGNATURE_HASH;
pub const CERT_FIND_SUBJECT_ATTR = CERT_FIND_FLAGS.SUBJECT_ATTR;
pub const CERT_FIND_SUBJECT_CERT = CERT_FIND_FLAGS.SUBJECT_CERT;
pub const CERT_FIND_SUBJECT_NAME = CERT_FIND_FLAGS.SUBJECT_NAME;
pub const CERT_FIND_SUBJECT_STR = CERT_FIND_FLAGS.SUBJECT_STR;
pub const CERT_FIND_CROSS_CERT_DIST_POINTS = CERT_FIND_FLAGS.CROSS_CERT_DIST_POINTS;
pub const CERT_FIND_PUBKEY_MD5_HASH = CERT_FIND_FLAGS.PUBKEY_MD5_HASH;
pub const CERT_FIND_SUBJECT_STR_A = CERT_FIND_FLAGS.SUBJECT_STR_A;
pub const CERT_FIND_SUBJECT_STR_W = CERT_FIND_FLAGS.SUBJECT_STR;
pub const CERT_FIND_ISSUER_STR_A = CERT_FIND_FLAGS.ISSUER_STR_A;
pub const CERT_FIND_ISSUER_STR_W = CERT_FIND_FLAGS.ISSUER_STR;
pub const CERT_FIND_SUBJECT_INFO_ACCESS = CERT_FIND_FLAGS.SUBJECT_INFO_ACCESS;
pub const CERT_FIND_HASH_STR = CERT_FIND_FLAGS.HASH_STR;
pub const CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.OPTIONAL_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.EXT_ONLY_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.PROP_ONLY_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_NO_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.NO_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_OR_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.OR_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_VALID_ENHKEY_USAGE_FLAG = CERT_FIND_FLAGS.VALID_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_OPTIONAL_CTL_USAGE_FLAG = CERT_FIND_FLAGS.OPTIONAL_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_EXT_ONLY_CTL_USAGE_FLAG = CERT_FIND_FLAGS.EXT_ONLY_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_PROP_ONLY_CTL_USAGE_FLAG = CERT_FIND_FLAGS.PROP_ONLY_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_NO_CTL_USAGE_FLAG = CERT_FIND_FLAGS.NO_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_OR_CTL_USAGE_FLAG = CERT_FIND_FLAGS.OR_ENHKEY_USAGE_FLAG;
pub const CERT_FIND_VALID_CTL_USAGE_FLAG = CERT_FIND_FLAGS.VALID_ENHKEY_USAGE_FLAG;
pub const CERT_QUERY_OBJECT_TYPE = enum(u32) {
FILE = 1,
BLOB = 2,
};
pub const CERT_QUERY_OBJECT_FILE = CERT_QUERY_OBJECT_TYPE.FILE;
pub const CERT_QUERY_OBJECT_BLOB = CERT_QUERY_OBJECT_TYPE.BLOB;
pub const CERT_QUERY_CONTENT_TYPE = enum(u32) {
CERT = 1,
CTL = 2,
CRL = 3,
SERIALIZED_STORE = 4,
SERIALIZED_CERT = 5,
SERIALIZED_CTL = 6,
SERIALIZED_CRL = 7,
PKCS7_SIGNED = 8,
PKCS7_UNSIGNED = 9,
PKCS7_SIGNED_EMBED = 10,
PKCS10 = 11,
PFX = 12,
CERT_PAIR = 13,
PFX_AND_LOAD = 14,
};
pub const CERT_QUERY_CONTENT_CERT = CERT_QUERY_CONTENT_TYPE.CERT;
pub const CERT_QUERY_CONTENT_CTL = CERT_QUERY_CONTENT_TYPE.CTL;
pub const CERT_QUERY_CONTENT_CRL = CERT_QUERY_CONTENT_TYPE.CRL;
pub const CERT_QUERY_CONTENT_SERIALIZED_STORE = CERT_QUERY_CONTENT_TYPE.SERIALIZED_STORE;
pub const CERT_QUERY_CONTENT_SERIALIZED_CERT = CERT_QUERY_CONTENT_TYPE.SERIALIZED_CERT;
pub const CERT_QUERY_CONTENT_SERIALIZED_CTL = CERT_QUERY_CONTENT_TYPE.SERIALIZED_CTL;
pub const CERT_QUERY_CONTENT_SERIALIZED_CRL = CERT_QUERY_CONTENT_TYPE.SERIALIZED_CRL;
pub const CERT_QUERY_CONTENT_PKCS7_SIGNED = CERT_QUERY_CONTENT_TYPE.PKCS7_SIGNED;
pub const CERT_QUERY_CONTENT_PKCS7_UNSIGNED = CERT_QUERY_CONTENT_TYPE.PKCS7_UNSIGNED;
pub const CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED = CERT_QUERY_CONTENT_TYPE.PKCS7_SIGNED_EMBED;
pub const CERT_QUERY_CONTENT_PKCS10 = CERT_QUERY_CONTENT_TYPE.PKCS10;
pub const CERT_QUERY_CONTENT_PFX = CERT_QUERY_CONTENT_TYPE.PFX;
pub const CERT_QUERY_CONTENT_CERT_PAIR = CERT_QUERY_CONTENT_TYPE.CERT_PAIR;
pub const CERT_QUERY_CONTENT_PFX_AND_LOAD = CERT_QUERY_CONTENT_TYPE.PFX_AND_LOAD;
pub const CERT_QUERY_CONTENT_TYPE_FLAGS = enum(u32) {
CERT = 2,
CTL = 4,
CRL = 8,
SERIALIZED_STORE = 16,
SERIALIZED_CERT = 32,
SERIALIZED_CTL = 64,
SERIALIZED_CRL = 128,
PKCS7_SIGNED = 256,
PKCS7_UNSIGNED = 512,
PKCS7_SIGNED_EMBED = 1024,
PKCS10 = 2048,
PFX = 4096,
CERT_PAIR = 8192,
PFX_AND_LOAD = 16384,
ALL = 16382,
ALL_ISSUER_CERT = 818,
};
pub const CERT_QUERY_CONTENT_FLAG_CERT = CERT_QUERY_CONTENT_TYPE_FLAGS.CERT;
pub const CERT_QUERY_CONTENT_FLAG_CTL = CERT_QUERY_CONTENT_TYPE_FLAGS.CTL;
pub const CERT_QUERY_CONTENT_FLAG_CRL = CERT_QUERY_CONTENT_TYPE_FLAGS.CRL;
pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE = CERT_QUERY_CONTENT_TYPE_FLAGS.SERIALIZED_STORE;
pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT = CERT_QUERY_CONTENT_TYPE_FLAGS.SERIALIZED_CERT;
pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL = CERT_QUERY_CONTENT_TYPE_FLAGS.SERIALIZED_CTL;
pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL = CERT_QUERY_CONTENT_TYPE_FLAGS.SERIALIZED_CRL;
pub const CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED = CERT_QUERY_CONTENT_TYPE_FLAGS.PKCS7_SIGNED;
pub const CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED = CERT_QUERY_CONTENT_TYPE_FLAGS.PKCS7_UNSIGNED;
pub const CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED = CERT_QUERY_CONTENT_TYPE_FLAGS.PKCS7_SIGNED_EMBED;
pub const CERT_QUERY_CONTENT_FLAG_PKCS10 = CERT_QUERY_CONTENT_TYPE_FLAGS.PKCS10;
pub const CERT_QUERY_CONTENT_FLAG_PFX = CERT_QUERY_CONTENT_TYPE_FLAGS.PFX;
pub const CERT_QUERY_CONTENT_FLAG_CERT_PAIR = CERT_QUERY_CONTENT_TYPE_FLAGS.CERT_PAIR;
pub const CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD = CERT_QUERY_CONTENT_TYPE_FLAGS.PFX_AND_LOAD;
pub const CERT_QUERY_CONTENT_FLAG_ALL = CERT_QUERY_CONTENT_TYPE_FLAGS.ALL;
pub const CERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERT = CERT_QUERY_CONTENT_TYPE_FLAGS.ALL_ISSUER_CERT;
pub const CERT_QUERY_FORMAT_TYPE = enum(u32) {
BINARY = 1,
BASE64_ENCODED = 2,
ASN_ASCII_HEX_ENCODED = 3,
};
pub const CERT_QUERY_FORMAT_BINARY = CERT_QUERY_FORMAT_TYPE.BINARY;
pub const CERT_QUERY_FORMAT_BASE64_ENCODED = CERT_QUERY_FORMAT_TYPE.BASE64_ENCODED;
pub const CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED = CERT_QUERY_FORMAT_TYPE.ASN_ASCII_HEX_ENCODED;
pub const CERT_QUERY_FORMAT_TYPE_FLAGS = enum(u32) {
BINARY = 2,
BASE64_ENCODED = 4,
ASN_ASCII_HEX_ENCODED = 8,
ALL = 14,
};
pub const CERT_QUERY_FORMAT_FLAG_BINARY = CERT_QUERY_FORMAT_TYPE_FLAGS.BINARY;
pub const CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED = CERT_QUERY_FORMAT_TYPE_FLAGS.BASE64_ENCODED;
pub const CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED = CERT_QUERY_FORMAT_TYPE_FLAGS.ASN_ASCII_HEX_ENCODED;
pub const CERT_QUERY_FORMAT_FLAG_ALL = CERT_QUERY_FORMAT_TYPE_FLAGS.ALL;
pub const CERT_QUERY_ENCODING_TYPE = enum(u32) {
X509_ASN_ENCODING = 1,
PKCS_7_ASN_ENCODING = 65536,
};
pub const X509_ASN_ENCODING = CERT_QUERY_ENCODING_TYPE.X509_ASN_ENCODING;
pub const PKCS_7_ASN_ENCODING = CERT_QUERY_ENCODING_TYPE.PKCS_7_ASN_ENCODING;
pub const CERT_STRING_TYPE = enum(u32) {
SIMPLE_NAME_STR = 1,
OID_NAME_STR = 2,
X500_NAME_STR = 3,
};
pub const CERT_SIMPLE_NAME_STR = CERT_STRING_TYPE.SIMPLE_NAME_STR;
pub const CERT_OID_NAME_STR = CERT_STRING_TYPE.OID_NAME_STR;
pub const CERT_X500_NAME_STR = CERT_STRING_TYPE.X500_NAME_STR;
pub const BCRYPT_TABLE = enum(u32) {
LOCAL = 1,
DOMAIN = 2,
};
pub const CRYPT_LOCAL = BCRYPT_TABLE.LOCAL;
pub const CRYPT_DOMAIN = BCRYPT_TABLE.DOMAIN;
pub const CERT_KEY_SPEC = enum(u32) {
AT_KEYEXCHANGE = 1,
AT_SIGNATURE = 2,
CERT_NCRYPT_KEY_SPEC = 4294967295,
};
pub const AT_KEYEXCHANGE = CERT_KEY_SPEC.AT_KEYEXCHANGE;
pub const AT_SIGNATURE = CERT_KEY_SPEC.AT_SIGNATURE;
pub const CERT_NCRYPT_KEY_SPEC = CERT_KEY_SPEC.CERT_NCRYPT_KEY_SPEC;
pub const BCRYPT_INTERFACE = enum(u32) {
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE = 3,
BCRYPT_CIPHER_INTERFACE = 1,
BCRYPT_HASH_INTERFACE = 2,
BCRYPT_RNG_INTERFACE = 6,
BCRYPT_SECRET_AGREEMENT_INTERFACE = 4,
BCRYPT_SIGNATURE_INTERFACE = 5,
NCRYPT_KEY_STORAGE_INTERFACE = 65537,
NCRYPT_SCHANNEL_INTERFACE = 65538,
NCRYPT_SCHANNEL_SIGNATURE_INTERFACE = 65539,
};
pub const BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE = BCRYPT_INTERFACE.BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE;
pub const BCRYPT_CIPHER_INTERFACE = BCRYPT_INTERFACE.BCRYPT_CIPHER_INTERFACE;
pub const BCRYPT_HASH_INTERFACE = BCRYPT_INTERFACE.BCRYPT_HASH_INTERFACE;
pub const BCRYPT_RNG_INTERFACE = BCRYPT_INTERFACE.BCRYPT_RNG_INTERFACE;
pub const BCRYPT_SECRET_AGREEMENT_INTERFACE = BCRYPT_INTERFACE.BCRYPT_SECRET_AGREEMENT_INTERFACE;
pub const BCRYPT_SIGNATURE_INTERFACE = BCRYPT_INTERFACE.BCRYPT_SIGNATURE_INTERFACE;
pub const NCRYPT_KEY_STORAGE_INTERFACE = BCRYPT_INTERFACE.NCRYPT_KEY_STORAGE_INTERFACE;
pub const NCRYPT_SCHANNEL_INTERFACE = BCRYPT_INTERFACE.NCRYPT_SCHANNEL_INTERFACE;
pub const NCRYPT_SCHANNEL_SIGNATURE_INTERFACE = BCRYPT_INTERFACE.NCRYPT_SCHANNEL_SIGNATURE_INTERFACE;
pub const CRYPTUI_WIZ_FLAGS = enum(u32) {
NO_UI = 1,
IGNORE_NO_UI_FLAG_FOR_CSPS = 2,
NO_UI_EXCEPT_CSP = 3,
IMPORT_ALLOW_CERT = 131072,
IMPORT_ALLOW_CRL = 262144,
IMPORT_ALLOW_CTL = 524288,
IMPORT_NO_CHANGE_DEST_STORE = 65536,
IMPORT_TO_LOCALMACHINE = 1048576,
IMPORT_TO_CURRENTUSER = 2097152,
IMPORT_REMOTE_DEST_STORE = 4194304,
EXPORT_PRIVATE_KEY = 256,
EXPORT_NO_DELETE_PRIVATE_KEY = 512,
_,
pub fn initFlags(o: struct {
NO_UI: u1 = 0,
IGNORE_NO_UI_FLAG_FOR_CSPS: u1 = 0,
NO_UI_EXCEPT_CSP: u1 = 0,
IMPORT_ALLOW_CERT: u1 = 0,
IMPORT_ALLOW_CRL: u1 = 0,
IMPORT_ALLOW_CTL: u1 = 0,
IMPORT_NO_CHANGE_DEST_STORE: u1 = 0,
IMPORT_TO_LOCALMACHINE: u1 = 0,
IMPORT_TO_CURRENTUSER: u1 = 0,
IMPORT_REMOTE_DEST_STORE: u1 = 0,
EXPORT_PRIVATE_KEY: u1 = 0,
EXPORT_NO_DELETE_PRIVATE_KEY: u1 = 0,
}) CRYPTUI_WIZ_FLAGS {
return @intToEnum(CRYPTUI_WIZ_FLAGS,
(if (o.NO_UI == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.NO_UI) else 0)
| (if (o.IGNORE_NO_UI_FLAG_FOR_CSPS == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IGNORE_NO_UI_FLAG_FOR_CSPS) else 0)
| (if (o.NO_UI_EXCEPT_CSP == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.NO_UI_EXCEPT_CSP) else 0)
| (if (o.IMPORT_ALLOW_CERT == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CERT) else 0)
| (if (o.IMPORT_ALLOW_CRL == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CRL) else 0)
| (if (o.IMPORT_ALLOW_CTL == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CTL) else 0)
| (if (o.IMPORT_NO_CHANGE_DEST_STORE == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_NO_CHANGE_DEST_STORE) else 0)
| (if (o.IMPORT_TO_LOCALMACHINE == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_TO_LOCALMACHINE) else 0)
| (if (o.IMPORT_TO_CURRENTUSER == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_TO_CURRENTUSER) else 0)
| (if (o.IMPORT_REMOTE_DEST_STORE == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.IMPORT_REMOTE_DEST_STORE) else 0)
| (if (o.EXPORT_PRIVATE_KEY == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.EXPORT_PRIVATE_KEY) else 0)
| (if (o.EXPORT_NO_DELETE_PRIVATE_KEY == 1) @enumToInt(CRYPTUI_WIZ_FLAGS.EXPORT_NO_DELETE_PRIVATE_KEY) else 0)
);
}
};
pub const CRYPTUI_WIZ_NO_UI = CRYPTUI_WIZ_FLAGS.NO_UI;
pub const CRYPTUI_WIZ_IGNORE_NO_UI_FLAG_FOR_CSPS = CRYPTUI_WIZ_FLAGS.IGNORE_NO_UI_FLAG_FOR_CSPS;
pub const CRYPTUI_WIZ_NO_UI_EXCEPT_CSP = CRYPTUI_WIZ_FLAGS.NO_UI_EXCEPT_CSP;
pub const CRYPTUI_WIZ_IMPORT_ALLOW_CERT = CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CERT;
pub const CRYPTUI_WIZ_IMPORT_ALLOW_CRL = CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CRL;
pub const CRYPTUI_WIZ_IMPORT_ALLOW_CTL = CRYPTUI_WIZ_FLAGS.IMPORT_ALLOW_CTL;
pub const CRYPTUI_WIZ_IMPORT_NO_CHANGE_DEST_STORE = CRYPTUI_WIZ_FLAGS.IMPORT_NO_CHANGE_DEST_STORE;
pub const CRYPTUI_WIZ_IMPORT_TO_LOCALMACHINE = CRYPTUI_WIZ_FLAGS.IMPORT_TO_LOCALMACHINE;
pub const CRYPTUI_WIZ_IMPORT_TO_CURRENTUSER = CRYPTUI_WIZ_FLAGS.IMPORT_TO_CURRENTUSER;
pub const CRYPTUI_WIZ_IMPORT_REMOTE_DEST_STORE = CRYPTUI_WIZ_FLAGS.IMPORT_REMOTE_DEST_STORE;
pub const CRYPTUI_WIZ_EXPORT_PRIVATE_KEY = CRYPTUI_WIZ_FLAGS.EXPORT_PRIVATE_KEY;
pub const CRYPTUI_WIZ_EXPORT_NO_DELETE_PRIVATE_KEY = CRYPTUI_WIZ_FLAGS.EXPORT_NO_DELETE_PRIVATE_KEY;
pub const NCRYPT_FLAGS = enum(u32) {
BCRYPT_PAD_NONE = 1,
BCRYPT_PAD_OAEP = 4,
BCRYPT_PAD_PKCS1 = 2,
BCRYPT_PAD_PSS = 8,
NCRYPT_SILENT_FLAG = 64,
// NCRYPT_NO_PADDING_FLAG = 1, this enum value conflicts with BCRYPT_PAD_NONE
// NCRYPT_PAD_OAEP_FLAG = 4, this enum value conflicts with BCRYPT_PAD_OAEP
// NCRYPT_PAD_PKCS1_FLAG = 2, this enum value conflicts with BCRYPT_PAD_PKCS1
// NCRYPT_REGISTER_NOTIFY_FLAG = 1, this enum value conflicts with BCRYPT_PAD_NONE
// NCRYPT_UNREGISTER_NOTIFY_FLAG = 2, this enum value conflicts with BCRYPT_PAD_PKCS1
NCRYPT_MACHINE_KEY_FLAG = 32,
// NCRYPT_UNPROTECT_NO_DECRYPT = 1, this enum value conflicts with BCRYPT_PAD_NONE
NCRYPT_OVERWRITE_KEY_FLAG = 128,
// NCRYPT_NO_KEY_VALIDATION = 8, this enum value conflicts with BCRYPT_PAD_PSS
NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG = 512,
// NCRYPT_PAD_PSS_FLAG = 8, this enum value conflicts with BCRYPT_PAD_PSS
NCRYPT_PERSIST_FLAG = 2147483648,
NCRYPT_PERSIST_ONLY_FLAG = 1073741824,
_,
pub fn initFlags(o: struct {
BCRYPT_PAD_NONE: u1 = 0,
BCRYPT_PAD_OAEP: u1 = 0,
BCRYPT_PAD_PKCS1: u1 = 0,
BCRYPT_PAD_PSS: u1 = 0,
NCRYPT_SILENT_FLAG: u1 = 0,
NCRYPT_MACHINE_KEY_FLAG: u1 = 0,
NCRYPT_OVERWRITE_KEY_FLAG: u1 = 0,
NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG: u1 = 0,
NCRYPT_PERSIST_FLAG: u1 = 0,
NCRYPT_PERSIST_ONLY_FLAG: u1 = 0,
}) NCRYPT_FLAGS {
return @intToEnum(NCRYPT_FLAGS,
(if (o.BCRYPT_PAD_NONE == 1) @enumToInt(NCRYPT_FLAGS.BCRYPT_PAD_NONE) else 0)
| (if (o.BCRYPT_PAD_OAEP == 1) @enumToInt(NCRYPT_FLAGS.BCRYPT_PAD_OAEP) else 0)
| (if (o.BCRYPT_PAD_PKCS1 == 1) @enumToInt(NCRYPT_FLAGS.BCRYPT_PAD_PKCS1) else 0)
| (if (o.BCRYPT_PAD_PSS == 1) @enumToInt(NCRYPT_FLAGS.BCRYPT_PAD_PSS) else 0)
| (if (o.NCRYPT_SILENT_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_SILENT_FLAG) else 0)
| (if (o.NCRYPT_MACHINE_KEY_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_MACHINE_KEY_FLAG) else 0)
| (if (o.NCRYPT_OVERWRITE_KEY_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_OVERWRITE_KEY_FLAG) else 0)
| (if (o.NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG) else 0)
| (if (o.NCRYPT_PERSIST_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_PERSIST_FLAG) else 0)
| (if (o.NCRYPT_PERSIST_ONLY_FLAG == 1) @enumToInt(NCRYPT_FLAGS.NCRYPT_PERSIST_ONLY_FLAG) else 0)
);
}
};
pub const BCRYPT_PAD_NONE = NCRYPT_FLAGS.BCRYPT_PAD_NONE;
pub const BCRYPT_PAD_OAEP = NCRYPT_FLAGS.BCRYPT_PAD_OAEP;
pub const BCRYPT_PAD_PKCS1 = NCRYPT_FLAGS.BCRYPT_PAD_PKCS1;
pub const BCRYPT_PAD_PSS = NCRYPT_FLAGS.BCRYPT_PAD_PSS;
pub const NCRYPT_SILENT_FLAG = NCRYPT_FLAGS.NCRYPT_SILENT_FLAG;
pub const NCRYPT_NO_PADDING_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_NONE;
pub const NCRYPT_PAD_OAEP_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_OAEP;
pub const NCRYPT_PAD_PKCS1_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_PKCS1;
pub const NCRYPT_REGISTER_NOTIFY_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_NONE;
pub const NCRYPT_UNREGISTER_NOTIFY_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_PKCS1;
pub const NCRYPT_MACHINE_KEY_FLAG = NCRYPT_FLAGS.NCRYPT_MACHINE_KEY_FLAG;
pub const NCRYPT_UNPROTECT_NO_DECRYPT = NCRYPT_FLAGS.BCRYPT_PAD_NONE;
pub const NCRYPT_OVERWRITE_KEY_FLAG = NCRYPT_FLAGS.NCRYPT_OVERWRITE_KEY_FLAG;
pub const NCRYPT_NO_KEY_VALIDATION = NCRYPT_FLAGS.BCRYPT_PAD_PSS;
pub const NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG = NCRYPT_FLAGS.NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG;
pub const NCRYPT_PAD_PSS_FLAG = NCRYPT_FLAGS.BCRYPT_PAD_PSS;
pub const NCRYPT_PERSIST_FLAG = NCRYPT_FLAGS.NCRYPT_PERSIST_FLAG;
pub const NCRYPT_PERSIST_ONLY_FLAG = NCRYPT_FLAGS.NCRYPT_PERSIST_ONLY_FLAG;
pub const CRYPT_STRING = enum(u32) {
BASE64HEADER = 0,
BASE64 = 1,
BINARY = 2,
BASE64REQUESTHEADER = 3,
HEX = 4,
HEXASCII = 5,
BASE64X509CRLHEADER = 9,
HEXADDR = 10,
HEXASCIIADDR = 11,
HEXRAW = 12,
STRICT = 536870912,
BASE64_ANY = 6,
ANY = 7,
HEX_ANY = 8,
};
pub const CRYPT_STRING_BASE64HEADER = CRYPT_STRING.BASE64HEADER;
pub const CRYPT_STRING_BASE64 = CRYPT_STRING.BASE64;
pub const CRYPT_STRING_BINARY = CRYPT_STRING.BINARY;
pub const CRYPT_STRING_BASE64REQUESTHEADER = CRYPT_STRING.BASE64REQUESTHEADER;
pub const CRYPT_STRING_HEX = CRYPT_STRING.HEX;
pub const CRYPT_STRING_HEXASCII = CRYPT_STRING.HEXASCII;
pub const CRYPT_STRING_BASE64X509CRLHEADER = CRYPT_STRING.BASE64X509CRLHEADER;
pub const CRYPT_STRING_HEXADDR = CRYPT_STRING.HEXADDR;
pub const CRYPT_STRING_HEXASCIIADDR = CRYPT_STRING.HEXASCIIADDR;
pub const CRYPT_STRING_HEXRAW = CRYPT_STRING.HEXRAW;
pub const CRYPT_STRING_STRICT = CRYPT_STRING.STRICT;
pub const CRYPT_STRING_BASE64_ANY = CRYPT_STRING.BASE64_ANY;
pub const CRYPT_STRING_ANY = CRYPT_STRING.ANY;
pub const CRYPT_STRING_HEX_ANY = CRYPT_STRING.HEX_ANY;
pub const CRYPT_IMPORT_PUBLIC_KEY_FLAGS = enum(u32) {
SIGN_KEY_FLAG = 2147483648,
ENCRYPT_KEY_FLAG = 1073741824,
_,
pub fn initFlags(o: struct {
SIGN_KEY_FLAG: u1 = 0,
ENCRYPT_KEY_FLAG: u1 = 0,
}) CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
return @intToEnum(CRYPT_IMPORT_PUBLIC_KEY_FLAGS,
(if (o.SIGN_KEY_FLAG == 1) @enumToInt(CRYPT_IMPORT_PUBLIC_KEY_FLAGS.SIGN_KEY_FLAG) else 0)
| (if (o.ENCRYPT_KEY_FLAG == 1) @enumToInt(CRYPT_IMPORT_PUBLIC_KEY_FLAGS.ENCRYPT_KEY_FLAG) else 0)
);
}
};
pub const CRYPT_OID_INFO_PUBKEY_SIGN_KEY_FLAG = CRYPT_IMPORT_PUBLIC_KEY_FLAGS.SIGN_KEY_FLAG;
pub const CRYPT_OID_INFO_PUBKEY_ENCRYPT_KEY_FLAG = CRYPT_IMPORT_PUBLIC_KEY_FLAGS.ENCRYPT_KEY_FLAG;
pub const CRYPT_XML_FLAGS = enum(u32) {
FLAG_DISABLE_EXTENSIONS = 268435456,
FLAG_NO_SERIALIZE = 2147483648,
SIGN_ADD_KEYVALUE = 1,
};
pub const CRYPT_XML_FLAG_DISABLE_EXTENSIONS = CRYPT_XML_FLAGS.FLAG_DISABLE_EXTENSIONS;
pub const CRYPT_XML_FLAG_NO_SERIALIZE = CRYPT_XML_FLAGS.FLAG_NO_SERIALIZE;
pub const CRYPT_XML_SIGN_ADD_KEYVALUE = CRYPT_XML_FLAGS.SIGN_ADD_KEYVALUE;
pub const CRYPT_ENCODE_OBJECT_FLAGS = enum(u32) {
ENCODE_ALLOC_FLAG = 32768,
ENCODE_ENABLE_PUNYCODE_FLAG = 131072,
UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG = 1073741824,
UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG = 2147483648,
UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG = 536870912,
_,
pub fn initFlags(o: struct {
ENCODE_ALLOC_FLAG: u1 = 0,
ENCODE_ENABLE_PUNYCODE_FLAG: u1 = 0,
UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG: u1 = 0,
UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG: u1 = 0,
UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG: u1 = 0,
}) CRYPT_ENCODE_OBJECT_FLAGS {
return @intToEnum(CRYPT_ENCODE_OBJECT_FLAGS,
(if (o.ENCODE_ALLOC_FLAG == 1) @enumToInt(CRYPT_ENCODE_OBJECT_FLAGS.ENCODE_ALLOC_FLAG) else 0)
| (if (o.ENCODE_ENABLE_PUNYCODE_FLAG == 1) @enumToInt(CRYPT_ENCODE_OBJECT_FLAGS.ENCODE_ENABLE_PUNYCODE_FLAG) else 0)
| (if (o.UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG == 1) @enumToInt(CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG) else 0)
| (if (o.UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG == 1) @enumToInt(CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG) else 0)
| (if (o.UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG == 1) @enumToInt(CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG) else 0)
);
}
};
pub const CRYPT_ENCODE_ALLOC_FLAG = CRYPT_ENCODE_OBJECT_FLAGS.ENCODE_ALLOC_FLAG;
pub const CRYPT_ENCODE_ENABLE_PUNYCODE_FLAG = CRYPT_ENCODE_OBJECT_FLAGS.ENCODE_ENABLE_PUNYCODE_FLAG;
pub const CRYPT_UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG = CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG;
pub const CRYPT_UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG = CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG;
pub const CRYPT_UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG = CRYPT_ENCODE_OBJECT_FLAGS.UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG;
pub const CRYPT_OBJECT_LOCATOR_RELEASE_REASON = enum(u32) {
SYSTEM_SHUTDOWN = 1,
SERVICE_STOP = 2,
PROCESS_EXIT = 3,
DLL_UNLOAD = 4,
};
pub const CRYPT_OBJECT_LOCATOR_RELEASE_SYSTEM_SHUTDOWN = CRYPT_OBJECT_LOCATOR_RELEASE_REASON.SYSTEM_SHUTDOWN;
pub const CRYPT_OBJECT_LOCATOR_RELEASE_SERVICE_STOP = CRYPT_OBJECT_LOCATOR_RELEASE_REASON.SERVICE_STOP;
pub const CRYPT_OBJECT_LOCATOR_RELEASE_PROCESS_EXIT = CRYPT_OBJECT_LOCATOR_RELEASE_REASON.PROCESS_EXIT;
pub const CRYPT_OBJECT_LOCATOR_RELEASE_DLL_UNLOAD = CRYPT_OBJECT_LOCATOR_RELEASE_REASON.DLL_UNLOAD;
pub const CRYPT_ACQUIRE_FLAGS = enum(u32) {
CACHE_FLAG = 1,
COMPARE_KEY_FLAG = 4,
NO_HEALING = 8,
SILENT_FLAG = 64,
USE_PROV_INFO_FLAG = 2,
_,
pub fn initFlags(o: struct {
CACHE_FLAG: u1 = 0,
COMPARE_KEY_FLAG: u1 = 0,
NO_HEALING: u1 = 0,
SILENT_FLAG: u1 = 0,
USE_PROV_INFO_FLAG: u1 = 0,
}) CRYPT_ACQUIRE_FLAGS {
return @intToEnum(CRYPT_ACQUIRE_FLAGS,
(if (o.CACHE_FLAG == 1) @enumToInt(CRYPT_ACQUIRE_FLAGS.CACHE_FLAG) else 0)
| (if (o.COMPARE_KEY_FLAG == 1) @enumToInt(CRYPT_ACQUIRE_FLAGS.COMPARE_KEY_FLAG) else 0)
| (if (o.NO_HEALING == 1) @enumToInt(CRYPT_ACQUIRE_FLAGS.NO_HEALING) else 0)
| (if (o.SILENT_FLAG == 1) @enumToInt(CRYPT_ACQUIRE_FLAGS.SILENT_FLAG) else 0)
| (if (o.USE_PROV_INFO_FLAG == 1) @enumToInt(CRYPT_ACQUIRE_FLAGS.USE_PROV_INFO_FLAG) else 0)
);
}
};
pub const CRYPT_ACQUIRE_CACHE_FLAG = CRYPT_ACQUIRE_FLAGS.CACHE_FLAG;
pub const CRYPT_ACQUIRE_COMPARE_KEY_FLAG = CRYPT_ACQUIRE_FLAGS.COMPARE_KEY_FLAG;
pub const CRYPT_ACQUIRE_NO_HEALING = CRYPT_ACQUIRE_FLAGS.NO_HEALING;
pub const CRYPT_ACQUIRE_SILENT_FLAG = CRYPT_ACQUIRE_FLAGS.SILENT_FLAG;
pub const CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = CRYPT_ACQUIRE_FLAGS.USE_PROV_INFO_FLAG;
pub const CRYPT_GET_URL_FLAGS = enum(u32) {
PROPERTY = 1,
EXTENSION = 2,
UNAUTH_ATTRIBUTE = 4,
AUTH_ATTRIBUTE = 8,
_,
pub fn initFlags(o: struct {
PROPERTY: u1 = 0,
EXTENSION: u1 = 0,
UNAUTH_ATTRIBUTE: u1 = 0,
AUTH_ATTRIBUTE: u1 = 0,
}) CRYPT_GET_URL_FLAGS {
return @intToEnum(CRYPT_GET_URL_FLAGS,
(if (o.PROPERTY == 1) @enumToInt(CRYPT_GET_URL_FLAGS.PROPERTY) else 0)
| (if (o.EXTENSION == 1) @enumToInt(CRYPT_GET_URL_FLAGS.EXTENSION) else 0)
| (if (o.UNAUTH_ATTRIBUTE == 1) @enumToInt(CRYPT_GET_URL_FLAGS.UNAUTH_ATTRIBUTE) else 0)
| (if (o.AUTH_ATTRIBUTE == 1) @enumToInt(CRYPT_GET_URL_FLAGS.AUTH_ATTRIBUTE) else 0)
);
}
};
pub const CRYPT_GET_URL_FROM_PROPERTY = CRYPT_GET_URL_FLAGS.PROPERTY;
pub const CRYPT_GET_URL_FROM_EXTENSION = CRYPT_GET_URL_FLAGS.EXTENSION;
pub const CRYPT_GET_URL_FROM_UNAUTH_ATTRIBUTE = CRYPT_GET_URL_FLAGS.UNAUTH_ATTRIBUTE;
pub const CRYPT_GET_URL_FROM_AUTH_ATTRIBUTE = CRYPT_GET_URL_FLAGS.AUTH_ATTRIBUTE;
pub const CERT_STORE_SAVE_AS = enum(u32) {
PKCS7 = 2,
STORE = 1,
};
pub const CERT_STORE_SAVE_AS_PKCS7 = CERT_STORE_SAVE_AS.PKCS7;
pub const CERT_STORE_SAVE_AS_STORE = CERT_STORE_SAVE_AS.STORE;
pub const BCRYPT_QUERY_PROVIDER_MODE = enum(u32) {
ANY = 4,
UM = 1,
KM = 2,
MM = 3,
};
pub const CRYPT_ANY = BCRYPT_QUERY_PROVIDER_MODE.ANY;
pub const CRYPT_UM = BCRYPT_QUERY_PROVIDER_MODE.UM;
pub const CRYPT_KM = BCRYPT_QUERY_PROVIDER_MODE.KM;
pub const CRYPT_MM = BCRYPT_QUERY_PROVIDER_MODE.MM;
pub const CERT_FIND_CHAIN_IN_STORE_FLAGS = enum(u32) {
COMPARE_KEY_FLAG = 1,
COMPLEX_CHAIN_FLAG = 2,
CACHE_ONLY_FLAG = 32768,
CACHE_ONLY_URL_FLAG = 4,
LOCAL_MACHINE_FLAG = 8,
NO_KEY_FLAG = 16384,
_,
pub fn initFlags(o: struct {
COMPARE_KEY_FLAG: u1 = 0,
COMPLEX_CHAIN_FLAG: u1 = 0,
CACHE_ONLY_FLAG: u1 = 0,
CACHE_ONLY_URL_FLAG: u1 = 0,
LOCAL_MACHINE_FLAG: u1 = 0,
NO_KEY_FLAG: u1 = 0,
}) CERT_FIND_CHAIN_IN_STORE_FLAGS {
return @intToEnum(CERT_FIND_CHAIN_IN_STORE_FLAGS,
(if (o.COMPARE_KEY_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.COMPARE_KEY_FLAG) else 0)
| (if (o.COMPLEX_CHAIN_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.COMPLEX_CHAIN_FLAG) else 0)
| (if (o.CACHE_ONLY_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.CACHE_ONLY_FLAG) else 0)
| (if (o.CACHE_ONLY_URL_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.CACHE_ONLY_URL_FLAG) else 0)
| (if (o.LOCAL_MACHINE_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.LOCAL_MACHINE_FLAG) else 0)
| (if (o.NO_KEY_FLAG == 1) @enumToInt(CERT_FIND_CHAIN_IN_STORE_FLAGS.NO_KEY_FLAG) else 0)
);
}
};
pub const CERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.COMPARE_KEY_FLAG;
pub const CERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.COMPLEX_CHAIN_FLAG;
pub const CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.CACHE_ONLY_FLAG;
pub const CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.CACHE_ONLY_URL_FLAG;
pub const CERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.LOCAL_MACHINE_FLAG;
pub const CERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAG = CERT_FIND_CHAIN_IN_STORE_FLAGS.NO_KEY_FLAG;
pub const CERT_CONTROL_STORE_FLAGS = enum(u32) {
COMMIT_FORCE_FLAG = 1,
COMMIT_CLEAR_FLAG = 2,
// INHIBIT_DUPLICATE_HANDLE_FLAG = 1, this enum value conflicts with COMMIT_FORCE_FLAG
};
pub const CERT_STORE_CTRL_COMMIT_FORCE_FLAG = CERT_CONTROL_STORE_FLAGS.COMMIT_FORCE_FLAG;
pub const CERT_STORE_CTRL_COMMIT_CLEAR_FLAG = CERT_CONTROL_STORE_FLAGS.COMMIT_CLEAR_FLAG;
pub const CERT_STORE_CTRL_INHIBIT_DUPLICATE_HANDLE_FLAG = CERT_CONTROL_STORE_FLAGS.COMMIT_FORCE_FLAG;
pub const BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS = enum(u32) {
ALG_HANDLE_HMAC_FLAG = 8,
PROV_DISPATCH = 1,
HASH_REUSABLE_FLAG = 32,
_,
pub fn initFlags(o: struct {
ALG_HANDLE_HMAC_FLAG: u1 = 0,
PROV_DISPATCH: u1 = 0,
HASH_REUSABLE_FLAG: u1 = 0,
}) BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
return @intToEnum(BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS,
(if (o.ALG_HANDLE_HMAC_FLAG == 1) @enumToInt(BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.ALG_HANDLE_HMAC_FLAG) else 0)
| (if (o.PROV_DISPATCH == 1) @enumToInt(BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.PROV_DISPATCH) else 0)
| (if (o.HASH_REUSABLE_FLAG == 1) @enumToInt(BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.HASH_REUSABLE_FLAG) else 0)
);
}
};
pub const BCRYPT_ALG_HANDLE_HMAC_FLAG = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.ALG_HANDLE_HMAC_FLAG;
pub const BCRYPT_PROV_DISPATCH = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.PROV_DISPATCH;
pub const BCRYPT_HASH_REUSABLE_FLAG = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS.HASH_REUSABLE_FLAG;
pub const CERT_STORE_SAVE_TO = enum(u32) {
FILE = 1,
FILENAME = 4,
FILENAME_A = 3,
// FILENAME_W = 4, this enum value conflicts with FILENAME
MEMORY = 2,
};
pub const CERT_STORE_SAVE_TO_FILE = CERT_STORE_SAVE_TO.FILE;
pub const CERT_STORE_SAVE_TO_FILENAME = CERT_STORE_SAVE_TO.FILENAME;
pub const CERT_STORE_SAVE_TO_FILENAME_A = CERT_STORE_SAVE_TO.FILENAME_A;
pub const CERT_STORE_SAVE_TO_FILENAME_W = CERT_STORE_SAVE_TO.FILENAME;
pub const CERT_STORE_SAVE_TO_MEMORY = CERT_STORE_SAVE_TO.MEMORY;
pub const CRYPT_SET_PROV_PARAM_ID = enum(u32) {
CLIENT_HWND = 1,
DELETEKEY = 24,
KEYEXCHANGE_ALG = 14,
KEYEXCHANGE_PIN = 32,
KEYEXCHANGE_KEYSIZE = 12,
KEYSET_SEC_DESCR = 8,
PIN_PROMPT_STRING = 44,
ROOT_CERTSTORE = 46,
SIGNATURE_ALG = 15,
SIGNATURE_PIN = 33,
SIGNATURE_KEYSIZE = 13,
UI_PROMPT = 21,
USE_HARDWARE_RNG = 38,
USER_CERTSTORE = 42,
SECURE_KEYEXCHANGE_PIN = 47,
SECURE_SIGNATURE_PIN = 48,
SMARTCARD_READER = 43,
};
pub const PP_CLIENT_HWND = CRYPT_SET_PROV_PARAM_ID.CLIENT_HWND;
pub const PP_DELETEKEY = CRYPT_SET_PROV_PARAM_ID.DELETEKEY;
pub const PP_KEYEXCHANGE_ALG = CRYPT_SET_PROV_PARAM_ID.KEYEXCHANGE_ALG;
pub const PP_KEYEXCHANGE_PIN = CRYPT_SET_PROV_PARAM_ID.KEYEXCHANGE_PIN;
pub const PP_KEYEXCHANGE_KEYSIZE = CRYPT_SET_PROV_PARAM_ID.KEYEXCHANGE_KEYSIZE;
pub const PP_KEYSET_SEC_DESCR = CRYPT_SET_PROV_PARAM_ID.KEYSET_SEC_DESCR;
pub const PP_PIN_PROMPT_STRING = CRYPT_SET_PROV_PARAM_ID.PIN_PROMPT_STRING;
pub const PP_ROOT_CERTSTORE = CRYPT_SET_PROV_PARAM_ID.ROOT_CERTSTORE;
pub const PP_SIGNATURE_ALG = CRYPT_SET_PROV_PARAM_ID.SIGNATURE_ALG;
pub const PP_SIGNATURE_PIN = CRYPT_SET_PROV_PARAM_ID.SIGNATURE_PIN;
pub const PP_SIGNATURE_KEYSIZE = CRYPT_SET_PROV_PARAM_ID.SIGNATURE_KEYSIZE;
pub const PP_UI_PROMPT = CRYPT_SET_PROV_PARAM_ID.UI_PROMPT;
pub const PP_USE_HARDWARE_RNG = CRYPT_SET_PROV_PARAM_ID.USE_HARDWARE_RNG;
pub const PP_USER_CERTSTORE = CRYPT_SET_PROV_PARAM_ID.USER_CERTSTORE;
pub const PP_SECURE_KEYEXCHANGE_PIN = CRYPT_SET_PROV_PARAM_ID.SECURE_KEYEXCHANGE_PIN;
pub const PP_SECURE_SIGNATURE_PIN = CRYPT_SET_PROV_PARAM_ID.SECURE_SIGNATURE_PIN;
pub const PP_SMARTCARD_READER = CRYPT_SET_PROV_PARAM_ID.SMARTCARD_READER;
pub const CRYPT_KEY_PARAM_ID = enum(u32) {
ALGID = 7,
CERTIFICATE = 26,
PERMISSIONS = 6,
SALT = 2,
SALT_EX = 10,
BLOCKLEN = 8,
GET_USE_COUNT = 42,
KEYLEN = 9,
};
pub const KP_ALGID = CRYPT_KEY_PARAM_ID.ALGID;
pub const KP_CERTIFICATE = CRYPT_KEY_PARAM_ID.CERTIFICATE;
pub const KP_PERMISSIONS = CRYPT_KEY_PARAM_ID.PERMISSIONS;
pub const KP_SALT = CRYPT_KEY_PARAM_ID.SALT;
pub const KP_SALT_EX = CRYPT_KEY_PARAM_ID.SALT_EX;
pub const KP_BLOCKLEN = CRYPT_KEY_PARAM_ID.BLOCKLEN;
pub const KP_GET_USE_COUNT = CRYPT_KEY_PARAM_ID.GET_USE_COUNT;
pub const KP_KEYLEN = CRYPT_KEY_PARAM_ID.KEYLEN;
pub const CRYPT_KEY_FLAGS = enum(u32) {
CRYPT_EXPORTABLE = 1,
CRYPT_USER_PROTECTED = 2,
CRYPT_ARCHIVABLE = 16384,
CRYPT_CREATE_IV = 512,
CRYPT_CREATE_SALT = 4,
CRYPT_DATA_KEY = 2048,
CRYPT_FORCE_KEY_PROTECTION_HIGH = 32768,
CRYPT_KEK = 1024,
CRYPT_INITIATOR = 64,
CRYPT_NO_SALT = 16,
CRYPT_ONLINE = 128,
// CRYPT_PREGEN = 64, this enum value conflicts with CRYPT_INITIATOR
// CRYPT_RECIPIENT = 16, this enum value conflicts with CRYPT_NO_SALT
CRYPT_SF = 256,
CRYPT_SGCKEY = 8192,
CRYPT_VOLATILE = 4096,
CRYPT_MACHINE_KEYSET = 32,
// CRYPT_USER_KEYSET = 4096, this enum value conflicts with CRYPT_VOLATILE
// PKCS12_PREFER_CNG_KSP = 256, this enum value conflicts with CRYPT_SF
// PKCS12_ALWAYS_CNG_KSP = 512, this enum value conflicts with CRYPT_CREATE_IV
// PKCS12_ALLOW_OVERWRITE_KEY = 16384, this enum value conflicts with CRYPT_ARCHIVABLE
// PKCS12_NO_PERSIST_KEY = 32768, this enum value conflicts with CRYPT_FORCE_KEY_PROTECTION_HIGH
// PKCS12_INCLUDE_EXTENDED_PROPERTIES = 16, this enum value conflicts with CRYPT_NO_SALT
// CRYPT_OAEP = 64, this enum value conflicts with CRYPT_INITIATOR
// CRYPT_BLOB_VER3 = 128, this enum value conflicts with CRYPT_ONLINE
// CRYPT_DESTROYKEY = 4, this enum value conflicts with CRYPT_CREATE_SALT
// CRYPT_SSL2_FALLBACK = 2, this enum value conflicts with CRYPT_USER_PROTECTED
// CRYPT_Y_ONLY = 1, this enum value conflicts with CRYPT_EXPORTABLE
// CRYPT_IPSEC_HMAC_KEY = 256, this enum value conflicts with CRYPT_SF
// CERT_SET_KEY_PROV_HANDLE_PROP_ID = 1, this enum value conflicts with CRYPT_EXPORTABLE
// CERT_SET_KEY_CONTEXT_PROP_ID = 1, this enum value conflicts with CRYPT_EXPORTABLE
_,
pub fn initFlags(o: struct {
CRYPT_EXPORTABLE: u1 = 0,
CRYPT_USER_PROTECTED: u1 = 0,
CRYPT_ARCHIVABLE: u1 = 0,
CRYPT_CREATE_IV: u1 = 0,
CRYPT_CREATE_SALT: u1 = 0,
CRYPT_DATA_KEY: u1 = 0,
CRYPT_FORCE_KEY_PROTECTION_HIGH: u1 = 0,
CRYPT_KEK: u1 = 0,
CRYPT_INITIATOR: u1 = 0,
CRYPT_NO_SALT: u1 = 0,
CRYPT_ONLINE: u1 = 0,
CRYPT_SF: u1 = 0,
CRYPT_SGCKEY: u1 = 0,
CRYPT_VOLATILE: u1 = 0,
CRYPT_MACHINE_KEYSET: u1 = 0,
}) CRYPT_KEY_FLAGS {
return @intToEnum(CRYPT_KEY_FLAGS,
(if (o.CRYPT_EXPORTABLE == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_EXPORTABLE) else 0)
| (if (o.CRYPT_USER_PROTECTED == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_USER_PROTECTED) else 0)
| (if (o.CRYPT_ARCHIVABLE == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_ARCHIVABLE) else 0)
| (if (o.CRYPT_CREATE_IV == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_CREATE_IV) else 0)
| (if (o.CRYPT_CREATE_SALT == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_CREATE_SALT) else 0)
| (if (o.CRYPT_DATA_KEY == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_DATA_KEY) else 0)
| (if (o.CRYPT_FORCE_KEY_PROTECTION_HIGH == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_FORCE_KEY_PROTECTION_HIGH) else 0)
| (if (o.CRYPT_KEK == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_KEK) else 0)
| (if (o.CRYPT_INITIATOR == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_INITIATOR) else 0)
| (if (o.CRYPT_NO_SALT == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_NO_SALT) else 0)
| (if (o.CRYPT_ONLINE == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_ONLINE) else 0)
| (if (o.CRYPT_SF == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_SF) else 0)
| (if (o.CRYPT_SGCKEY == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_SGCKEY) else 0)
| (if (o.CRYPT_VOLATILE == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_VOLATILE) else 0)
| (if (o.CRYPT_MACHINE_KEYSET == 1) @enumToInt(CRYPT_KEY_FLAGS.CRYPT_MACHINE_KEYSET) else 0)
);
}
};
pub const CRYPT_EXPORTABLE = CRYPT_KEY_FLAGS.CRYPT_EXPORTABLE;
pub const CRYPT_USER_PROTECTED = CRYPT_KEY_FLAGS.CRYPT_USER_PROTECTED;
pub const CRYPT_ARCHIVABLE = CRYPT_KEY_FLAGS.CRYPT_ARCHIVABLE;
pub const CRYPT_CREATE_IV = CRYPT_KEY_FLAGS.CRYPT_CREATE_IV;
pub const CRYPT_CREATE_SALT = CRYPT_KEY_FLAGS.CRYPT_CREATE_SALT;
pub const CRYPT_DATA_KEY = CRYPT_KEY_FLAGS.CRYPT_DATA_KEY;
pub const CRYPT_FORCE_KEY_PROTECTION_HIGH = CRYPT_KEY_FLAGS.CRYPT_FORCE_KEY_PROTECTION_HIGH;
pub const CRYPT_KEK = CRYPT_KEY_FLAGS.CRYPT_KEK;
pub const CRYPT_INITIATOR = CRYPT_KEY_FLAGS.CRYPT_INITIATOR;
pub const CRYPT_NO_SALT = CRYPT_KEY_FLAGS.CRYPT_NO_SALT;
pub const CRYPT_ONLINE = CRYPT_KEY_FLAGS.CRYPT_ONLINE;
pub const CRYPT_PREGEN = CRYPT_KEY_FLAGS.CRYPT_INITIATOR;
pub const CRYPT_RECIPIENT = CRYPT_KEY_FLAGS.CRYPT_NO_SALT;
pub const CRYPT_SF = CRYPT_KEY_FLAGS.CRYPT_SF;
pub const CRYPT_SGCKEY = CRYPT_KEY_FLAGS.CRYPT_SGCKEY;
pub const CRYPT_VOLATILE = CRYPT_KEY_FLAGS.CRYPT_VOLATILE;
pub const CRYPT_MACHINE_KEYSET = CRYPT_KEY_FLAGS.CRYPT_MACHINE_KEYSET;
pub const CRYPT_USER_KEYSET = CRYPT_KEY_FLAGS.CRYPT_VOLATILE;
pub const PKCS12_PREFER_CNG_KSP = CRYPT_KEY_FLAGS.CRYPT_SF;
pub const PKCS12_ALWAYS_CNG_KSP = CRYPT_KEY_FLAGS.CRYPT_CREATE_IV;
pub const PKCS12_ALLOW_OVERWRITE_KEY = CRYPT_KEY_FLAGS.CRYPT_ARCHIVABLE;
pub const PKCS12_NO_PERSIST_KEY = CRYPT_KEY_FLAGS.CRYPT_FORCE_KEY_PROTECTION_HIGH;
pub const PKCS12_INCLUDE_EXTENDED_PROPERTIES = CRYPT_KEY_FLAGS.CRYPT_NO_SALT;
pub const CRYPT_OAEP = CRYPT_KEY_FLAGS.CRYPT_INITIATOR;
pub const CRYPT_BLOB_VER3 = CRYPT_KEY_FLAGS.CRYPT_ONLINE;
pub const CRYPT_DESTROYKEY = CRYPT_KEY_FLAGS.CRYPT_CREATE_SALT;
pub const CRYPT_SSL2_FALLBACK = CRYPT_KEY_FLAGS.CRYPT_USER_PROTECTED;
pub const CRYPT_Y_ONLY = CRYPT_KEY_FLAGS.CRYPT_EXPORTABLE;
pub const CRYPT_IPSEC_HMAC_KEY = CRYPT_KEY_FLAGS.CRYPT_SF;
pub const CERT_SET_KEY_PROV_HANDLE_PROP_ID = CRYPT_KEY_FLAGS.CRYPT_EXPORTABLE;
pub const CERT_SET_KEY_CONTEXT_PROP_ID = CRYPT_KEY_FLAGS.CRYPT_EXPORTABLE;
pub const CRYPT_MSG_TYPE = enum(u32) {
DATA = 1,
SIGNED = 2,
ENVELOPED = 3,
SIGNED_AND_ENVELOPED = 4,
HASHED = 5,
};
pub const CMSG_DATA = CRYPT_MSG_TYPE.DATA;
pub const CMSG_SIGNED = CRYPT_MSG_TYPE.SIGNED;
pub const CMSG_ENVELOPED = CRYPT_MSG_TYPE.ENVELOPED;
pub const CMSG_SIGNED_AND_ENVELOPED = CRYPT_MSG_TYPE.SIGNED_AND_ENVELOPED;
pub const CMSG_HASHED = CRYPT_MSG_TYPE.HASHED;
pub const CERT_OPEN_STORE_FLAGS = enum(u32) {
BACKUP_RESTORE_FLAG = 2048,
CREATE_NEW_FLAG = 8192,
DEFER_CLOSE_UNTIL_LAST_FREE_FLAG = 4,
DELETE_FLAG = 16,
ENUM_ARCHIVED_FLAG = 512,
MAXIMUM_ALLOWED_FLAG = 4096,
NO_CRYPT_RELEASE_FLAG = 1,
OPEN_EXISTING_FLAG = 16384,
READONLY_FLAG = 32768,
SET_LOCALIZED_NAME_FLAG = 2,
SHARE_CONTEXT_FLAG = 128,
UPDATE_KEYID_FLAG = 1024,
};
pub const CERT_STORE_BACKUP_RESTORE_FLAG = CERT_OPEN_STORE_FLAGS.BACKUP_RESTORE_FLAG;
pub const CERT_STORE_CREATE_NEW_FLAG = CERT_OPEN_STORE_FLAGS.CREATE_NEW_FLAG;
pub const CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG = CERT_OPEN_STORE_FLAGS.DEFER_CLOSE_UNTIL_LAST_FREE_FLAG;
pub const CERT_STORE_DELETE_FLAG = CERT_OPEN_STORE_FLAGS.DELETE_FLAG;
pub const CERT_STORE_ENUM_ARCHIVED_FLAG = CERT_OPEN_STORE_FLAGS.ENUM_ARCHIVED_FLAG;
pub const CERT_STORE_MAXIMUM_ALLOWED_FLAG = CERT_OPEN_STORE_FLAGS.MAXIMUM_ALLOWED_FLAG;
pub const CERT_STORE_NO_CRYPT_RELEASE_FLAG = CERT_OPEN_STORE_FLAGS.NO_CRYPT_RELEASE_FLAG;
pub const CERT_STORE_OPEN_EXISTING_FLAG = CERT_OPEN_STORE_FLAGS.OPEN_EXISTING_FLAG;
pub const CERT_STORE_READONLY_FLAG = CERT_OPEN_STORE_FLAGS.READONLY_FLAG;
pub const CERT_STORE_SET_LOCALIZED_NAME_FLAG = CERT_OPEN_STORE_FLAGS.SET_LOCALIZED_NAME_FLAG;
pub const CERT_STORE_SHARE_CONTEXT_FLAG = CERT_OPEN_STORE_FLAGS.SHARE_CONTEXT_FLAG;
pub const CERT_STORE_UPDATE_KEYID_FLAG = CERT_OPEN_STORE_FLAGS.UPDATE_KEYID_FLAG;
pub const CRYPT_DEFAULT_CONTEXT_FLAGS = enum(u32) {
AUTO_RELEASE_FLAG = 1,
PROCESS_FLAG = 2,
_,
pub fn initFlags(o: struct {
AUTO_RELEASE_FLAG: u1 = 0,
PROCESS_FLAG: u1 = 0,
}) CRYPT_DEFAULT_CONTEXT_FLAGS {
return @intToEnum(CRYPT_DEFAULT_CONTEXT_FLAGS,
(if (o.AUTO_RELEASE_FLAG == 1) @enumToInt(CRYPT_DEFAULT_CONTEXT_FLAGS.AUTO_RELEASE_FLAG) else 0)
| (if (o.PROCESS_FLAG == 1) @enumToInt(CRYPT_DEFAULT_CONTEXT_FLAGS.PROCESS_FLAG) else 0)
);
}
};
pub const CRYPT_DEFAULT_CONTEXT_AUTO_RELEASE_FLAG = CRYPT_DEFAULT_CONTEXT_FLAGS.AUTO_RELEASE_FLAG;
pub const CRYPT_DEFAULT_CONTEXT_PROCESS_FLAG = CRYPT_DEFAULT_CONTEXT_FLAGS.PROCESS_FLAG;
pub const CRYPT_VERIFY_CERT_FLAGS = enum(u32) {
DISABLE_MD2_MD4_FLAG = 1,
SET_STRONG_PROPERTIES_FLAG = 2,
RETURN_STRONG_PROPERTIES_FLAG = 4,
};
pub const CRYPT_VERIFY_CERT_SIGN_DISABLE_MD2_MD4_FLAG = CRYPT_VERIFY_CERT_FLAGS.DISABLE_MD2_MD4_FLAG;
pub const CRYPT_VERIFY_CERT_SIGN_SET_STRONG_PROPERTIES_FLAG = CRYPT_VERIFY_CERT_FLAGS.SET_STRONG_PROPERTIES_FLAG;
pub const CRYPT_VERIFY_CERT_SIGN_RETURN_STRONG_PROPERTIES_FLAG = CRYPT_VERIFY_CERT_FLAGS.RETURN_STRONG_PROPERTIES_FLAG;
pub const CRYPT_SET_HASH_PARAM = enum(u32) {
MAC_INFO = 5,
ASHVAL = 2,
};
pub const HP_HMAC_INFO = CRYPT_SET_HASH_PARAM.MAC_INFO;
pub const HP_HASHVAL = CRYPT_SET_HASH_PARAM.ASHVAL;
pub const CERT_SYSTEM_STORE_FLAGS = enum(u32) {
LOCATION_MASK = 16711680,
RELOCATE_FLAG = 2147483648,
};
pub const CERT_SYSTEM_STORE_LOCATION_MASK = CERT_SYSTEM_STORE_FLAGS.LOCATION_MASK;
pub const CERT_SYSTEM_STORE_RELOCATE_FLAG = CERT_SYSTEM_STORE_FLAGS.RELOCATE_FLAG;
pub const CERT_CREATE_SELFSIGN_FLAGS = enum(u32) {
KEY_INFO = 2,
SIGN = 1,
_,
pub fn initFlags(o: struct {
KEY_INFO: u1 = 0,
SIGN: u1 = 0,
}) CERT_CREATE_SELFSIGN_FLAGS {
return @intToEnum(CERT_CREATE_SELFSIGN_FLAGS,
(if (o.KEY_INFO == 1) @enumToInt(CERT_CREATE_SELFSIGN_FLAGS.KEY_INFO) else 0)
| (if (o.SIGN == 1) @enumToInt(CERT_CREATE_SELFSIGN_FLAGS.SIGN) else 0)
);
}
};
pub const CERT_CREATE_SELFSIGN_NO_KEY_INFO = CERT_CREATE_SELFSIGN_FLAGS.KEY_INFO;
pub const CERT_CREATE_SELFSIGN_NO_SIGN = CERT_CREATE_SELFSIGN_FLAGS.SIGN;
pub const CRYPT_DEFAULT_CONTEXT_TYPE = enum(u32) {
CERT_SIGN_OID = 1,
MULTI_CERT_SIGN_OID = 2,
};
pub const CRYPT_DEFAULT_CONTEXT_CERT_SIGN_OID = CRYPT_DEFAULT_CONTEXT_TYPE.CERT_SIGN_OID;
pub const CRYPT_DEFAULT_CONTEXT_MULTI_CERT_SIGN_OID = CRYPT_DEFAULT_CONTEXT_TYPE.MULTI_CERT_SIGN_OID;
pub const BCRYPT_RESOLVE_PROVIDERS_FLAGS = enum(u32) {
FUNCTIONS = 1,
PROVIDERS = 2,
_,
pub fn initFlags(o: struct {
FUNCTIONS: u1 = 0,
PROVIDERS: u1 = 0,
}) BCRYPT_RESOLVE_PROVIDERS_FLAGS {
return @intToEnum(BCRYPT_RESOLVE_PROVIDERS_FLAGS,
(if (o.FUNCTIONS == 1) @enumToInt(BCRYPT_RESOLVE_PROVIDERS_FLAGS.FUNCTIONS) else 0)
| (if (o.PROVIDERS == 1) @enumToInt(BCRYPT_RESOLVE_PROVIDERS_FLAGS.PROVIDERS) else 0)
);
}
};
pub const CRYPT_ALL_FUNCTIONS = BCRYPT_RESOLVE_PROVIDERS_FLAGS.FUNCTIONS;
pub const CRYPT_ALL_PROVIDERS = BCRYPT_RESOLVE_PROVIDERS_FLAGS.PROVIDERS;
pub const CERT_FIND_TYPE = enum(u32) {
ANY = 0,
SHA1_HASH = 1,
MD5_HASH = 2,
USAGE = 3,
// SAME_USAGE_FLAG = 1, this enum value conflicts with SHA1_HASH
EXISTING = 5,
SUBJECT = 4,
};
pub const CTL_FIND_ANY = CERT_FIND_TYPE.ANY;
pub const CTL_FIND_SHA1_HASH = CERT_FIND_TYPE.SHA1_HASH;
pub const CTL_FIND_MD5_HASH = CERT_FIND_TYPE.MD5_HASH;
pub const CTL_FIND_USAGE = CERT_FIND_TYPE.USAGE;
pub const CTL_FIND_SAME_USAGE_FLAG = CERT_FIND_TYPE.SHA1_HASH;
pub const CTL_FIND_EXISTING = CERT_FIND_TYPE.EXISTING;
pub const CTL_FIND_SUBJECT = CERT_FIND_TYPE.SUBJECT;
pub const CRYPT_FIND_FLAGS = enum(u32) {
USER_KEYSET_FLAG = 1,
MACHINE_KEYSET_FLAG = 2,
SILENT_KEYSET_FLAG = 64,
};
pub const CRYPT_FIND_USER_KEYSET_FLAG = CRYPT_FIND_FLAGS.USER_KEYSET_FLAG;
pub const CRYPT_FIND_MACHINE_KEYSET_FLAG = CRYPT_FIND_FLAGS.MACHINE_KEYSET_FLAG;
pub const CRYPT_FIND_SILENT_KEYSET_FLAG = CRYPT_FIND_FLAGS.SILENT_KEYSET_FLAG;
pub const CRYPTUI_VIEWCERTIFICATE_FLAGS = enum(u32) {
HIDE_HIERARCHYPAGE = 1,
HIDE_DETAILPAGE = 2,
DISABLE_EDITPROPERTIES = 4,
ENABLE_EDITPROPERTIES = 8,
DISABLE_ADDTOSTORE = 16,
ENABLE_ADDTOSTORE = 32,
ACCEPT_DECLINE_STYLE = 64,
IGNORE_UNTRUSTED_ROOT = 128,
DONT_OPEN_STORES = 256,
ONLY_OPEN_ROOT_STORE = 512,
WARN_UNTRUSTED_ROOT = 1024,
ENABLE_REVOCATION_CHECKING = 2048,
WARN_REMOTE_TRUST = 4096,
DISABLE_EXPORT = 8192,
ENABLE_REVOCATION_CHECK_END_CERT = 16384,
ENABLE_REVOCATION_CHECK_CHAIN = 32768,
// ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 2048, this enum value conflicts with ENABLE_REVOCATION_CHECKING
DISABLE_HTMLLINK = 65536,
DISABLE_ISSUERSTATEMENT = 131072,
CACHE_ONLY_URL_RETRIEVAL = 262144,
_,
pub fn initFlags(o: struct {
HIDE_HIERARCHYPAGE: u1 = 0,
HIDE_DETAILPAGE: u1 = 0,
DISABLE_EDITPROPERTIES: u1 = 0,
ENABLE_EDITPROPERTIES: u1 = 0,
DISABLE_ADDTOSTORE: u1 = 0,
ENABLE_ADDTOSTORE: u1 = 0,
ACCEPT_DECLINE_STYLE: u1 = 0,
IGNORE_UNTRUSTED_ROOT: u1 = 0,
DONT_OPEN_STORES: u1 = 0,
ONLY_OPEN_ROOT_STORE: u1 = 0,
WARN_UNTRUSTED_ROOT: u1 = 0,
ENABLE_REVOCATION_CHECKING: u1 = 0,
WARN_REMOTE_TRUST: u1 = 0,
DISABLE_EXPORT: u1 = 0,
ENABLE_REVOCATION_CHECK_END_CERT: u1 = 0,
ENABLE_REVOCATION_CHECK_CHAIN: u1 = 0,
DISABLE_HTMLLINK: u1 = 0,
DISABLE_ISSUERSTATEMENT: u1 = 0,
CACHE_ONLY_URL_RETRIEVAL: u1 = 0,
}) CRYPTUI_VIEWCERTIFICATE_FLAGS {
return @intToEnum(CRYPTUI_VIEWCERTIFICATE_FLAGS,
(if (o.HIDE_HIERARCHYPAGE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.HIDE_HIERARCHYPAGE) else 0)
| (if (o.HIDE_DETAILPAGE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.HIDE_DETAILPAGE) else 0)
| (if (o.DISABLE_EDITPROPERTIES == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_EDITPROPERTIES) else 0)
| (if (o.ENABLE_EDITPROPERTIES == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_EDITPROPERTIES) else 0)
| (if (o.DISABLE_ADDTOSTORE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_ADDTOSTORE) else 0)
| (if (o.ENABLE_ADDTOSTORE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_ADDTOSTORE) else 0)
| (if (o.ACCEPT_DECLINE_STYLE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ACCEPT_DECLINE_STYLE) else 0)
| (if (o.IGNORE_UNTRUSTED_ROOT == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.IGNORE_UNTRUSTED_ROOT) else 0)
| (if (o.DONT_OPEN_STORES == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DONT_OPEN_STORES) else 0)
| (if (o.ONLY_OPEN_ROOT_STORE == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ONLY_OPEN_ROOT_STORE) else 0)
| (if (o.WARN_UNTRUSTED_ROOT == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.WARN_UNTRUSTED_ROOT) else 0)
| (if (o.ENABLE_REVOCATION_CHECKING == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECKING) else 0)
| (if (o.WARN_REMOTE_TRUST == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.WARN_REMOTE_TRUST) else 0)
| (if (o.DISABLE_EXPORT == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_EXPORT) else 0)
| (if (o.ENABLE_REVOCATION_CHECK_END_CERT == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECK_END_CERT) else 0)
| (if (o.ENABLE_REVOCATION_CHECK_CHAIN == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECK_CHAIN) else 0)
| (if (o.DISABLE_HTMLLINK == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_HTMLLINK) else 0)
| (if (o.DISABLE_ISSUERSTATEMENT == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_ISSUERSTATEMENT) else 0)
| (if (o.CACHE_ONLY_URL_RETRIEVAL == 1) @enumToInt(CRYPTUI_VIEWCERTIFICATE_FLAGS.CACHE_ONLY_URL_RETRIEVAL) else 0)
);
}
};
pub const CRYPTUI_HIDE_HIERARCHYPAGE = CRYPTUI_VIEWCERTIFICATE_FLAGS.HIDE_HIERARCHYPAGE;
pub const CRYPTUI_HIDE_DETAILPAGE = CRYPTUI_VIEWCERTIFICATE_FLAGS.HIDE_DETAILPAGE;
pub const CRYPTUI_DISABLE_EDITPROPERTIES = CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_EDITPROPERTIES;
pub const CRYPTUI_ENABLE_EDITPROPERTIES = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_EDITPROPERTIES;
pub const CRYPTUI_DISABLE_ADDTOSTORE = CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_ADDTOSTORE;
pub const CRYPTUI_ENABLE_ADDTOSTORE = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_ADDTOSTORE;
pub const CRYPTUI_ACCEPT_DECLINE_STYLE = CRYPTUI_VIEWCERTIFICATE_FLAGS.ACCEPT_DECLINE_STYLE;
pub const CRYPTUI_IGNORE_UNTRUSTED_ROOT = CRYPTUI_VIEWCERTIFICATE_FLAGS.IGNORE_UNTRUSTED_ROOT;
pub const CRYPTUI_DONT_OPEN_STORES = CRYPTUI_VIEWCERTIFICATE_FLAGS.DONT_OPEN_STORES;
pub const CRYPTUI_ONLY_OPEN_ROOT_STORE = CRYPTUI_VIEWCERTIFICATE_FLAGS.ONLY_OPEN_ROOT_STORE;
pub const CRYPTUI_WARN_UNTRUSTED_ROOT = CRYPTUI_VIEWCERTIFICATE_FLAGS.WARN_UNTRUSTED_ROOT;
pub const CRYPTUI_ENABLE_REVOCATION_CHECKING = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECKING;
pub const CRYPTUI_WARN_REMOTE_TRUST = CRYPTUI_VIEWCERTIFICATE_FLAGS.WARN_REMOTE_TRUST;
pub const CRYPTUI_DISABLE_EXPORT = CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_EXPORT;
pub const CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECK_END_CERT;
pub const CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECK_CHAIN;
pub const CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = CRYPTUI_VIEWCERTIFICATE_FLAGS.ENABLE_REVOCATION_CHECKING;
pub const CRYPTUI_DISABLE_HTMLLINK = CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_HTMLLINK;
pub const CRYPTUI_DISABLE_ISSUERSTATEMENT = CRYPTUI_VIEWCERTIFICATE_FLAGS.DISABLE_ISSUERSTATEMENT;
pub const CRYPTUI_CACHE_ONLY_URL_RETRIEVAL = CRYPTUI_VIEWCERTIFICATE_FLAGS.CACHE_ONLY_URL_RETRIEVAL;
pub const CRYPT_IMAGE_REF_FLAGS = enum(u32) {
MIN_DEPENDENCIES = 1,
PROCESS_ISOLATE = 65536,
_,
pub fn initFlags(o: struct {
MIN_DEPENDENCIES: u1 = 0,
PROCESS_ISOLATE: u1 = 0,
}) CRYPT_IMAGE_REF_FLAGS {
return @intToEnum(CRYPT_IMAGE_REF_FLAGS,
(if (o.MIN_DEPENDENCIES == 1) @enumToInt(CRYPT_IMAGE_REF_FLAGS.MIN_DEPENDENCIES) else 0)
| (if (o.PROCESS_ISOLATE == 1) @enumToInt(CRYPT_IMAGE_REF_FLAGS.PROCESS_ISOLATE) else 0)
);
}
};
pub const CRYPT_MIN_DEPENDENCIES = CRYPT_IMAGE_REF_FLAGS.MIN_DEPENDENCIES;
pub const CRYPT_PROCESS_ISOLATE = CRYPT_IMAGE_REF_FLAGS.PROCESS_ISOLATE;
pub const CERT_REVOCATION_STATUS_REASON = enum(u32) {
UNSPECIFIED = 0,
KEY_COMPROMISE = 1,
CA_COMPROMISE = 2,
AFFILIATION_CHANGED = 3,
SUPERSEDED = 4,
CESSATION_OF_OPERATION = 5,
CERTIFICATE_HOLD = 6,
REMOVE_FROM_CRL = 8,
};
pub const CRL_REASON_UNSPECIFIED = CERT_REVOCATION_STATUS_REASON.UNSPECIFIED;
pub const CRL_REASON_KEY_COMPROMISE = CERT_REVOCATION_STATUS_REASON.KEY_COMPROMISE;
pub const CRL_REASON_CA_COMPROMISE = CERT_REVOCATION_STATUS_REASON.CA_COMPROMISE;
pub const CRL_REASON_AFFILIATION_CHANGED = CERT_REVOCATION_STATUS_REASON.AFFILIATION_CHANGED;
pub const CRL_REASON_SUPERSEDED = CERT_REVOCATION_STATUS_REASON.SUPERSEDED;
pub const CRL_REASON_CESSATION_OF_OPERATION = CERT_REVOCATION_STATUS_REASON.CESSATION_OF_OPERATION;
pub const CRL_REASON_CERTIFICATE_HOLD = CERT_REVOCATION_STATUS_REASON.CERTIFICATE_HOLD;
pub const CRL_REASON_REMOVE_FROM_CRL = CERT_REVOCATION_STATUS_REASON.REMOVE_FROM_CRL;
pub const CERT_ROOT_PROGRAM_FLAGS = enum(u32) {
LSC = 64,
ORG = 128,
SUBJECT_LOGO = 32,
_,
pub fn initFlags(o: struct {
LSC: u1 = 0,
ORG: u1 = 0,
SUBJECT_LOGO: u1 = 0,
}) CERT_ROOT_PROGRAM_FLAGS {
return @intToEnum(CERT_ROOT_PROGRAM_FLAGS,
(if (o.LSC == 1) @enumToInt(CERT_ROOT_PROGRAM_FLAGS.LSC) else 0)
| (if (o.ORG == 1) @enumToInt(CERT_ROOT_PROGRAM_FLAGS.ORG) else 0)
| (if (o.SUBJECT_LOGO == 1) @enumToInt(CERT_ROOT_PROGRAM_FLAGS.SUBJECT_LOGO) else 0)
);
}
};
pub const CERT_ROOT_PROGRAM_FLAG_LSC = CERT_ROOT_PROGRAM_FLAGS.LSC;
pub const CERT_ROOT_PROGRAM_FLAG_ORG = CERT_ROOT_PROGRAM_FLAGS.ORG;
pub const CERT_ROOT_PROGRAM_FLAG_SUBJECT_LOGO = CERT_ROOT_PROGRAM_FLAGS.SUBJECT_LOGO;
pub const CRYPT_XML_KEY_VALUE_TYPE = enum(u32) {
DSA = 1,
RSA = 2,
ECDSA = 3,
CUSTOM = 4,
};
pub const CRYPT_XML_KEY_VALUE_TYPE_DSA = CRYPT_XML_KEY_VALUE_TYPE.DSA;
pub const CRYPT_XML_KEY_VALUE_TYPE_RSA = CRYPT_XML_KEY_VALUE_TYPE.RSA;
pub const CRYPT_XML_KEY_VALUE_TYPE_ECDSA = CRYPT_XML_KEY_VALUE_TYPE.ECDSA;
pub const CRYPT_XML_KEY_VALUE_TYPE_CUSTOM = CRYPT_XML_KEY_VALUE_TYPE.CUSTOM;
pub const CERT_LOGOTYPE_CHOICE = enum(u32) {
NO_IMAGE_RESOLUTION_CHOICE = 0,
BITS_IMAGE_RESOLUTION_CHOICE = 1,
TABLE_SIZE_IMAGE_RESOLUTION_CHOICE = 2,
};
pub const CERT_LOGOTYPE_NO_IMAGE_RESOLUTION_CHOICE = CERT_LOGOTYPE_CHOICE.NO_IMAGE_RESOLUTION_CHOICE;
pub const CERT_LOGOTYPE_BITS_IMAGE_RESOLUTION_CHOICE = CERT_LOGOTYPE_CHOICE.BITS_IMAGE_RESOLUTION_CHOICE;
pub const CERT_LOGOTYPE_TABLE_SIZE_IMAGE_RESOLUTION_CHOICE = CERT_LOGOTYPE_CHOICE.TABLE_SIZE_IMAGE_RESOLUTION_CHOICE;
pub const CERT_SELECT_STRUCT_FLAGS = enum(u32) {
HIDE_PROPERTIES = 1,
ENABLEHOOK = 2,
ALLOWMULTISELECT = 4,
SHOW_HELP = 16,
ENABLETEMPLATE = 32,
ENABLETEMPLATEHANDLE = 64,
_,
pub fn initFlags(o: struct {
HIDE_PROPERTIES: u1 = 0,
ENABLEHOOK: u1 = 0,
ALLOWMULTISELECT: u1 = 0,
SHOW_HELP: u1 = 0,
ENABLETEMPLATE: u1 = 0,
ENABLETEMPLATEHANDLE: u1 = 0,
}) CERT_SELECT_STRUCT_FLAGS {
return @intToEnum(CERT_SELECT_STRUCT_FLAGS,
(if (o.HIDE_PROPERTIES == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.HIDE_PROPERTIES) else 0)
| (if (o.ENABLEHOOK == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.ENABLEHOOK) else 0)
| (if (o.ALLOWMULTISELECT == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.ALLOWMULTISELECT) else 0)
| (if (o.SHOW_HELP == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.SHOW_HELP) else 0)
| (if (o.ENABLETEMPLATE == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.ENABLETEMPLATE) else 0)
| (if (o.ENABLETEMPLATEHANDLE == 1) @enumToInt(CERT_SELECT_STRUCT_FLAGS.ENABLETEMPLATEHANDLE) else 0)
);
}
};
pub const CSS_HIDE_PROPERTIES = CERT_SELECT_STRUCT_FLAGS.HIDE_PROPERTIES;
pub const CSS_ENABLEHOOK = CERT_SELECT_STRUCT_FLAGS.ENABLEHOOK;
pub const CSS_ALLOWMULTISELECT = CERT_SELECT_STRUCT_FLAGS.ALLOWMULTISELECT;
pub const CSS_SHOW_HELP = CERT_SELECT_STRUCT_FLAGS.SHOW_HELP;
pub const CSS_ENABLETEMPLATE = CERT_SELECT_STRUCT_FLAGS.ENABLETEMPLATE;
pub const CSS_ENABLETEMPLATEHANDLE = CERT_SELECT_STRUCT_FLAGS.ENABLETEMPLATEHANDLE;
pub const CMSG_KEY_AGREE_OPTION = enum(u32) {
EPHEMERAL_KEY_CHOICE = 1,
STATIC_KEY_CHOICE = 2,
};
pub const CMSG_KEY_AGREE_EPHEMERAL_KEY_CHOICE = CMSG_KEY_AGREE_OPTION.EPHEMERAL_KEY_CHOICE;
pub const CMSG_KEY_AGREE_STATIC_KEY_CHOICE = CMSG_KEY_AGREE_OPTION.STATIC_KEY_CHOICE;
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = enum(u32) {
FILE = 1,
CERT_CONTEXT = 2,
CTL_CONTEXT = 3,
CRL_CONTEXT = 4,
CERT_STORE = 5,
};
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_FILE = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION.FILE;
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION.CERT_CONTEXT;
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION.CTL_CONTEXT;
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION.CRL_CONTEXT;
pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION.CERT_STORE;
pub const CERT_LOGOTYPE_OPTION = enum(u32) {
DIRECT_INFO_CHOICE = 1,
INDIRECT_INFO_CHOICE = 2,
};
pub const CERT_LOGOTYPE_DIRECT_INFO_CHOICE = CERT_LOGOTYPE_OPTION.DIRECT_INFO_CHOICE;
pub const CERT_LOGOTYPE_INDIRECT_INFO_CHOICE = CERT_LOGOTYPE_OPTION.INDIRECT_INFO_CHOICE;
pub const CERT_STORE_PROV_FLAGS = enum(u32) {
EXTERNAL_FLAG = 1,
DELETED_FLAG = 2,
NO_PERSIST_FLAG = 4,
SYSTEM_STORE_FLAG = 8,
LM_SYSTEM_STORE_FLAG = 16,
_,
pub fn initFlags(o: struct {
EXTERNAL_FLAG: u1 = 0,
DELETED_FLAG: u1 = 0,
NO_PERSIST_FLAG: u1 = 0,
SYSTEM_STORE_FLAG: u1 = 0,
LM_SYSTEM_STORE_FLAG: u1 = 0,
}) CERT_STORE_PROV_FLAGS {
return @intToEnum(CERT_STORE_PROV_FLAGS,
(if (o.EXTERNAL_FLAG == 1) @enumToInt(CERT_STORE_PROV_FLAGS.EXTERNAL_FLAG) else 0)
| (if (o.DELETED_FLAG == 1) @enumToInt(CERT_STORE_PROV_FLAGS.DELETED_FLAG) else 0)
| (if (o.NO_PERSIST_FLAG == 1) @enumToInt(CERT_STORE_PROV_FLAGS.NO_PERSIST_FLAG) else 0)
| (if (o.SYSTEM_STORE_FLAG == 1) @enumToInt(CERT_STORE_PROV_FLAGS.SYSTEM_STORE_FLAG) else 0)
| (if (o.LM_SYSTEM_STORE_FLAG == 1) @enumToInt(CERT_STORE_PROV_FLAGS.LM_SYSTEM_STORE_FLAG) else 0)
);
}
};
pub const CERT_STORE_PROV_EXTERNAL_FLAG = CERT_STORE_PROV_FLAGS.EXTERNAL_FLAG;
pub const CERT_STORE_PROV_DELETED_FLAG = CERT_STORE_PROV_FLAGS.DELETED_FLAG;
pub const CERT_STORE_PROV_NO_PERSIST_FLAG = CERT_STORE_PROV_FLAGS.NO_PERSIST_FLAG;
pub const CERT_STORE_PROV_SYSTEM_STORE_FLAG = CERT_STORE_PROV_FLAGS.SYSTEM_STORE_FLAG;
pub const CERT_STORE_PROV_LM_SYSTEM_STORE_FLAG = CERT_STORE_PROV_FLAGS.LM_SYSTEM_STORE_FLAG;
pub const CMSG_KEY_AGREE_ORIGINATOR = enum(u32) {
CERT = 1,
PUBLIC_KEY = 2,
};
pub const CMSG_KEY_AGREE_ORIGINATOR_CERT = CMSG_KEY_AGREE_ORIGINATOR.CERT;
pub const CMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEY = CMSG_KEY_AGREE_ORIGINATOR.PUBLIC_KEY;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT = enum(u32) {
BLOB = 2,
FILE = 1,
NONE = 0,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_BLOB = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT.BLOB;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_FILE = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT.FILE;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_NONE = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT.NONE;
pub const CRYPT_CONTEXT_CONFIG_FLAGS = enum(u32) {
EXCLUSIVE = 1,
OVERRIDE = 65536,
_,
pub fn initFlags(o: struct {
EXCLUSIVE: u1 = 0,
OVERRIDE: u1 = 0,
}) CRYPT_CONTEXT_CONFIG_FLAGS {
return @intToEnum(CRYPT_CONTEXT_CONFIG_FLAGS,
(if (o.EXCLUSIVE == 1) @enumToInt(CRYPT_CONTEXT_CONFIG_FLAGS.EXCLUSIVE) else 0)
| (if (o.OVERRIDE == 1) @enumToInt(CRYPT_CONTEXT_CONFIG_FLAGS.OVERRIDE) else 0)
);
}
};
pub const CRYPT_EXCLUSIVE = CRYPT_CONTEXT_CONFIG_FLAGS.EXCLUSIVE;
pub const CRYPT_OVERRIDE = CRYPT_CONTEXT_CONFIG_FLAGS.OVERRIDE;
pub const BCRYPT_DSA_MAGIC = enum(u32) {
UBLIC_MAGIC = 1112560452,
RIVATE_MAGIC = 1448104772,
};
pub const BCRYPT_DSA_PUBLIC_MAGIC = BCRYPT_DSA_MAGIC.UBLIC_MAGIC;
pub const BCRYPT_DSA_PRIVATE_MAGIC = BCRYPT_DSA_MAGIC.RIVATE_MAGIC;
pub const CRYPTUI_WIZ_DIGITAL_SIGN = enum(u32) {
CERT = 1,
STORE = 2,
PVK = 3,
NONE = 0,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_CERT = CRYPTUI_WIZ_DIGITAL_SIGN.CERT;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_STORE = CRYPTUI_WIZ_DIGITAL_SIGN.STORE;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK = CRYPTUI_WIZ_DIGITAL_SIGN.PVK;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_NONE = CRYPTUI_WIZ_DIGITAL_SIGN.NONE;
pub const CRYPT_XML_X509DATA_TYPE = enum(u32) {
ISSUER_SERIAL = 1,
SKI = 2,
SUBJECT_NAME = 3,
CERTIFICATE = 4,
CRL = 5,
CUSTOM = 6,
};
pub const CRYPT_XML_X509DATA_TYPE_ISSUER_SERIAL = CRYPT_XML_X509DATA_TYPE.ISSUER_SERIAL;
pub const CRYPT_XML_X509DATA_TYPE_SKI = CRYPT_XML_X509DATA_TYPE.SKI;
pub const CRYPT_XML_X509DATA_TYPE_SUBJECT_NAME = CRYPT_XML_X509DATA_TYPE.SUBJECT_NAME;
pub const CRYPT_XML_X509DATA_TYPE_CERTIFICATE = CRYPT_XML_X509DATA_TYPE.CERTIFICATE;
pub const CRYPT_XML_X509DATA_TYPE_CRL = CRYPT_XML_X509DATA_TYPE.CRL;
pub const CRYPT_XML_X509DATA_TYPE_CUSTOM = CRYPT_XML_X509DATA_TYPE.CUSTOM;
pub const CERT_BIOMETRIC_DATA_TYPE = enum(u32) {
PREDEFINED_DATA_CHOICE = 1,
OID_DATA_CHOICE = 2,
};
pub const CERT_BIOMETRIC_PREDEFINED_DATA_CHOICE = CERT_BIOMETRIC_DATA_TYPE.PREDEFINED_DATA_CHOICE;
pub const CERT_BIOMETRIC_OID_DATA_CHOICE = CERT_BIOMETRIC_DATA_TYPE.OID_DATA_CHOICE;
pub const CERT_CHAIN_POLICY_FLAGS = enum(u32) {
IGNORE_NOT_TIME_VALID_FLAG = 1,
IGNORE_CTL_NOT_TIME_VALID_FLAG = 2,
IGNORE_NOT_TIME_NESTED_FLAG = 4,
IGNORE_ALL_NOT_TIME_VALID_FLAGS = 7,
IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = 8,
ALLOW_UNKNOWN_CA_FLAG = 16,
IGNORE_WRONG_USAGE_FLAG = 32,
IGNORE_INVALID_NAME_FLAG = 64,
IGNORE_INVALID_POLICY_FLAG = 128,
IGNORE_END_REV_UNKNOWN_FLAG = 256,
IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG = 512,
IGNORE_CA_REV_UNKNOWN_FLAG = 1024,
IGNORE_ROOT_REV_UNKNOWN_FLAG = 2048,
IGNORE_ALL_REV_UNKNOWN_FLAGS = 3840,
ALLOW_TESTROOT_FLAG = 32768,
TRUST_TESTROOT_FLAG = 16384,
IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAG = 8192,
IGNORE_PEER_TRUST_FLAG = 4096,
};
pub const CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_NOT_TIME_VALID_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_CTL_NOT_TIME_VALID_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_NOT_TIME_NESTED_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS = CERT_CHAIN_POLICY_FLAGS.IGNORE_ALL_NOT_TIME_VALID_FLAGS;
pub const CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG;
pub const CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG = CERT_CHAIN_POLICY_FLAGS.ALLOW_UNKNOWN_CA_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_WRONG_USAGE_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_INVALID_NAME_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_INVALID_POLICY_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_END_REV_UNKNOWN_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_CA_REV_UNKNOWN_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_ROOT_REV_UNKNOWN_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS = CERT_CHAIN_POLICY_FLAGS.IGNORE_ALL_REV_UNKNOWN_FLAGS;
pub const CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG = CERT_CHAIN_POLICY_FLAGS.ALLOW_TESTROOT_FLAG;
pub const CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG = CERT_CHAIN_POLICY_FLAGS.TRUST_TESTROOT_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAG;
pub const CERT_CHAIN_POLICY_IGNORE_PEER_TRUST_FLAG = CERT_CHAIN_POLICY_FLAGS.IGNORE_PEER_TRUST_FLAG;
pub const CERT_STRONG_SIGN_FLAGS = enum(u32) {
CRL_CHECK = 1,
OCSP_CHECK = 2,
_,
pub fn initFlags(o: struct {
CRL_CHECK: u1 = 0,
OCSP_CHECK: u1 = 0,
}) CERT_STRONG_SIGN_FLAGS {
return @intToEnum(CERT_STRONG_SIGN_FLAGS,
(if (o.CRL_CHECK == 1) @enumToInt(CERT_STRONG_SIGN_FLAGS.CRL_CHECK) else 0)
| (if (o.OCSP_CHECK == 1) @enumToInt(CERT_STRONG_SIGN_FLAGS.OCSP_CHECK) else 0)
);
}
};
pub const CERT_STRONG_SIGN_ENABLE_CRL_CHECK = CERT_STRONG_SIGN_FLAGS.CRL_CHECK;
pub const CERT_STRONG_SIGN_ENABLE_OCSP_CHECK = CERT_STRONG_SIGN_FLAGS.OCSP_CHECK;
pub const CERT_LOGOTYPE_IMAGE_INFO_TYPE = enum(u32) {
GRAY_SCALE_IMAGE_INFO_CHOICE = 1,
COLOR_IMAGE_INFO_CHOICE = 2,
};
pub const CERT_LOGOTYPE_GRAY_SCALE_IMAGE_INFO_CHOICE = CERT_LOGOTYPE_IMAGE_INFO_TYPE.GRAY_SCALE_IMAGE_INFO_CHOICE;
pub const CERT_LOGOTYPE_COLOR_IMAGE_INFO_CHOICE = CERT_LOGOTYPE_IMAGE_INFO_TYPE.COLOR_IMAGE_INFO_CHOICE;
pub const CRYPT_XML_STATUS_INFO_STATUS = enum(u32) {
INTERNAL_REFERENCE = 1,
KEY_AVAILABLE = 2,
DIGESTING = 4,
DIGEST_VALID = 8,
SIGNATURE_VALID = 65536,
OPENED_TO_ENCODE = 2147483648,
};
pub const CRYPT_XML_STATUS_INTERNAL_REFERENCE = CRYPT_XML_STATUS_INFO_STATUS.INTERNAL_REFERENCE;
pub const CRYPT_XML_STATUS_KEY_AVAILABLE = CRYPT_XML_STATUS_INFO_STATUS.KEY_AVAILABLE;
pub const CRYPT_XML_STATUS_DIGESTING = CRYPT_XML_STATUS_INFO_STATUS.DIGESTING;
pub const CRYPT_XML_STATUS_DIGEST_VALID = CRYPT_XML_STATUS_INFO_STATUS.DIGEST_VALID;
pub const CRYPT_XML_STATUS_SIGNATURE_VALID = CRYPT_XML_STATUS_INFO_STATUS.SIGNATURE_VALID;
pub const CRYPT_XML_STATUS_OPENED_TO_ENCODE = CRYPT_XML_STATUS_INFO_STATUS.OPENED_TO_ENCODE;
pub const CRYPT_XML_TRANSFORM_FLAGS = enum(u32) {
ON_STREAM = 1,
ON_NODESET = 2,
URI_QUERY_STRING = 3,
_,
pub fn initFlags(o: struct {
ON_STREAM: u1 = 0,
ON_NODESET: u1 = 0,
URI_QUERY_STRING: u1 = 0,
}) CRYPT_XML_TRANSFORM_FLAGS {
return @intToEnum(CRYPT_XML_TRANSFORM_FLAGS,
(if (o.ON_STREAM == 1) @enumToInt(CRYPT_XML_TRANSFORM_FLAGS.ON_STREAM) else 0)
| (if (o.ON_NODESET == 1) @enumToInt(CRYPT_XML_TRANSFORM_FLAGS.ON_NODESET) else 0)
| (if (o.URI_QUERY_STRING == 1) @enumToInt(CRYPT_XML_TRANSFORM_FLAGS.URI_QUERY_STRING) else 0)
);
}
};
pub const CRYPT_XML_TRANSFORM_ON_STREAM = CRYPT_XML_TRANSFORM_FLAGS.ON_STREAM;
pub const CRYPT_XML_TRANSFORM_ON_NODESET = CRYPT_XML_TRANSFORM_FLAGS.ON_NODESET;
pub const CRYPT_XML_TRANSFORM_URI_QUERY_STRING = CRYPT_XML_TRANSFORM_FLAGS.URI_QUERY_STRING;
pub const CRYPT_XML_GROUP_ID = enum(u32) {
HASH_________ = 1,
SIGN_________ = 2,
};
pub const CRYPT_XML_GROUP_ID_HASH_________ = CRYPT_XML_GROUP_ID.HASH_________;
pub const CRYPT_XML_GROUP_ID_SIGN_________ = CRYPT_XML_GROUP_ID.SIGN_________;
pub const CRYPTUI_WIZ_EXPORT_SUBJECT = enum(u32) {
ERT_CONTEXT = 1,
TL_CONTEXT = 2,
RL_CONTEXT = 3,
ERT_STORE = 4,
ERT_STORE_CERTIFICATES_ONLY = 5,
};
pub const CRYPTUI_WIZ_EXPORT_CERT_CONTEXT = CRYPTUI_WIZ_EXPORT_SUBJECT.ERT_CONTEXT;
pub const CRYPTUI_WIZ_EXPORT_CTL_CONTEXT = CRYPTUI_WIZ_EXPORT_SUBJECT.TL_CONTEXT;
pub const CRYPTUI_WIZ_EXPORT_CRL_CONTEXT = CRYPTUI_WIZ_EXPORT_SUBJECT.RL_CONTEXT;
pub const CRYPTUI_WIZ_EXPORT_CERT_STORE = CRYPTUI_WIZ_EXPORT_SUBJECT.ERT_STORE;
pub const CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY = CRYPTUI_WIZ_EXPORT_SUBJECT.ERT_STORE_CERTIFICATES_ONLY;
pub const CERT_SELECT_CRITERIA_TYPE = enum(u32) {
ENHKEY_USAGE = 1,
KEY_USAGE = 2,
POLICY_OID = 3,
PROV_NAME = 4,
EXTENSION = 5,
SUBJECT_HOST_NAME = 6,
ISSUER_ATTR = 7,
SUBJECT_ATTR = 8,
ISSUER_NAME = 9,
PUBLIC_KEY = 10,
TLS_SIGNATURES = 11,
};
pub const CERT_SELECT_BY_ENHKEY_USAGE = CERT_SELECT_CRITERIA_TYPE.ENHKEY_USAGE;
pub const CERT_SELECT_BY_KEY_USAGE = CERT_SELECT_CRITERIA_TYPE.KEY_USAGE;
pub const CERT_SELECT_BY_POLICY_OID = CERT_SELECT_CRITERIA_TYPE.POLICY_OID;
pub const CERT_SELECT_BY_PROV_NAME = CERT_SELECT_CRITERIA_TYPE.PROV_NAME;
pub const CERT_SELECT_BY_EXTENSION = CERT_SELECT_CRITERIA_TYPE.EXTENSION;
pub const CERT_SELECT_BY_SUBJECT_HOST_NAME = CERT_SELECT_CRITERIA_TYPE.SUBJECT_HOST_NAME;
pub const CERT_SELECT_BY_ISSUER_ATTR = CERT_SELECT_CRITERIA_TYPE.ISSUER_ATTR;
pub const CERT_SELECT_BY_SUBJECT_ATTR = CERT_SELECT_CRITERIA_TYPE.SUBJECT_ATTR;
pub const CERT_SELECT_BY_ISSUER_NAME = CERT_SELECT_CRITERIA_TYPE.ISSUER_NAME;
pub const CERT_SELECT_BY_PUBLIC_KEY = CERT_SELECT_CRITERIA_TYPE.PUBLIC_KEY;
pub const CERT_SELECT_BY_TLS_SIGNATURES = CERT_SELECT_CRITERIA_TYPE.TLS_SIGNATURES;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE = enum(u32) {
COMMERCIAL = 1,
INDIVIDUAL = 2,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_COMMERCIAL = CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE.COMMERCIAL;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_INDIVIDUAL = CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE.INDIVIDUAL;
pub const BCRYPT_RSAKEY_BLOB_MAGIC = enum(u32) {
PUBLIC_MAGIC = 826364754,
PRIVATE_MAGIC = 843141970,
FULLPRIVATE_MAGIC = 859919186,
};
pub const BCRYPT_RSAPUBLIC_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC.PUBLIC_MAGIC;
pub const BCRYPT_RSAPRIVATE_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC.PRIVATE_MAGIC;
pub const BCRYPT_RSAFULLPRIVATE_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC.FULLPRIVATE_MAGIC;
pub const CRYPT_XML_KEYINFO_TYPE = enum(u32) {
KEYNAME = 1,
KEYVALUE = 2,
RETRIEVAL = 3,
X509DATA = 4,
CUSTOM = 5,
};
pub const CRYPT_XML_KEYINFO_TYPE_KEYNAME = CRYPT_XML_KEYINFO_TYPE.KEYNAME;
pub const CRYPT_XML_KEYINFO_TYPE_KEYVALUE = CRYPT_XML_KEYINFO_TYPE.KEYVALUE;
pub const CRYPT_XML_KEYINFO_TYPE_RETRIEVAL = CRYPT_XML_KEYINFO_TYPE.RETRIEVAL;
pub const CRYPT_XML_KEYINFO_TYPE_X509DATA = CRYPT_XML_KEYINFO_TYPE.X509DATA;
pub const CRYPT_XML_KEYINFO_TYPE_CUSTOM = CRYPT_XML_KEYINFO_TYPE.CUSTOM;
pub const CRYPT_TIMESTAMP_VERSION = enum(u32) {
N = 1,
};
pub const TIMESTAMP_VERSION = CRYPT_TIMESTAMP_VERSION.N;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION = enum(u32) {
FILE = 1,
PROV = 2,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE = CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION.FILE;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_PROV = CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION.PROV;
pub const CERT_ID_OPTION = enum(u32) {
ISSUER_SERIAL_NUMBER = 1,
KEY_IDENTIFIER = 2,
SHA1_HASH = 3,
};
pub const CERT_ID_ISSUER_SERIAL_NUMBER = CERT_ID_OPTION.ISSUER_SERIAL_NUMBER;
pub const CERT_ID_KEY_IDENTIFIER = CERT_ID_OPTION.KEY_IDENTIFIER;
pub const CERT_ID_SHA1_HASH = CERT_ID_OPTION.SHA1_HASH;
pub const HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE = enum(u32) {
CLIENT = 1,
SERVER = 2,
};
pub const AUTHTYPE_CLIENT = HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE.CLIENT;
pub const AUTHTYPE_SERVER = HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE.SERVER;
pub const CRYPTUI_WIZ_EXPORT_FORMAT = enum(u32) {
DER = 1,
PFX = 2,
PKCS7 = 3,
BASE64 = 4,
CRL = 6,
CTL = 7,
};
pub const CRYPTUI_WIZ_EXPORT_FORMAT_DER = CRYPTUI_WIZ_EXPORT_FORMAT.DER;
pub const CRYPTUI_WIZ_EXPORT_FORMAT_PFX = CRYPTUI_WIZ_EXPORT_FORMAT.PFX;
pub const CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7 = CRYPTUI_WIZ_EXPORT_FORMAT.PKCS7;
pub const CRYPTUI_WIZ_EXPORT_FORMAT_BASE64 = CRYPTUI_WIZ_EXPORT_FORMAT.BASE64;
pub const CRYPTUI_WIZ_EXPORT_FORMAT_CRL = CRYPTUI_WIZ_EXPORT_FORMAT.CRL;
pub const CRYPTUI_WIZ_EXPORT_FORMAT_CTL = CRYPTUI_WIZ_EXPORT_FORMAT.CTL;
pub const BCRYPT_DH_KEY_BLOB_MAGIC = enum(u32) {
UBLIC_MAGIC = 1112557636,
RIVATE_MAGIC = 1448101956,
};
pub const BCRYPT_DH_PUBLIC_MAGIC = BCRYPT_DH_KEY_BLOB_MAGIC.UBLIC_MAGIC;
pub const BCRYPT_DH_PRIVATE_MAGIC = BCRYPT_DH_KEY_BLOB_MAGIC.RIVATE_MAGIC;
pub const CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE = enum(u32) {
CHAIN = 1,
CHAIN_NO_ROOT = 2,
NONE = 0,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_CHAIN = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE.CHAIN;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_CHAIN_NO_ROOT = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE.CHAIN_NO_ROOT;
pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_NONE = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE.NONE;
pub const CRYPT_XML_STATUS_ERROR_STATUS = enum(u32) {
NOT_RESOLVED = 1,
DIGEST_INVALID = 2,
NOT_SUPPORTED_ALGORITHM = 5,
NOT_SUPPORTED_TRANSFORM = 8,
SIGNATURE_INVALID = 65536,
KEYINFO_NOT_PARSED = 131072,
};
pub const CRYPT_XML_STATUS_ERROR_NOT_RESOLVED = CRYPT_XML_STATUS_ERROR_STATUS.NOT_RESOLVED;
pub const CRYPT_XML_STATUS_ERROR_DIGEST_INVALID = CRYPT_XML_STATUS_ERROR_STATUS.DIGEST_INVALID;
pub const CRYPT_XML_STATUS_ERROR_NOT_SUPPORTED_ALGORITHM = CRYPT_XML_STATUS_ERROR_STATUS.NOT_SUPPORTED_ALGORITHM;
pub const CRYPT_XML_STATUS_ERROR_NOT_SUPPORTED_TRANSFORM = CRYPT_XML_STATUS_ERROR_STATUS.NOT_SUPPORTED_TRANSFORM;
pub const CRYPT_XML_STATUS_ERROR_SIGNATURE_INVALID = CRYPT_XML_STATUS_ERROR_STATUS.SIGNATURE_INVALID;
pub const CRYPT_XML_STATUS_ERROR_KEYINFO_NOT_PARSED = CRYPT_XML_STATUS_ERROR_STATUS.KEYINFO_NOT_PARSED;
pub const CRYPT_TIMESTAMP_RESPONSE_STATUS = enum(u32) {
GRANTED = 0,
GRANTED_WITH_MODS = 1,
REJECTED = 2,
WAITING = 3,
REVOCATION_WARNING = 4,
REVOKED = 5,
};
pub const TIMESTAMP_STATUS_GRANTED = CRYPT_TIMESTAMP_RESPONSE_STATUS.GRANTED;
pub const TIMESTAMP_STATUS_GRANTED_WITH_MODS = CRYPT_TIMESTAMP_RESPONSE_STATUS.GRANTED_WITH_MODS;
pub const TIMESTAMP_STATUS_REJECTED = CRYPT_TIMESTAMP_RESPONSE_STATUS.REJECTED;
pub const TIMESTAMP_STATUS_WAITING = CRYPT_TIMESTAMP_RESPONSE_STATUS.WAITING;
pub const TIMESTAMP_STATUS_REVOCATION_WARNING = CRYPT_TIMESTAMP_RESPONSE_STATUS.REVOCATION_WARNING;
pub const TIMESTAMP_STATUS_REVOKED = CRYPT_TIMESTAMP_RESPONSE_STATUS.REVOKED;
pub const NCRYPT_ALGORITHM_NAME_CLASS = enum(u32) {
ASYMMETRIC_ENCRYPTION_INTERFACE = 3,
SECRET_AGREEMENT_INTERFACE = 4,
SIGNATURE_INTERFACE = 5,
};
pub const NCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE = NCRYPT_ALGORITHM_NAME_CLASS.ASYMMETRIC_ENCRYPTION_INTERFACE;
pub const NCRYPT_SECRET_AGREEMENT_INTERFACE = NCRYPT_ALGORITHM_NAME_CLASS.SECRET_AGREEMENT_INTERFACE;
pub const NCRYPT_SIGNATURE_INTERFACE = NCRYPT_ALGORITHM_NAME_CLASS.SIGNATURE_INTERFACE;
pub const CTL_MODIFY_REQUEST_OPERATION = enum(u32) {
ADD_TRUSTED = 3,
ADD_NOT_TRUSTED = 1,
REMOVE = 2,
};
pub const CTL_MODIFY_REQUEST_ADD_TRUSTED = CTL_MODIFY_REQUEST_OPERATION.ADD_TRUSTED;
pub const CTL_MODIFY_REQUEST_ADD_NOT_TRUSTED = CTL_MODIFY_REQUEST_OPERATION.ADD_NOT_TRUSTED;
pub const CTL_MODIFY_REQUEST_REMOVE = CTL_MODIFY_REQUEST_OPERATION.REMOVE;
// TODO: this type has a FreeFunc 'CryptCloseAsyncHandle', what can Zig do with this information?
pub const HCRYPTASYNC = *opaque{};
// TODO: this type has a FreeFunc 'CertFreeCertificateChainEngine', what can Zig do with this information?
pub const HCERTCHAINENGINE = *opaque{};
// TODO: this type has a FreeFunc 'BCryptCloseAlgorithmProvider', what can Zig do with this information?
pub const BCRYPT_ALG_HANDLE = isize;
// TODO: this type has a FreeFunc 'BCryptDestroyKey', what can Zig do with this information?
pub const BCRYPT_KEY_HANDLE = isize;
pub const CMS_KEY_INFO = extern struct {
dwVersion: u32,
Algid: u32,
pbOID: ?*u8,
cbOID: u32,
};
pub const HMAC_Info = extern struct {
HashAlgid: u32,
pbInnerString: ?*u8,
cbInnerString: u32,
pbOuterString: ?*u8,
cbOuterString: u32,
};
pub const SCHANNEL_ALG = extern struct {
dwUse: u32,
Algid: u32,
cBits: u32,
dwFlags: u32,
dwReserved: u32,
};
pub const PROV_ENUMALGS = extern struct {
aiAlgid: u32,
dwBitLen: u32,
dwNameLen: u32,
szName: [20]CHAR,
};
pub const PROV_ENUMALGS_EX = extern struct {
aiAlgid: u32,
dwDefaultLen: u32,
dwMinLen: u32,
dwMaxLen: u32,
dwProtocols: u32,
dwNameLen: u32,
szName: [20]CHAR,
dwLongNameLen: u32,
szLongName: [40]CHAR,
};
pub const PUBLICKEYSTRUC = extern struct {
bType: u8,
bVersion: u8,
reserved: u16,
aiKeyAlg: u32,
};
pub const RSAPUBKEY = extern struct {
magic: u32,
bitlen: u32,
pubexp: u32,
};
pub const PUBKEY = extern struct {
magic: u32,
bitlen: u32,
};
pub const DSSSEED = extern struct {
counter: u32,
seed: [20]u8,
};
pub const PUBKEYVER3 = extern struct {
magic: u32,
bitlenP: u32,
bitlenQ: u32,
bitlenJ: u32,
DSSSeed: DSSSEED,
};
pub const PRIVKEYVER3 = extern struct {
magic: u32,
bitlenP: u32,
bitlenQ: u32,
bitlenJ: u32,
bitlenX: u32,
DSSSeed: DSSSEED,
};
pub const KEY_TYPE_SUBTYPE = extern struct {
dwKeySpec: u32,
Type: Guid,
Subtype: Guid,
};
pub const CERT_FORTEZZA_DATA_PROP = extern struct {
SerialNumber: [8]u8,
CertIndex: i32,
CertLabel: [36]u8,
};
pub const CRYPT_RC4_KEY_STATE = extern struct {
Key: [16]u8,
SBox: [256]u8,
i: u8,
j: u8,
};
pub const CRYPT_DES_KEY_STATE = extern struct {
Key: [8]u8,
IV: [8]u8,
Feedback: [8]u8,
};
pub const CRYPT_3DES_KEY_STATE = extern struct {
Key: [24]u8,
IV: [8]u8,
Feedback: [8]u8,
};
pub const CRYPT_AES_128_KEY_STATE = extern struct {
Key: [16]u8,
IV: [16]u8,
EncryptionState: [176]u8,
DecryptionState: [176]u8,
Feedback: [16]u8,
};
pub const CRYPT_AES_256_KEY_STATE = extern struct {
Key: [32]u8,
IV: [16]u8,
EncryptionState: [240]u8,
DecryptionState: [240]u8,
Feedback: [16]u8,
};
pub const CRYPTOAPI_BLOB = extern struct {
cbData: u32,
pbData: ?*u8,
};
pub const CMS_DH_KEY_INFO = extern struct {
dwVersion: u32,
Algid: u32,
pszContentEncObjId: ?PSTR,
PubInfo: CRYPTOAPI_BLOB,
pReserved: ?*c_void,
};
pub const BCRYPT_KEY_LENGTHS_STRUCT = extern struct {
dwMinLength: u32,
dwMaxLength: u32,
dwIncrement: u32,
};
pub const BCRYPT_OID = extern struct {
cbOID: u32,
pbOID: ?*u8,
};
pub const BCRYPT_OID_LIST = extern struct {
dwOIDCount: u32,
pOIDs: ?*BCRYPT_OID,
};
pub const BCRYPT_PKCS1_PADDING_INFO = extern struct {
pszAlgId: ?[*:0]const u16,
};
pub const BCRYPT_PSS_PADDING_INFO = extern struct {
pszAlgId: ?[*:0]const u16,
cbSalt: u32,
};
pub const BCRYPT_OAEP_PADDING_INFO = extern struct {
pszAlgId: ?[*:0]const u16,
pbLabel: ?*u8,
cbLabel: u32,
};
pub const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO = extern struct {
cbSize: u32,
dwInfoVersion: u32,
pbNonce: ?*u8,
cbNonce: u32,
pbAuthData: ?*u8,
cbAuthData: u32,
pbTag: ?*u8,
cbTag: u32,
pbMacContext: ?*u8,
cbMacContext: u32,
cbAAD: u32,
cbData: u64,
dwFlags: u32,
};
pub const BCryptBuffer = extern struct {
cbBuffer: u32,
BufferType: u32,
pvBuffer: ?*c_void,
};
pub const BCryptBufferDesc = extern struct {
ulVersion: u32,
cBuffers: u32,
pBuffers: ?*BCryptBuffer,
};
pub const BCRYPT_KEY_BLOB = extern struct {
Magic: u32,
};
pub const BCRYPT_RSAKEY_BLOB = extern struct {
Magic: BCRYPT_RSAKEY_BLOB_MAGIC,
BitLength: u32,
cbPublicExp: u32,
cbModulus: u32,
cbPrime1: u32,
cbPrime2: u32,
};
pub const BCRYPT_ECCKEY_BLOB = extern struct {
dwMagic: u32,
cbKey: u32,
};
pub const SSL_ECCKEY_BLOB = extern struct {
dwCurveType: u32,
cbKey: u32,
};
pub const ECC_CURVE_TYPE_ENUM = enum(i32) {
SHORT_WEIERSTRASS_CURVE = 1,
TWISTED_EDWARDS_CURVE = 2,
MONTGOMERY_CURVE = 3,
};
pub const BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE = ECC_CURVE_TYPE_ENUM.SHORT_WEIERSTRASS_CURVE;
pub const BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE = ECC_CURVE_TYPE_ENUM.TWISTED_EDWARDS_CURVE;
pub const BCRYPT_ECC_PRIME_MONTGOMERY_CURVE = ECC_CURVE_TYPE_ENUM.MONTGOMERY_CURVE;
pub const ECC_CURVE_ALG_ID_ENUM = enum(i32) {
D = 0,
};
pub const BCRYPT_NO_CURVE_GENERATION_ALG_ID = ECC_CURVE_ALG_ID_ENUM.D;
pub const BCRYPT_ECCFULLKEY_BLOB = extern struct {
dwMagic: u32,
dwVersion: u32,
dwCurveType: ECC_CURVE_TYPE_ENUM,
dwCurveGenerationAlgId: ECC_CURVE_ALG_ID_ENUM,
cbFieldLength: u32,
cbSubgroupOrder: u32,
cbCofactor: u32,
cbSeed: u32,
};
pub const BCRYPT_DH_KEY_BLOB = extern struct {
dwMagic: BCRYPT_DH_KEY_BLOB_MAGIC,
cbKey: u32,
};
pub const BCRYPT_DH_PARAMETER_HEADER = extern struct {
cbLength: u32,
dwMagic: u32,
cbKeyLength: u32,
};
pub const BCRYPT_DSA_KEY_BLOB = extern struct {
dwMagic: BCRYPT_DSA_MAGIC,
cbKey: u32,
Count: [4]u8,
Seed: [20]u8,
q: [20]u8,
};
pub const HASHALGORITHM_ENUM = enum(i32) {
@"1" = 0,
@"256" = 1,
@"512" = 2,
};
pub const DSA_HASH_ALGORITHM_SHA1 = HASHALGORITHM_ENUM.@"1";
pub const DSA_HASH_ALGORITHM_SHA256 = HASHALGORITHM_ENUM.@"256";
pub const DSA_HASH_ALGORITHM_SHA512 = HASHALGORITHM_ENUM.@"512";
pub const DSAFIPSVERSION_ENUM = enum(i32) {
@"2" = 0,
@"3" = 1,
};
pub const DSA_FIPS186_2 = DSAFIPSVERSION_ENUM.@"2";
pub const DSA_FIPS186_3 = DSAFIPSVERSION_ENUM.@"3";
pub const BCRYPT_DSA_KEY_BLOB_V2 = extern struct {
dwMagic: BCRYPT_DSA_MAGIC,
cbKey: u32,
hashAlgorithm: HASHALGORITHM_ENUM,
standardVersion: DSAFIPSVERSION_ENUM,
cbSeedLength: u32,
cbGroupSize: u32,
Count: [4]u8,
};
pub const BCRYPT_KEY_DATA_BLOB_HEADER = extern struct {
dwMagic: u32,
dwVersion: u32,
cbKeyData: u32,
};
pub const BCRYPT_DSA_PARAMETER_HEADER = extern struct {
cbLength: u32,
dwMagic: u32,
cbKeyLength: u32,
Count: [4]u8,
Seed: [20]u8,
q: [20]u8,
};
pub const BCRYPT_DSA_PARAMETER_HEADER_V2 = extern struct {
cbLength: u32,
dwMagic: u32,
cbKeyLength: u32,
hashAlgorithm: HASHALGORITHM_ENUM,
standardVersion: DSAFIPSVERSION_ENUM,
cbSeedLength: u32,
cbGroupSize: u32,
Count: [4]u8,
};
pub const BCRYPT_ECC_CURVE_NAMES = extern struct {
dwEccCurveNames: u32,
pEccCurveNames: ?*?PWSTR,
};
pub const BCRYPT_HASH_OPERATION_TYPE = enum(i32) {
HASH_DATA = 1,
FINISH_HASH = 2,
};
pub const BCRYPT_HASH_OPERATION_HASH_DATA = BCRYPT_HASH_OPERATION_TYPE.HASH_DATA;
pub const BCRYPT_HASH_OPERATION_FINISH_HASH = BCRYPT_HASH_OPERATION_TYPE.FINISH_HASH;
pub const BCRYPT_MULTI_HASH_OPERATION = extern struct {
iHash: u32,
hashOperation: BCRYPT_HASH_OPERATION_TYPE,
pbBuffer: ?*u8,
cbBuffer: u32,
};
pub const BCRYPT_MULTI_OPERATION_TYPE = enum(i32) {
H = 1,
};
pub const BCRYPT_OPERATION_TYPE_HASH = BCRYPT_MULTI_OPERATION_TYPE.H;
pub const BCRYPT_MULTI_OBJECT_LENGTH_STRUCT = extern struct {
cbPerObject: u32,
cbPerElement: u32,
};
pub const BCRYPT_ALGORITHM_IDENTIFIER = extern struct {
pszName: ?PWSTR,
dwClass: u32,
dwFlags: u32,
};
pub const BCRYPT_PROVIDER_NAME = extern struct {
pszProviderName: ?PWSTR,
};
pub const BCRYPT_INTERFACE_VERSION = extern struct {
MajorVersion: u16,
MinorVersion: u16,
};
pub const CRYPT_INTERFACE_REG = extern struct {
dwInterface: BCRYPT_INTERFACE,
dwFlags: BCRYPT_TABLE,
cFunctions: u32,
rgpszFunctions: ?*?PWSTR,
};
pub const CRYPT_IMAGE_REG = extern struct {
pszImage: ?PWSTR,
cInterfaces: u32,
rgpInterfaces: ?*?*CRYPT_INTERFACE_REG,
};
pub const CRYPT_PROVIDER_REG = extern struct {
cAliases: u32,
rgpszAliases: ?*?PWSTR,
pUM: ?*CRYPT_IMAGE_REG,
pKM: ?*CRYPT_IMAGE_REG,
};
pub const CRYPT_PROVIDERS = extern struct {
cProviders: u32,
rgpszProviders: ?*?PWSTR,
};
pub const CRYPT_CONTEXT_CONFIG = extern struct {
dwFlags: CRYPT_CONTEXT_CONFIG_FLAGS,
dwReserved: u32,
};
pub const CRYPT_CONTEXT_FUNCTION_CONFIG = extern struct {
dwFlags: u32,
dwReserved: u32,
};
pub const CRYPT_CONTEXTS = extern struct {
cContexts: u32,
rgpszContexts: ?*?PWSTR,
};
pub const CRYPT_CONTEXT_FUNCTIONS = extern struct {
cFunctions: u32,
rgpszFunctions: ?*?PWSTR,
};
pub const CRYPT_CONTEXT_FUNCTION_PROVIDERS = extern struct {
cProviders: u32,
rgpszProviders: ?*?PWSTR,
};
pub const CRYPT_PROPERTY_REF = extern struct {
pszProperty: ?PWSTR,
cbValue: u32,
pbValue: ?*u8,
};
pub const CRYPT_IMAGE_REF = extern struct {
pszImage: ?PWSTR,
dwFlags: CRYPT_IMAGE_REF_FLAGS,
};
pub const CRYPT_PROVIDER_REF = extern struct {
dwInterface: u32,
pszFunction: ?PWSTR,
pszProvider: ?PWSTR,
cProperties: u32,
rgpProperties: ?*?*CRYPT_PROPERTY_REF,
pUM: ?*CRYPT_IMAGE_REF,
pKM: ?*CRYPT_IMAGE_REF,
};
pub const CRYPT_PROVIDER_REFS = extern struct {
cProviders: u32,
rgpProviders: ?*?*CRYPT_PROVIDER_REF,
};
pub const PFN_NCRYPT_ALLOC = fn(
cbSize: usize,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
pub const PFN_NCRYPT_FREE = fn(
pv: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const NCRYPT_ALLOC_PARA = extern struct {
cbSize: u32,
pfnAlloc: ?PFN_NCRYPT_ALLOC,
pfnFree: ?PFN_NCRYPT_FREE,
};
pub const NCRYPT_CIPHER_PADDING_INFO = extern struct {
cbSize: u32,
dwFlags: u32,
pbIV: ?*u8,
cbIV: u32,
pbOtherInfo: ?*u8,
cbOtherInfo: u32,
};
pub const NCRYPT_PLATFORM_ATTEST_PADDING_INFO = extern struct {
magic: u32,
pcrMask: u32,
};
pub const NCRYPT_KEY_ATTEST_PADDING_INFO = extern struct {
magic: u32,
pbKeyBlob: ?*u8,
cbKeyBlob: u32,
pbKeyAuth: ?*u8,
cbKeyAuth: u32,
};
pub const NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES = extern struct {
Version: u32,
Flags: u32,
cbPublicKeyBlob: u32,
};
pub const NCRYPT_VSM_KEY_ATTESTATION_STATEMENT = extern struct {
Magic: u32,
Version: u32,
cbSignature: u32,
cbReport: u32,
cbAttributes: u32,
};
pub const NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS = extern struct {
Version: u32,
TrustletId: u64,
MinSvn: u32,
FlagsMask: u32,
FlagsExpected: u32,
_bitfield: u32,
};
pub const NCRYPT_EXPORTED_ISOLATED_KEY_HEADER = extern struct {
Version: u32,
KeyUsage: u32,
_bitfield: u32,
cbAlgName: u32,
cbNonce: u32,
cbAuthTag: u32,
cbWrappingKey: u32,
cbIsolatedKey: u32,
};
pub const NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE = extern struct {
Header: NCRYPT_EXPORTED_ISOLATED_KEY_HEADER,
};
pub const __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT = extern struct {
Magic: u32,
Version: u32,
HeaderSize: u32,
cbCertifyInfo: u32,
cbSignature: u32,
cbTpmPublic: u32,
};
pub const NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT = extern struct {
Magic: u32,
Version: u32,
pcrAlg: u32,
cbSignature: u32,
cbQuote: u32,
cbPcrs: u32,
};
pub const NCryptAlgorithmName = extern struct {
pszName: ?PWSTR,
dwClass: NCRYPT_ALGORITHM_NAME_CLASS,
dwAlgOperations: NCRYPT_OPERATION,
dwFlags: u32,
};
pub const NCryptKeyName = extern struct {
pszName: ?PWSTR,
pszAlgid: ?PWSTR,
dwLegacyKeySpec: CERT_KEY_SPEC,
dwFlags: u32,
};
pub const NCryptProviderName = extern struct {
pszName: ?PWSTR,
pszComment: ?PWSTR,
};
pub const NCRYPT_UI_POLICY = extern struct {
dwVersion: u32,
dwFlags: u32,
pszCreationTitle: ?[*:0]const u16,
pszFriendlyName: ?[*:0]const u16,
pszDescription: ?[*:0]const u16,
};
pub const NCRYPT_KEY_ACCESS_POLICY_BLOB = extern struct {
dwVersion: u32,
dwPolicyFlags: u32,
cbUserSid: u32,
cbApplicationSid: u32,
};
pub const NCRYPT_SUPPORTED_LENGTHS = extern struct {
dwMinLength: u32,
dwMaxLength: u32,
dwIncrement: u32,
dwDefaultLength: u32,
};
pub const NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO = extern struct {
dwVersion: u32,
iExpiration: i32,
pabNonce: [32]u8,
pabPolicyRef: [32]u8,
pabHMAC: [32]u8,
};
pub const NCRYPT_PCP_TPM_FW_VERSION_INFO = extern struct {
major1: u16,
major2: u16,
minor1: u16,
minor2: u16,
};
pub const NCRYPT_PCP_RAW_POLICYDIGEST = extern struct {
dwVersion: u32,
cbDigest: u32,
};
pub const NCRYPT_KEY_BLOB_HEADER = extern struct {
cbSize: u32,
dwMagic: u32,
cbAlgName: u32,
cbKeyData: u32,
};
pub const NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER = extern struct {
magic: u32,
cbHeader: u32,
cbPublic: u32,
cbPrivate: u32,
cbName: u32,
};
pub const CRYPT_BIT_BLOB = extern struct {
cbData: u32,
pbData: ?*u8,
cUnusedBits: u32,
};
pub const CRYPT_ALGORITHM_IDENTIFIER = extern struct {
pszObjId: ?PSTR,
Parameters: CRYPTOAPI_BLOB,
};
pub const CRYPT_OBJID_TABLE = extern struct {
dwAlgId: u32,
pszObjId: ?[*:0]const u8,
};
pub const CRYPT_HASH_INFO = extern struct {
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Hash: CRYPTOAPI_BLOB,
};
pub const CERT_EXTENSION = extern struct {
pszObjId: ?PSTR,
fCritical: BOOL,
Value: CRYPTOAPI_BLOB,
};
pub const CRYPT_ATTRIBUTE_TYPE_VALUE = extern struct {
pszObjId: ?PSTR,
Value: CRYPTOAPI_BLOB,
};
pub const CRYPT_ATTRIBUTE = extern struct {
pszObjId: ?PSTR,
cValue: u32,
rgValue: ?*CRYPTOAPI_BLOB,
};
pub const CRYPT_ATTRIBUTES = extern struct {
cAttr: u32,
rgAttr: ?*CRYPT_ATTRIBUTE,
};
pub const CERT_RDN_ATTR = extern struct {
pszObjId: ?PSTR,
dwValueType: CERT_RDN_ATTR_VALUE_TYPE,
Value: CRYPTOAPI_BLOB,
};
pub const CERT_RDN = extern struct {
cRDNAttr: u32,
rgRDNAttr: ?*CERT_RDN_ATTR,
};
pub const CERT_NAME_INFO = extern struct {
cRDN: u32,
rgRDN: ?*CERT_RDN,
};
pub const CERT_NAME_VALUE = extern struct {
dwValueType: u32,
Value: CRYPTOAPI_BLOB,
};
pub const CERT_PUBLIC_KEY_INFO = extern struct {
Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
PublicKey: CRYPT_BIT_BLOB,
};
pub const CRYPT_ECC_PRIVATE_KEY_INFO = extern struct {
dwVersion: u32,
PrivateKey: CRYPTOAPI_BLOB,
szCurveOid: ?PSTR,
PublicKey: CRYPT_BIT_BLOB,
};
pub const CRYPT_PRIVATE_KEY_INFO = extern struct {
Version: u32,
Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
PrivateKey: CRYPTOAPI_BLOB,
pAttributes: ?*CRYPT_ATTRIBUTES,
};
pub const CRYPT_ENCRYPTED_PRIVATE_KEY_INFO = extern struct {
EncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedPrivateKey: CRYPTOAPI_BLOB,
};
pub const PCRYPT_DECRYPT_PRIVATE_KEY_FUNC = fn(
Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedPrivateKey: CRYPTOAPI_BLOB,
// TODO: what to do with BytesParamIndex 3?
pbClearTextKey: ?*u8,
pcbClearTextKey: ?*u32,
pVoidDecryptFunc: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC = fn(
pAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pClearTextPrivateKey: ?*CRYPTOAPI_BLOB,
// TODO: what to do with BytesParamIndex 3?
pbEncryptedKey: ?*u8,
pcbEncryptedKey: ?*u32,
pVoidEncryptFunc: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PCRYPT_RESOLVE_HCRYPTPROV_FUNC = fn(
pPrivateKeyInfo: ?*CRYPT_PRIVATE_KEY_INFO,
phCryptProv: ?*usize,
pVoidResolveFunc: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CRYPT_PKCS8_IMPORT_PARAMS = extern struct {
PrivateKey: CRYPTOAPI_BLOB,
pResolvehCryptProvFunc: ?PCRYPT_RESOLVE_HCRYPTPROV_FUNC,
pVoidResolveFunc: ?*c_void,
pDecryptPrivateKeyFunc: ?PCRYPT_DECRYPT_PRIVATE_KEY_FUNC,
pVoidDecryptFunc: ?*c_void,
};
pub const CRYPT_PKCS8_EXPORT_PARAMS = extern struct {
hCryptProv: usize,
dwKeySpec: u32,
pszPrivateKeyObjId: ?PSTR,
pEncryptPrivateKeyFunc: ?PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC,
pVoidEncryptFunc: ?*c_void,
};
pub const CERT_INFO = extern struct {
dwVersion: u32,
SerialNumber: CRYPTOAPI_BLOB,
SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Issuer: CRYPTOAPI_BLOB,
NotBefore: FILETIME,
NotAfter: FILETIME,
Subject: CRYPTOAPI_BLOB,
SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
IssuerUniqueId: CRYPT_BIT_BLOB,
SubjectUniqueId: CRYPT_BIT_BLOB,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CRL_ENTRY = extern struct {
SerialNumber: CRYPTOAPI_BLOB,
RevocationDate: FILETIME,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CRL_INFO = extern struct {
dwVersion: u32,
SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Issuer: CRYPTOAPI_BLOB,
ThisUpdate: FILETIME,
NextUpdate: FILETIME,
cCRLEntry: u32,
rgCRLEntry: ?*CRL_ENTRY,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CERT_OR_CRL_BLOB = extern struct {
dwChoice: u32,
cbEncoded: u32,
pbEncoded: ?*u8,
};
pub const CERT_OR_CRL_BUNDLE = extern struct {
cItem: u32,
rgItem: ?*CERT_OR_CRL_BLOB,
};
pub const CERT_REQUEST_INFO = extern struct {
dwVersion: u32,
Subject: CRYPTOAPI_BLOB,
SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
cAttribute: u32,
rgAttribute: ?*CRYPT_ATTRIBUTE,
};
pub const CERT_KEYGEN_REQUEST_INFO = extern struct {
dwVersion: u32,
SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
pwszChallengeString: ?PWSTR,
};
pub const CERT_SIGNED_CONTENT_INFO = extern struct {
ToBeSigned: CRYPTOAPI_BLOB,
SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Signature: CRYPT_BIT_BLOB,
};
pub const CTL_USAGE = extern struct {
cUsageIdentifier: u32,
rgpszUsageIdentifier: ?*?PSTR,
};
pub const CTL_ENTRY = extern struct {
SubjectIdentifier: CRYPTOAPI_BLOB,
cAttribute: u32,
rgAttribute: ?*CRYPT_ATTRIBUTE,
};
pub const CTL_INFO = extern struct {
dwVersion: u32,
SubjectUsage: CTL_USAGE,
ListIdentifier: CRYPTOAPI_BLOB,
SequenceNumber: CRYPTOAPI_BLOB,
ThisUpdate: FILETIME,
NextUpdate: FILETIME,
SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
cCTLEntry: u32,
rgCTLEntry: ?*CTL_ENTRY,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CRYPT_TIME_STAMP_REQUEST_INFO = extern struct {
pszTimeStampAlgorithm: ?PSTR,
pszContentType: ?PSTR,
Content: CRYPTOAPI_BLOB,
cAttribute: u32,
rgAttribute: ?*CRYPT_ATTRIBUTE,
};
pub const CRYPT_ENROLLMENT_NAME_VALUE_PAIR = extern struct {
pwszName: ?PWSTR,
pwszValue: ?PWSTR,
};
pub const CRYPT_CSP_PROVIDER = extern struct {
dwKeySpec: u32,
pwszProviderName: ?PWSTR,
Signature: CRYPT_BIT_BLOB,
};
pub const PFN_CRYPT_ALLOC = fn(
cbSize: usize,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
pub const PFN_CRYPT_FREE = fn(
pv: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CRYPT_ENCODE_PARA = extern struct {
cbSize: u32,
pfnAlloc: ?PFN_CRYPT_ALLOC,
pfnFree: ?PFN_CRYPT_FREE,
};
pub const CRYPT_DECODE_PARA = extern struct {
cbSize: u32,
pfnAlloc: ?PFN_CRYPT_ALLOC,
pfnFree: ?PFN_CRYPT_FREE,
};
pub const CERT_EXTENSIONS = extern struct {
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CERT_AUTHORITY_KEY_ID_INFO = extern struct {
KeyId: CRYPTOAPI_BLOB,
CertIssuer: CRYPTOAPI_BLOB,
CertSerialNumber: CRYPTOAPI_BLOB,
};
pub const CERT_PRIVATE_KEY_VALIDITY = extern struct {
NotBefore: FILETIME,
NotAfter: FILETIME,
};
pub const CERT_KEY_ATTRIBUTES_INFO = extern struct {
KeyId: CRYPTOAPI_BLOB,
IntendedKeyUsage: CRYPT_BIT_BLOB,
pPrivateKeyUsagePeriod: ?*CERT_PRIVATE_KEY_VALIDITY,
};
pub const CERT_POLICY_ID = extern struct {
cCertPolicyElementId: u32,
rgpszCertPolicyElementId: ?*?PSTR,
};
pub const CERT_KEY_USAGE_RESTRICTION_INFO = extern struct {
cCertPolicyId: u32,
rgCertPolicyId: ?*CERT_POLICY_ID,
RestrictedKeyUsage: CRYPT_BIT_BLOB,
};
pub const CERT_OTHER_NAME = extern struct {
pszObjId: ?PSTR,
Value: CRYPTOAPI_BLOB,
};
pub const CERT_ALT_NAME_ENTRY = extern struct {
dwAltNameChoice: u32,
Anonymous: extern union {
pOtherName: ?*CERT_OTHER_NAME,
pwszRfc822Name: ?PWSTR,
pwszDNSName: ?PWSTR,
DirectoryName: CRYPTOAPI_BLOB,
pwszURL: ?PWSTR,
IPAddress: CRYPTOAPI_BLOB,
pszRegisteredID: ?PSTR,
},
};
pub const CERT_ALT_NAME_INFO = extern struct {
cAltEntry: u32,
rgAltEntry: ?*CERT_ALT_NAME_ENTRY,
};
pub const CERT_BASIC_CONSTRAINTS_INFO = extern struct {
SubjectType: CRYPT_BIT_BLOB,
fPathLenConstraint: BOOL,
dwPathLenConstraint: u32,
cSubtreesConstraint: u32,
rgSubtreesConstraint: ?*CRYPTOAPI_BLOB,
};
pub const CERT_BASIC_CONSTRAINTS2_INFO = extern struct {
fCA: BOOL,
fPathLenConstraint: BOOL,
dwPathLenConstraint: u32,
};
pub const CERT_POLICY_QUALIFIER_INFO = extern struct {
pszPolicyQualifierId: ?PSTR,
Qualifier: CRYPTOAPI_BLOB,
};
pub const CERT_POLICY_INFO = extern struct {
pszPolicyIdentifier: ?PSTR,
cPolicyQualifier: u32,
rgPolicyQualifier: ?*CERT_POLICY_QUALIFIER_INFO,
};
pub const CERT_POLICIES_INFO = extern struct {
cPolicyInfo: u32,
rgPolicyInfo: ?*CERT_POLICY_INFO,
};
pub const CERT_POLICY_QUALIFIER_NOTICE_REFERENCE = extern struct {
pszOrganization: ?PSTR,
cNoticeNumbers: u32,
rgNoticeNumbers: ?*i32,
};
pub const CERT_POLICY_QUALIFIER_USER_NOTICE = extern struct {
pNoticeReference: ?*CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
pszDisplayText: ?PWSTR,
};
pub const CPS_URLS = extern struct {
pszURL: ?PWSTR,
pAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pDigest: ?*CRYPTOAPI_BLOB,
};
pub const CERT_POLICY95_QUALIFIER1 = extern struct {
pszPracticesReference: ?PWSTR,
pszNoticeIdentifier: ?PSTR,
pszNSINoticeIdentifier: ?PSTR,
cCPSURLs: u32,
rgCPSURLs: ?*CPS_URLS,
};
pub const CERT_POLICY_MAPPING = extern struct {
pszIssuerDomainPolicy: ?PSTR,
pszSubjectDomainPolicy: ?PSTR,
};
pub const CERT_POLICY_MAPPINGS_INFO = extern struct {
cPolicyMapping: u32,
rgPolicyMapping: ?*CERT_POLICY_MAPPING,
};
pub const CERT_POLICY_CONSTRAINTS_INFO = extern struct {
fRequireExplicitPolicy: BOOL,
dwRequireExplicitPolicySkipCerts: u32,
fInhibitPolicyMapping: BOOL,
dwInhibitPolicyMappingSkipCerts: u32,
};
pub const CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY = extern struct {
pszObjId: ?PSTR,
cValue: u32,
rgValue: ?*CRYPTOAPI_BLOB,
};
pub const CRYPT_CONTENT_INFO = extern struct {
pszObjId: ?PSTR,
Content: CRYPTOAPI_BLOB,
};
pub const CRYPT_SEQUENCE_OF_ANY = extern struct {
cValue: u32,
rgValue: ?*CRYPTOAPI_BLOB,
};
pub const CERT_AUTHORITY_KEY_ID2_INFO = extern struct {
KeyId: CRYPTOAPI_BLOB,
AuthorityCertIssuer: CERT_ALT_NAME_INFO,
AuthorityCertSerialNumber: CRYPTOAPI_BLOB,
};
pub const CERT_ACCESS_DESCRIPTION = extern struct {
pszAccessMethod: ?PSTR,
AccessLocation: CERT_ALT_NAME_ENTRY,
};
pub const CERT_AUTHORITY_INFO_ACCESS = extern struct {
cAccDescr: u32,
rgAccDescr: ?*CERT_ACCESS_DESCRIPTION,
};
pub const CRL_DIST_POINT_NAME = extern struct {
dwDistPointNameChoice: u32,
Anonymous: extern union {
FullName: CERT_ALT_NAME_INFO,
},
};
pub const CRL_DIST_POINT = extern struct {
DistPointName: CRL_DIST_POINT_NAME,
ReasonFlags: CRYPT_BIT_BLOB,
CRLIssuer: CERT_ALT_NAME_INFO,
};
pub const CRL_DIST_POINTS_INFO = extern struct {
cDistPoint: u32,
rgDistPoint: ?*CRL_DIST_POINT,
};
pub const CROSS_CERT_DIST_POINTS_INFO = extern struct {
dwSyncDeltaTime: u32,
cDistPoint: u32,
rgDistPoint: ?*CERT_ALT_NAME_INFO,
};
pub const CERT_PAIR = extern struct {
Forward: CRYPTOAPI_BLOB,
Reverse: CRYPTOAPI_BLOB,
};
pub const CRL_ISSUING_DIST_POINT = extern struct {
DistPointName: CRL_DIST_POINT_NAME,
fOnlyContainsUserCerts: BOOL,
fOnlyContainsCACerts: BOOL,
OnlySomeReasonFlags: CRYPT_BIT_BLOB,
fIndirectCRL: BOOL,
};
pub const CERT_GENERAL_SUBTREE = extern struct {
Base: CERT_ALT_NAME_ENTRY,
dwMinimum: u32,
fMaximum: BOOL,
dwMaximum: u32,
};
pub const CERT_NAME_CONSTRAINTS_INFO = extern struct {
cPermittedSubtree: u32,
rgPermittedSubtree: ?*CERT_GENERAL_SUBTREE,
cExcludedSubtree: u32,
rgExcludedSubtree: ?*CERT_GENERAL_SUBTREE,
};
pub const CERT_DSS_PARAMETERS = extern struct {
p: CRYPTOAPI_BLOB,
q: CRYPTOAPI_BLOB,
g: CRYPTOAPI_BLOB,
};
pub const CERT_DH_PARAMETERS = extern struct {
p: CRYPTOAPI_BLOB,
g: CRYPTOAPI_BLOB,
};
pub const CERT_ECC_SIGNATURE = extern struct {
r: CRYPTOAPI_BLOB,
s: CRYPTOAPI_BLOB,
};
pub const CERT_X942_DH_VALIDATION_PARAMS = extern struct {
seed: CRYPT_BIT_BLOB,
pgenCounter: u32,
};
pub const CERT_X942_DH_PARAMETERS = extern struct {
p: CRYPTOAPI_BLOB,
g: CRYPTOAPI_BLOB,
q: CRYPTOAPI_BLOB,
j: CRYPTOAPI_BLOB,
pValidationParams: ?*CERT_X942_DH_VALIDATION_PARAMS,
};
pub const CRYPT_X942_OTHER_INFO = extern struct {
pszContentEncryptionObjId: ?PSTR,
rgbCounter: [4]u8,
rgbKeyLength: [4]u8,
PubInfo: CRYPTOAPI_BLOB,
};
pub const CRYPT_ECC_CMS_SHARED_INFO = extern struct {
Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
EntityUInfo: CRYPTOAPI_BLOB,
rgbSuppPubInfo: [4]u8,
};
pub const CRYPT_RC2_CBC_PARAMETERS = extern struct {
dwVersion: u32,
fIV: BOOL,
rgbIV: [8]u8,
};
pub const CRYPT_SMIME_CAPABILITY = extern struct {
pszObjId: ?PSTR,
Parameters: CRYPTOAPI_BLOB,
};
pub const CRYPT_SMIME_CAPABILITIES = extern struct {
cCapability: u32,
rgCapability: ?*CRYPT_SMIME_CAPABILITY,
};
pub const CERT_QC_STATEMENT = extern struct {
pszStatementId: ?PSTR,
StatementInfo: CRYPTOAPI_BLOB,
};
pub const CERT_QC_STATEMENTS_EXT_INFO = extern struct {
cStatement: u32,
rgStatement: ?*CERT_QC_STATEMENT,
};
pub const CRYPT_MASK_GEN_ALGORITHM = extern struct {
pszObjId: ?PSTR,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
};
pub const CRYPT_RSA_SSA_PSS_PARAMETERS = extern struct {
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
dwSaltLength: u32,
dwTrailerField: u32,
};
pub const CRYPT_PSOURCE_ALGORITHM = extern struct {
pszObjId: ?PSTR,
EncodingParameters: CRYPTOAPI_BLOB,
};
pub const CRYPT_RSAES_OAEP_PARAMETERS = extern struct {
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
PSourceAlgorithm: CRYPT_PSOURCE_ALGORITHM,
};
pub const CMC_TAGGED_ATTRIBUTE = extern struct {
dwBodyPartID: u32,
Attribute: CRYPT_ATTRIBUTE,
};
pub const CMC_TAGGED_CERT_REQUEST = extern struct {
dwBodyPartID: u32,
SignedCertRequest: CRYPTOAPI_BLOB,
};
pub const CMC_TAGGED_REQUEST = extern struct {
dwTaggedRequestChoice: u32,
Anonymous: extern union {
pTaggedCertRequest: ?*CMC_TAGGED_CERT_REQUEST,
},
};
pub const CMC_TAGGED_CONTENT_INFO = extern struct {
dwBodyPartID: u32,
EncodedContentInfo: CRYPTOAPI_BLOB,
};
pub const CMC_TAGGED_OTHER_MSG = extern struct {
dwBodyPartID: u32,
pszObjId: ?PSTR,
Value: CRYPTOAPI_BLOB,
};
pub const CMC_DATA_INFO = extern struct {
cTaggedAttribute: u32,
rgTaggedAttribute: ?*CMC_TAGGED_ATTRIBUTE,
cTaggedRequest: u32,
rgTaggedRequest: ?*CMC_TAGGED_REQUEST,
cTaggedContentInfo: u32,
rgTaggedContentInfo: ?*CMC_TAGGED_CONTENT_INFO,
cTaggedOtherMsg: u32,
rgTaggedOtherMsg: ?*CMC_TAGGED_OTHER_MSG,
};
pub const CMC_RESPONSE_INFO = extern struct {
cTaggedAttribute: u32,
rgTaggedAttribute: ?*CMC_TAGGED_ATTRIBUTE,
cTaggedContentInfo: u32,
rgTaggedContentInfo: ?*CMC_TAGGED_CONTENT_INFO,
cTaggedOtherMsg: u32,
rgTaggedOtherMsg: ?*CMC_TAGGED_OTHER_MSG,
};
pub const CMC_PEND_INFO = extern struct {
PendToken: CRYPTOAPI_BLOB,
PendTime: FILETIME,
};
pub const CMC_STATUS_INFO = extern struct {
dwStatus: u32,
cBodyList: u32,
rgdwBodyList: ?*u32,
pwszStatusString: ?PWSTR,
dwOtherInfoChoice: u32,
Anonymous: extern union {
dwFailInfo: u32,
pPendInfo: ?*CMC_PEND_INFO,
},
};
pub const CMC_ADD_EXTENSIONS_INFO = extern struct {
dwCmcDataReference: u32,
cCertReference: u32,
rgdwCertReference: ?*u32,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CMC_ADD_ATTRIBUTES_INFO = extern struct {
dwCmcDataReference: u32,
cCertReference: u32,
rgdwCertReference: ?*u32,
cAttribute: u32,
rgAttribute: ?*CRYPT_ATTRIBUTE,
};
pub const CERT_TEMPLATE_EXT = extern struct {
pszObjId: ?PSTR,
dwMajorVersion: u32,
fMinorVersion: BOOL,
dwMinorVersion: u32,
};
pub const CERT_HASHED_URL = extern struct {
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Hash: CRYPTOAPI_BLOB,
pwszUrl: ?PWSTR,
};
pub const CERT_LOGOTYPE_DETAILS = extern struct {
pwszMimeType: ?PWSTR,
cHashedUrl: u32,
rgHashedUrl: ?*CERT_HASHED_URL,
};
pub const CERT_LOGOTYPE_REFERENCE = extern struct {
cHashedUrl: u32,
rgHashedUrl: ?*CERT_HASHED_URL,
};
pub const CERT_LOGOTYPE_IMAGE_INFO = extern struct {
dwLogotypeImageInfoChoice: CERT_LOGOTYPE_IMAGE_INFO_TYPE,
dwFileSize: u32,
dwXSize: u32,
dwYSize: u32,
dwLogotypeImageResolutionChoice: CERT_LOGOTYPE_CHOICE,
Anonymous: extern union {
dwNumBits: u32,
dwTableSize: u32,
},
pwszLanguage: ?PWSTR,
};
pub const CERT_LOGOTYPE_IMAGE = extern struct {
LogotypeDetails: CERT_LOGOTYPE_DETAILS,
pLogotypeImageInfo: ?*CERT_LOGOTYPE_IMAGE_INFO,
};
pub const CERT_LOGOTYPE_AUDIO_INFO = extern struct {
dwFileSize: u32,
dwPlayTime: u32,
dwChannels: u32,
dwSampleRate: u32,
pwszLanguage: ?PWSTR,
};
pub const CERT_LOGOTYPE_AUDIO = extern struct {
LogotypeDetails: CERT_LOGOTYPE_DETAILS,
pLogotypeAudioInfo: ?*CERT_LOGOTYPE_AUDIO_INFO,
};
pub const CERT_LOGOTYPE_DATA = extern struct {
cLogotypeImage: u32,
rgLogotypeImage: ?*CERT_LOGOTYPE_IMAGE,
cLogotypeAudio: u32,
rgLogotypeAudio: ?*CERT_LOGOTYPE_AUDIO,
};
pub const CERT_LOGOTYPE_INFO = extern struct {
dwLogotypeInfoChoice: CERT_LOGOTYPE_OPTION,
Anonymous: extern union {
pLogotypeDirectInfo: ?*CERT_LOGOTYPE_DATA,
pLogotypeIndirectInfo: ?*CERT_LOGOTYPE_REFERENCE,
},
};
pub const CERT_OTHER_LOGOTYPE_INFO = extern struct {
pszObjId: ?PSTR,
LogotypeInfo: CERT_LOGOTYPE_INFO,
};
pub const CERT_LOGOTYPE_EXT_INFO = extern struct {
cCommunityLogo: u32,
rgCommunityLogo: ?*CERT_LOGOTYPE_INFO,
pIssuerLogo: ?*CERT_LOGOTYPE_INFO,
pSubjectLogo: ?*CERT_LOGOTYPE_INFO,
cOtherLogo: u32,
rgOtherLogo: ?*CERT_OTHER_LOGOTYPE_INFO,
};
pub const CERT_BIOMETRIC_DATA = extern struct {
dwTypeOfBiometricDataChoice: CERT_BIOMETRIC_DATA_TYPE,
Anonymous: extern union {
dwPredefined: u32,
pszObjId: ?PSTR,
},
HashedUrl: CERT_HASHED_URL,
};
pub const CERT_BIOMETRIC_EXT_INFO = extern struct {
cBiometricData: u32,
rgBiometricData: ?*CERT_BIOMETRIC_DATA,
};
pub const OCSP_SIGNATURE_INFO = extern struct {
SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
Signature: CRYPT_BIT_BLOB,
cCertEncoded: u32,
rgCertEncoded: ?*CRYPTOAPI_BLOB,
};
pub const OCSP_SIGNED_REQUEST_INFO = extern struct {
ToBeSigned: CRYPTOAPI_BLOB,
pOptionalSignatureInfo: ?*OCSP_SIGNATURE_INFO,
};
pub const OCSP_CERT_ID = extern struct {
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
IssuerNameHash: CRYPTOAPI_BLOB,
IssuerKeyHash: CRYPTOAPI_BLOB,
SerialNumber: CRYPTOAPI_BLOB,
};
pub const OCSP_REQUEST_ENTRY = extern struct {
CertId: OCSP_CERT_ID,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const OCSP_REQUEST_INFO = extern struct {
dwVersion: u32,
pRequestorName: ?*CERT_ALT_NAME_ENTRY,
cRequestEntry: u32,
rgRequestEntry: ?*OCSP_REQUEST_ENTRY,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const OCSP_RESPONSE_INFO = extern struct {
dwStatus: u32,
pszObjId: ?PSTR,
Value: CRYPTOAPI_BLOB,
};
pub const OCSP_BASIC_SIGNED_RESPONSE_INFO = extern struct {
ToBeSigned: CRYPTOAPI_BLOB,
SignatureInfo: OCSP_SIGNATURE_INFO,
};
pub const OCSP_BASIC_REVOKED_INFO = extern struct {
RevocationDate: FILETIME,
dwCrlReasonCode: CERT_REVOCATION_STATUS_REASON,
};
pub const OCSP_BASIC_RESPONSE_ENTRY = extern struct {
CertId: OCSP_CERT_ID,
dwCertStatus: u32,
Anonymous: extern union {
pRevokedInfo: ?*OCSP_BASIC_REVOKED_INFO,
},
ThisUpdate: FILETIME,
NextUpdate: FILETIME,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const OCSP_BASIC_RESPONSE_INFO = extern struct {
dwVersion: u32,
dwResponderIdChoice: u32,
Anonymous: extern union {
ByNameResponderId: CRYPTOAPI_BLOB,
ByKeyResponderId: CRYPTOAPI_BLOB,
},
ProducedAt: FILETIME,
cResponseEntry: u32,
rgResponseEntry: ?*OCSP_BASIC_RESPONSE_ENTRY,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CERT_SUPPORTED_ALGORITHM_INFO = extern struct {
Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
IntendedKeyUsage: CRYPT_BIT_BLOB,
IntendedCertPolicies: CERT_POLICIES_INFO,
};
pub const CERT_TPM_SPECIFICATION_INFO = extern struct {
pwszFamily: ?PWSTR,
dwLevel: u32,
dwRevision: u32,
};
pub const CRYPT_OID_FUNC_ENTRY = extern struct {
pszOID: ?[*:0]const u8,
pvFuncAddr: ?*c_void,
};
pub const PFN_CRYPT_ENUM_OID_FUNC = fn(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
cValue: u32,
rgdwValueType: [*]const u32,
rgpwszValueName: [*]const ?[*:0]const u16,
rgpbValueData: [*]const ?*const u8,
rgcbValueData: [*]const u32,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CRYPT_OID_INFO = extern struct {
cbSize: u32,
pszOID: ?[*:0]const u8,
pwszName: ?[*:0]const u16,
dwGroupId: u32,
Anonymous: extern union {
dwValue: u32,
Algid: u32,
dwLength: u32,
},
ExtraInfo: CRYPTOAPI_BLOB,
};
pub const PFN_CRYPT_ENUM_OID_INFO = fn(
pInfo: ?*CRYPT_OID_INFO,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_STRONG_SIGN_SERIALIZED_INFO = extern struct {
dwFlags: CERT_STRONG_SIGN_FLAGS,
pwszCNGSignHashAlgids: ?PWSTR,
pwszCNGPubKeyMinBitLengths: ?PWSTR,
};
pub const CERT_STRONG_SIGN_PARA = extern struct {
cbSize: u32,
dwInfoChoice: u32,
Anonymous: extern union {
pvInfo: ?*c_void,
pSerializedInfo: ?*CERT_STRONG_SIGN_SERIALIZED_INFO,
pszOID: ?PSTR,
},
};
pub const CERT_ISSUER_SERIAL_NUMBER = extern struct {
Issuer: CRYPTOAPI_BLOB,
SerialNumber: CRYPTOAPI_BLOB,
};
pub const CERT_ID = extern struct {
dwIdChoice: CERT_ID_OPTION,
Anonymous: extern union {
IssuerSerialNumber: CERT_ISSUER_SERIAL_NUMBER,
KeyId: CRYPTOAPI_BLOB,
HashId: CRYPTOAPI_BLOB,
},
};
pub const CMSG_SIGNER_ENCODE_INFO = extern struct {
cbSize: u32,
pCertInfo: ?*CERT_INFO,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: u32,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*c_void,
cAuthAttr: u32,
rgAuthAttr: ?*CRYPT_ATTRIBUTE,
cUnauthAttr: u32,
rgUnauthAttr: ?*CRYPT_ATTRIBUTE,
};
pub const CMSG_SIGNED_ENCODE_INFO = extern struct {
cbSize: u32,
cSigners: u32,
rgSigners: ?*CMSG_SIGNER_ENCODE_INFO,
cCertEncoded: u32,
rgCertEncoded: ?*CRYPTOAPI_BLOB,
cCrlEncoded: u32,
rgCrlEncoded: ?*CRYPTOAPI_BLOB,
};
pub const CMSG_ENVELOPED_ENCODE_INFO = extern struct {
cbSize: u32,
hCryptProv: usize,
ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvEncryptionAuxInfo: ?*c_void,
cRecipients: u32,
rgpRecipients: ?*?*CERT_INFO,
};
pub const CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = extern struct {
cbSize: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvKeyEncryptionAuxInfo: ?*c_void,
hCryptProv: usize,
RecipientPublicKey: CRYPT_BIT_BLOB,
RecipientId: CERT_ID,
};
pub const CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = extern struct {
cbSize: u32,
RecipientPublicKey: CRYPT_BIT_BLOB,
RecipientId: CERT_ID,
Date: FILETIME,
pOtherAttr: ?*CRYPT_ATTRIBUTE_TYPE_VALUE,
};
pub const CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = extern struct {
cbSize: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvKeyEncryptionAuxInfo: ?*c_void,
KeyWrapAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvKeyWrapAuxInfo: ?*c_void,
hCryptProv: usize,
dwKeySpec: u32,
dwKeyChoice: CMSG_KEY_AGREE_OPTION,
Anonymous: extern union {
pEphemeralAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pSenderId: ?*CERT_ID,
},
UserKeyingMaterial: CRYPTOAPI_BLOB,
cRecipientEncryptedKeys: u32,
rgpRecipientEncryptedKeys: ?*?*CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO,
};
pub const CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = extern struct {
cbSize: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvKeyEncryptionAuxInfo: ?*c_void,
hCryptProv: usize,
dwKeyChoice: u32,
Anonymous: extern union {
hKeyEncryptionKey: usize,
pvKeyEncryptionKey: ?*c_void,
},
KeyId: CRYPTOAPI_BLOB,
Date: FILETIME,
pOtherAttr: ?*CRYPT_ATTRIBUTE_TYPE_VALUE,
};
pub const CMSG_RECIPIENT_ENCODE_INFO = extern struct {
dwRecipientChoice: u32,
Anonymous: extern union {
pKeyTrans: ?*CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO,
pKeyAgree: ?*CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO,
pMailList: ?*CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO,
},
};
pub const CMSG_RC2_AUX_INFO = extern struct {
cbSize: u32,
dwBitLen: u32,
};
pub const CMSG_SP3_COMPATIBLE_AUX_INFO = extern struct {
cbSize: u32,
dwFlags: u32,
};
pub const CMSG_RC4_AUX_INFO = extern struct {
cbSize: u32,
dwBitLen: u32,
};
pub const CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO = extern struct {
cbSize: u32,
SignedInfo: CMSG_SIGNED_ENCODE_INFO,
EnvelopedInfo: CMSG_ENVELOPED_ENCODE_INFO,
};
pub const CMSG_HASHED_ENCODE_INFO = extern struct {
cbSize: u32,
hCryptProv: usize,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*c_void,
};
pub const CMSG_ENCRYPTED_ENCODE_INFO = extern struct {
cbSize: u32,
ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvEncryptionAuxInfo: ?*c_void,
};
pub const PFN_CMSG_STREAM_OUTPUT = fn(
pvArg: ?*const c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*u8,
cbData: u32,
fFinal: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_STREAM_INFO = extern struct {
cbContent: u32,
pfnStreamOutput: ?PFN_CMSG_STREAM_OUTPUT,
pvArg: ?*c_void,
};
pub const CMSG_SIGNER_INFO = extern struct {
dwVersion: u32,
Issuer: CRYPTOAPI_BLOB,
SerialNumber: CRYPTOAPI_BLOB,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedHash: CRYPTOAPI_BLOB,
AuthAttrs: CRYPT_ATTRIBUTES,
UnauthAttrs: CRYPT_ATTRIBUTES,
};
pub const CMSG_CMS_SIGNER_INFO = extern struct {
dwVersion: u32,
SignerId: CERT_ID,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedHash: CRYPTOAPI_BLOB,
AuthAttrs: CRYPT_ATTRIBUTES,
UnauthAttrs: CRYPT_ATTRIBUTES,
};
pub const CMSG_KEY_TRANS_RECIPIENT_INFO = extern struct {
dwVersion: u32,
RecipientId: CERT_ID,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedKey: CRYPTOAPI_BLOB,
};
pub const CMSG_RECIPIENT_ENCRYPTED_KEY_INFO = extern struct {
RecipientId: CERT_ID,
EncryptedKey: CRYPTOAPI_BLOB,
Date: FILETIME,
pOtherAttr: ?*CRYPT_ATTRIBUTE_TYPE_VALUE,
};
pub const CMSG_KEY_AGREE_RECIPIENT_INFO = extern struct {
dwVersion: u32,
dwOriginatorChoice: CMSG_KEY_AGREE_ORIGINATOR,
Anonymous: extern union {
OriginatorCertId: CERT_ID,
OriginatorPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
},
UserKeyingMaterial: CRYPTOAPI_BLOB,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
cRecipientEncryptedKeys: u32,
rgpRecipientEncryptedKeys: ?*?*CMSG_RECIPIENT_ENCRYPTED_KEY_INFO,
};
pub const CMSG_MAIL_LIST_RECIPIENT_INFO = extern struct {
dwVersion: u32,
KeyId: CRYPTOAPI_BLOB,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedKey: CRYPTOAPI_BLOB,
Date: FILETIME,
pOtherAttr: ?*CRYPT_ATTRIBUTE_TYPE_VALUE,
};
pub const CMSG_CMS_RECIPIENT_INFO = extern struct {
dwRecipientChoice: u32,
Anonymous: extern union {
pKeyTrans: ?*CMSG_KEY_TRANS_RECIPIENT_INFO,
pKeyAgree: ?*CMSG_KEY_AGREE_RECIPIENT_INFO,
pMailList: ?*CMSG_MAIL_LIST_RECIPIENT_INFO,
},
};
pub const CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA = extern struct {
cbSize: u32,
hCryptProv: usize,
dwSignerIndex: u32,
dwSignerType: u32,
pvSigner: ?*c_void,
};
pub const CMSG_CTRL_DECRYPT_PARA = extern struct {
cbSize: u32,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: u32,
dwRecipientIndex: u32,
};
pub const CMSG_CTRL_KEY_TRANS_DECRYPT_PARA = extern struct {
cbSize: u32,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: u32,
pKeyTrans: ?*CMSG_KEY_TRANS_RECIPIENT_INFO,
dwRecipientIndex: u32,
};
pub const CMSG_CTRL_KEY_AGREE_DECRYPT_PARA = extern struct {
cbSize: u32,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: u32,
pKeyAgree: ?*CMSG_KEY_AGREE_RECIPIENT_INFO,
dwRecipientIndex: u32,
dwRecipientEncryptedKeyIndex: u32,
OriginatorPublicKey: CRYPT_BIT_BLOB,
};
pub const CMSG_CTRL_MAIL_LIST_DECRYPT_PARA = extern struct {
cbSize: u32,
hCryptProv: usize,
pMailList: ?*CMSG_MAIL_LIST_RECIPIENT_INFO,
dwRecipientIndex: u32,
dwKeyChoice: u32,
Anonymous: extern union {
hKeyEncryptionKey: usize,
pvKeyEncryptionKey: ?*c_void,
},
};
pub const CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA = extern struct {
cbSize: u32,
dwSignerIndex: u32,
blob: CRYPTOAPI_BLOB,
};
pub const CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA = extern struct {
cbSize: u32,
dwSignerIndex: u32,
dwUnauthAttrIndex: u32,
};
pub const PFN_CMSG_ALLOC = fn(
cb: usize,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
pub const PFN_CMSG_FREE = fn(
pv: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const PFN_CMSG_GEN_ENCRYPT_KEY = fn(
phCryptProv: ?*usize,
paiEncrypt: ?*CRYPT_ALGORITHM_IDENTIFIER,
pvEncryptAuxInfo: ?*c_void,
pPublicKeyInfo: ?*CERT_PUBLIC_KEY_INFO,
pfnAlloc: ?PFN_CMSG_ALLOC,
phEncryptKey: ?*usize,
ppbEncryptParameters: ?*?*u8,
pcbEncryptParameters: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_EXPORT_ENCRYPT_KEY = fn(
hCryptProv: usize,
hEncryptKey: usize,
pPublicKeyInfo: ?*CERT_PUBLIC_KEY_INFO,
// TODO: what to do with BytesParamIndex 4?
pbData: ?*u8,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_IMPORT_ENCRYPT_KEY = fn(
hCryptProv: usize,
dwKeySpec: u32,
paiEncrypt: ?*CRYPT_ALGORITHM_IDENTIFIER,
paiPubKey: ?*CRYPT_ALGORITHM_IDENTIFIER,
// TODO: what to do with BytesParamIndex 5?
pbEncodedKey: ?*u8,
cbEncodedKey: u32,
phEncryptKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_CONTENT_ENCRYPT_INFO = extern struct {
cbSize: u32,
hCryptProv: usize,
ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvEncryptionAuxInfo: ?*c_void,
cRecipients: u32,
rgCmsRecipients: ?*CMSG_RECIPIENT_ENCODE_INFO,
pfnAlloc: ?PFN_CMSG_ALLOC,
pfnFree: ?PFN_CMSG_FREE,
dwEncryptFlags: u32,
Anonymous: extern union {
hContentEncryptKey: usize,
hCNGContentEncryptKey: BCRYPT_KEY_HANDLE,
},
dwFlags: u32,
fCNG: BOOL,
pbCNGContentEncryptKeyObject: ?*u8,
pbContentEncryptKey: ?*u8,
cbContentEncryptKey: u32,
};
pub const PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY = fn(
pContentEncryptInfo: ?*CMSG_CONTENT_ENCRYPT_INFO,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_KEY_TRANS_ENCRYPT_INFO = extern struct {
cbSize: u32,
dwRecipientIndex: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedKey: CRYPTOAPI_BLOB,
dwFlags: u32,
};
pub const PFN_CMSG_EXPORT_KEY_TRANS = fn(
pContentEncryptInfo: ?*CMSG_CONTENT_ENCRYPT_INFO,
pKeyTransEncodeInfo: ?*CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO,
pKeyTransEncryptInfo: ?*CMSG_KEY_TRANS_ENCRYPT_INFO,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_KEY_AGREE_KEY_ENCRYPT_INFO = extern struct {
cbSize: u32,
EncryptedKey: CRYPTOAPI_BLOB,
};
pub const CMSG_KEY_AGREE_ENCRYPT_INFO = extern struct {
cbSize: u32,
dwRecipientIndex: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
UserKeyingMaterial: CRYPTOAPI_BLOB,
dwOriginatorChoice: CMSG_KEY_AGREE_ORIGINATOR,
Anonymous: extern union {
OriginatorCertId: CERT_ID,
OriginatorPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
},
cKeyAgreeKeyEncryptInfo: u32,
rgpKeyAgreeKeyEncryptInfo: ?*?*CMSG_KEY_AGREE_KEY_ENCRYPT_INFO,
dwFlags: u32,
};
pub const PFN_CMSG_EXPORT_KEY_AGREE = fn(
pContentEncryptInfo: ?*CMSG_CONTENT_ENCRYPT_INFO,
pKeyAgreeEncodeInfo: ?*CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO,
pKeyAgreeEncryptInfo: ?*CMSG_KEY_AGREE_ENCRYPT_INFO,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_MAIL_LIST_ENCRYPT_INFO = extern struct {
cbSize: u32,
dwRecipientIndex: u32,
KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
EncryptedKey: CRYPTOAPI_BLOB,
dwFlags: u32,
};
pub const PFN_CMSG_EXPORT_MAIL_LIST = fn(
pContentEncryptInfo: ?*CMSG_CONTENT_ENCRYPT_INFO,
pMailListEncodeInfo: ?*CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO,
pMailListEncryptInfo: ?*CMSG_MAIL_LIST_ENCRYPT_INFO,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_IMPORT_KEY_TRANS = fn(
pContentEncryptionAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pKeyTransDecryptPara: ?*CMSG_CTRL_KEY_TRANS_DECRYPT_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
phContentEncryptKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_IMPORT_KEY_AGREE = fn(
pContentEncryptionAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pKeyAgreeDecryptPara: ?*CMSG_CTRL_KEY_AGREE_DECRYPT_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
phContentEncryptKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_IMPORT_MAIL_LIST = fn(
pContentEncryptionAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pMailListDecryptPara: ?*CMSG_CTRL_MAIL_LIST_DECRYPT_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
phContentEncryptKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CMSG_CNG_CONTENT_DECRYPT_INFO = extern struct {
cbSize: u32,
ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pfnAlloc: ?PFN_CMSG_ALLOC,
pfnFree: ?PFN_CMSG_FREE,
hNCryptKey: usize,
pbContentEncryptKey: ?*u8,
cbContentEncryptKey: u32,
hCNGContentEncryptKey: BCRYPT_KEY_HANDLE,
pbCNGContentEncryptKeyObject: ?*u8,
};
pub const PFN_CMSG_CNG_IMPORT_KEY_TRANS = fn(
pCNGContentDecryptInfo: ?*CMSG_CNG_CONTENT_DECRYPT_INFO,
pKeyTransDecryptPara: ?*CMSG_CTRL_KEY_TRANS_DECRYPT_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_CNG_IMPORT_KEY_AGREE = fn(
pCNGContentDecryptInfo: ?*CMSG_CNG_CONTENT_DECRYPT_INFO,
pKeyAgreeDecryptPara: ?*CMSG_CTRL_KEY_AGREE_DECRYPT_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY = fn(
pCNGContentDecryptInfo: ?*CMSG_CNG_CONTENT_DECRYPT_INFO,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_CONTEXT = extern struct {
dwCertEncodingType: u32,
pbCertEncoded: ?*u8,
cbCertEncoded: u32,
pCertInfo: ?*CERT_INFO,
hCertStore: ?*c_void,
};
pub const CRL_CONTEXT = extern struct {
dwCertEncodingType: u32,
pbCrlEncoded: ?*u8,
cbCrlEncoded: u32,
pCrlInfo: ?*CRL_INFO,
hCertStore: ?*c_void,
};
pub const CTL_CONTEXT = extern struct {
dwMsgAndCertEncodingType: u32,
pbCtlEncoded: ?*u8,
cbCtlEncoded: u32,
pCtlInfo: ?*CTL_INFO,
hCertStore: ?*c_void,
hCryptMsg: ?*c_void,
pbCtlContent: ?*u8,
cbCtlContent: u32,
};
pub const CertKeyType = enum(u32) {
Other = 0,
VirtualSmartCard = 1,
PhysicalSmartCard = 2,
Passport = 3,
PassportRemote = 4,
PassportSmartCard = 5,
Hardware = 6,
Software = 7,
SelfSigned = 8,
};
pub const KeyTypeOther = CertKeyType.Other;
pub const KeyTypeVirtualSmartCard = CertKeyType.VirtualSmartCard;
pub const KeyTypePhysicalSmartCard = CertKeyType.PhysicalSmartCard;
pub const KeyTypePassport = CertKeyType.Passport;
pub const KeyTypePassportRemote = CertKeyType.PassportRemote;
pub const KeyTypePassportSmartCard = CertKeyType.PassportSmartCard;
pub const KeyTypeHardware = CertKeyType.Hardware;
pub const KeyTypeSoftware = CertKeyType.Software;
pub const KeyTypeSelfSigned = CertKeyType.SelfSigned;
pub const CRYPT_KEY_PROV_PARAM = extern struct {
dwParam: u32,
pbData: ?*u8,
cbData: u32,
dwFlags: u32,
};
pub const CRYPT_KEY_PROV_INFO = extern struct {
pwszContainerName: ?PWSTR,
pwszProvName: ?PWSTR,
dwProvType: u32,
dwFlags: CRYPT_KEY_FLAGS,
cProvParam: u32,
rgProvParam: ?*CRYPT_KEY_PROV_PARAM,
dwKeySpec: u32,
};
pub const CERT_KEY_CONTEXT = extern struct {
cbSize: u32,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: u32,
};
pub const ROOT_INFO_LUID = extern struct {
LowPart: u32,
HighPart: i32,
};
pub const CRYPT_SMART_CARD_ROOT_INFO = extern struct {
rgbCardID: [16]u8,
luid: ROOT_INFO_LUID,
};
pub const CERT_SYSTEM_STORE_RELOCATE_PARA = extern struct {
Anonymous1: extern union {
hKeyBase: ?HKEY,
pvBase: ?*c_void,
},
Anonymous2: extern union {
pvSystemStore: ?*c_void,
pszSystemStore: ?[*:0]const u8,
pwszSystemStore: ?[*:0]const u16,
},
};
pub const CERT_REGISTRY_STORE_CLIENT_GPT_PARA = extern struct {
hKeyBase: ?HKEY,
pwszRegPath: ?PWSTR,
};
pub const CERT_REGISTRY_STORE_ROAMING_PARA = extern struct {
hKey: ?HKEY,
pwszStoreDirectory: ?PWSTR,
};
pub const CERT_LDAP_STORE_OPENED_PARA = extern struct {
pvLdapSessionHandle: ?*c_void,
pwszLdapUrl: ?[*:0]const u16,
};
pub const CERT_STORE_PROV_INFO = extern struct {
cbSize: u32,
cStoreProvFunc: u32,
rgpvStoreProvFunc: ?*?*c_void,
hStoreProv: ?*c_void,
dwStoreProvFlags: CERT_STORE_PROV_FLAGS,
hStoreProvFuncAddr2: ?*c_void,
};
pub const PFN_CERT_DLL_OPEN_STORE_PROV_FUNC = fn(
lpszStoreProvider: ?[*:0]const u8,
dwEncodingType: CERT_QUERY_ENCODING_TYPE,
hCryptProv: usize,
dwFlags: CERT_OPEN_STORE_FLAGS,
pvPara: ?*const c_void,
hCertStore: ?*c_void,
pStoreProvInfo: ?*CERT_STORE_PROV_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_CLOSE = fn(
hStoreProv: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) void;
pub const PFN_CERT_STORE_PROV_READ_CERT = fn(
hStoreProv: ?*c_void,
pStoreCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
ppProvCertContext: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_WRITE_CERT = fn(
hStoreProv: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_DELETE_CERT = fn(
hStoreProv: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_SET_CERT_PROPERTY = fn(
hStoreProv: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_READ_CRL = fn(
hStoreProv: ?*c_void,
pStoreCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
ppProvCrlContext: ?*?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_WRITE_CRL = fn(
hStoreProv: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_DELETE_CRL = fn(
hStoreProv: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_SET_CRL_PROPERTY = fn(
hStoreProv: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_READ_CTL = fn(
hStoreProv: ?*c_void,
pStoreCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
ppProvCtlContext: ?*?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_WRITE_CTL = fn(
hStoreProv: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_DELETE_CTL = fn(
hStoreProv: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_SET_CTL_PROPERTY = fn(
hStoreProv: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_CONTROL = fn(
hStoreProv: ?*c_void,
dwFlags: u32,
dwCtrlType: u32,
pvCtrlPara: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_STORE_PROV_FIND_INFO = extern struct {
cbSize: u32,
dwMsgAndCertEncodingType: u32,
dwFindFlags: u32,
dwFindType: u32,
pvFindPara: ?*const c_void,
};
pub const PFN_CERT_STORE_PROV_FIND_CERT = fn(
hStoreProv: ?*c_void,
pFindInfo: ?*CERT_STORE_PROV_FIND_INFO,
pPrevCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
ppvStoreProvFindInfo: ?*?*c_void,
ppProvCertContext: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_FREE_FIND_CERT = fn(
hStoreProv: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
pvStoreProvFindInfo: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_GET_CERT_PROPERTY = fn(
hStoreProv: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwPropId: u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_FIND_CRL = fn(
hStoreProv: ?*c_void,
pFindInfo: ?*CERT_STORE_PROV_FIND_INFO,
pPrevCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
ppvStoreProvFindInfo: ?*?*c_void,
ppProvCrlContext: ?*?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_FREE_FIND_CRL = fn(
hStoreProv: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
pvStoreProvFindInfo: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_GET_CRL_PROPERTY = fn(
hStoreProv: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_FIND_CTL = fn(
hStoreProv: ?*c_void,
pFindInfo: ?*CERT_STORE_PROV_FIND_INFO,
pPrevCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
ppvStoreProvFindInfo: ?*?*c_void,
ppProvCtlContext: ?*?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_FREE_FIND_CTL = fn(
hStoreProv: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
pvStoreProvFindInfo: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_STORE_PROV_GET_CTL_PROPERTY = fn(
hStoreProv: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CRL_FIND_ISSUED_FOR_PARA = extern struct {
pSubjectCert: ?*const CERT_CONTEXT,
pIssuerCert: ?*const CERT_CONTEXT,
};
pub const CTL_ANY_SUBJECT_INFO = extern struct {
SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
SubjectIdentifier: CRYPTOAPI_BLOB,
};
pub const CTL_FIND_USAGE_PARA = extern struct {
cbSize: u32,
SubjectUsage: CTL_USAGE,
ListIdentifier: CRYPTOAPI_BLOB,
pSigner: ?*CERT_INFO,
};
pub const CTL_FIND_SUBJECT_PARA = extern struct {
cbSize: u32,
pUsagePara: ?*CTL_FIND_USAGE_PARA,
dwSubjectType: u32,
pvSubject: ?*c_void,
};
pub const PFN_CERT_CREATE_CONTEXT_SORT_FUNC = fn(
cbTotalEncoded: u32,
cbRemainEncoded: u32,
cEntry: u32,
pvSort: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_CREATE_CONTEXT_PARA = extern struct {
cbSize: u32,
pfnFree: ?PFN_CRYPT_FREE,
pvFree: ?*c_void,
pfnSort: ?PFN_CERT_CREATE_CONTEXT_SORT_FUNC,
pvSort: ?*c_void,
};
pub const CERT_SYSTEM_STORE_INFO = extern struct {
cbSize: u32,
};
pub const CERT_PHYSICAL_STORE_INFO = extern struct {
cbSize: u32,
pszOpenStoreProvider: ?PSTR,
dwOpenEncodingType: u32,
dwOpenFlags: u32,
OpenParameters: CRYPTOAPI_BLOB,
dwFlags: u32,
dwPriority: u32,
};
pub const PFN_CERT_ENUM_SYSTEM_STORE_LOCATION = fn(
pwszStoreLocation: ?[*:0]const u16,
dwFlags: u32,
pvReserved: ?*c_void,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_ENUM_SYSTEM_STORE = fn(
pvSystemStore: ?*const c_void,
dwFlags: CERT_SYSTEM_STORE_FLAGS,
pStoreInfo: ?*CERT_SYSTEM_STORE_INFO,
pvReserved: ?*c_void,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_ENUM_PHYSICAL_STORE = fn(
pvSystemStore: ?*const c_void,
dwFlags: u32,
pwszStoreName: ?[*:0]const u16,
pStoreInfo: ?*CERT_PHYSICAL_STORE_INFO,
pvReserved: ?*c_void,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CTL_VERIFY_USAGE_PARA = extern struct {
cbSize: u32,
ListIdentifier: CRYPTOAPI_BLOB,
cCtlStore: u32,
rghCtlStore: ?*?*c_void,
cSignerStore: u32,
rghSignerStore: ?*?*c_void,
};
pub const CTL_VERIFY_USAGE_STATUS = extern struct {
cbSize: u32,
dwError: u32,
dwFlags: u32,
ppCtl: ?*?*CTL_CONTEXT,
dwCtlEntryIndex: u32,
ppSigner: ?*?*CERT_CONTEXT,
dwSignerIndex: u32,
};
pub const CERT_REVOCATION_CRL_INFO = extern struct {
cbSize: u32,
pBaseCrlContext: ?*CRL_CONTEXT,
pDeltaCrlContext: ?*CRL_CONTEXT,
pCrlEntry: ?*CRL_ENTRY,
fDeltaCrlEntry: BOOL,
};
pub const CERT_REVOCATION_PARA = extern struct {
cbSize: u32,
pIssuerCert: ?*const CERT_CONTEXT,
cCertStore: u32,
rgCertStore: ?*?*c_void,
hCrlStore: ?*c_void,
pftTimeToUse: ?*FILETIME,
};
pub const CERT_REVOCATION_STATUS = extern struct {
cbSize: u32,
dwIndex: u32,
dwError: u32,
dwReason: CERT_REVOCATION_STATUS_REASON,
fHasFreshnessTime: BOOL,
dwFreshnessTime: u32,
};
pub const CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO = extern struct {
CertSignHashCNGAlgPropData: CRYPTOAPI_BLOB,
CertIssuerPubKeyBitLengthPropData: CRYPTOAPI_BLOB,
};
pub const CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO = extern struct {
cCNGHashAlgid: u32,
rgpwszCNGHashAlgid: ?*?PWSTR,
dwWeakIndex: u32,
};
pub const PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC = fn(
dwCertEncodingType: u32,
pSignatureAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
ppvDecodedSignPara: ?*?*c_void,
ppwszCNGHashAlgid: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC = fn(
hKey: usize,
dwCertEncodingType: u32,
pSignatureAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pvDecodedSignPara: ?*c_void,
pwszCNGPubKeyAlgid: ?[*:0]const u16,
pwszCNGHashAlgid: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 7?
pbComputedHash: ?*u8,
cbComputedHash: u32,
// TODO: what to do with BytesParamIndex 9?
pbSignature: ?*u8,
pcbSignature: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC = fn(
dwCertEncodingType: u32,
pPubKeyInfo: ?*CERT_PUBLIC_KEY_INFO,
pSignatureAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pvDecodedSignPara: ?*c_void,
pwszCNGPubKeyAlgid: ?[*:0]const u16,
pwszCNGHashAlgid: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 7?
pbComputedHash: ?*u8,
cbComputedHash: u32,
// TODO: what to do with BytesParamIndex 9?
pbSignature: ?*u8,
cbSignature: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA = extern struct {
cOID: u32,
rgpszOID: ?*?PSTR,
};
pub const PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC = fn(
hNCryptKey: usize,
dwCertEncodingType: u32,
pszPublicKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pInfo: ?*CERT_PUBLIC_KEY_INFO,
pcbInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC = fn(
hBCryptKey: BCRYPT_KEY_HANDLE,
dwCertEncodingType: u32,
pszPublicKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pInfo: ?*CERT_PUBLIC_KEY_INFO,
pcbInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC = fn(
dwCertEncodingType: u32,
pInfo: ?*CERT_PUBLIC_KEY_INFO,
dwFlags: u32,
pvAuxInfo: ?*c_void,
phKey: ?*BCRYPT_KEY_HANDLE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_IMPORT_PRIV_KEY_FUNC = fn(
hCryptProv: usize,
pPrivateKeyInfo: ?*CRYPT_PRIVATE_KEY_INFO,
dwFlags: u32,
pvAuxInfo: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_EXPORT_PRIV_KEY_FUNC = fn(
hCryptProv: usize,
dwKeySpec: u32,
pszPrivateKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pPrivateKeyInfo: ?*CRYPT_PRIVATE_KEY_INFO,
pcbPrivateKeyInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_GET_SIGNER_CERTIFICATE = fn(
pvGetArg: ?*c_void,
dwCertEncodingType: u32,
pSignerId: ?*CERT_INFO,
hMsgCertStore: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
pub const CRYPT_SIGN_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgEncodingType: u32,
pSigningCert: ?*const CERT_CONTEXT,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*c_void,
cMsgCert: u32,
rgpMsgCert: ?*?*CERT_CONTEXT,
cMsgCrl: u32,
rgpMsgCrl: ?*?*CRL_CONTEXT,
cAuthAttr: u32,
rgAuthAttr: ?*CRYPT_ATTRIBUTE,
cUnauthAttr: u32,
rgUnauthAttr: ?*CRYPT_ATTRIBUTE,
dwFlags: u32,
dwInnerContentType: u32,
};
pub const CRYPT_VERIFY_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgAndCertEncodingType: u32,
hCryptProv: usize,
pfnGetSignerCertificate: ?PFN_CRYPT_GET_SIGNER_CERTIFICATE,
pvGetArg: ?*c_void,
};
pub const CRYPT_ENCRYPT_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgEncodingType: u32,
hCryptProv: usize,
ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvEncryptionAuxInfo: ?*c_void,
dwFlags: u32,
dwInnerContentType: u32,
};
pub const CRYPT_DECRYPT_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgAndCertEncodingType: u32,
cCertStore: u32,
rghCertStore: ?*?*c_void,
};
pub const CRYPT_HASH_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgEncodingType: u32,
hCryptProv: usize,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*c_void,
};
pub const CRYPT_KEY_SIGN_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgAndCertEncodingType: CERT_QUERY_ENCODING_TYPE,
Anonymous: extern union {
hCryptProv: usize,
hNCryptKey: usize,
},
dwKeySpec: CERT_KEY_SPEC,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*c_void,
PubKeyAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
};
pub const CRYPT_KEY_VERIFY_MESSAGE_PARA = extern struct {
cbSize: u32,
dwMsgEncodingType: u32,
hCryptProv: usize,
};
pub const CERT_CHAIN = extern struct {
cCerts: u32,
certs: ?*CRYPTOAPI_BLOB,
keyLocatorInfo: CRYPT_KEY_PROV_INFO,
};
pub const PFN_CRYPT_ASYNC_PARAM_FREE_FUNC = fn(
pszParamOid: ?PSTR,
pvParam: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CRYPT_BLOB_ARRAY = extern struct {
cBlob: u32,
rgBlob: ?*CRYPTOAPI_BLOB,
};
pub const CRYPT_CREDENTIALS = extern struct {
cbSize: u32,
pszCredentialsOid: ?[*:0]const u8,
pvCredentials: ?*c_void,
};
pub const CRYPT_PASSWORD_CREDENTIALSA = extern struct {
cbSize: u32,
pszUsername: ?PSTR,
pszPassword: ?PSTR,
};
pub const CRYPT_PASSWORD_CREDENTIALSW = extern struct {
cbSize: u32,
pszUsername: ?PWSTR,
pszPassword: ?PWSTR,
};
pub const PFN_FREE_ENCODED_OBJECT_FUNC = fn(
pszObjectOid: ?[*:0]const u8,
pObject: ?*CRYPT_BLOB_ARRAY,
pvFreeContext: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CRYPTNET_URL_CACHE_PRE_FETCH_INFO = extern struct {
cbSize: u32,
dwObjectType: u32,
dwError: u32,
dwReserved: u32,
ThisUpdateTime: FILETIME,
NextUpdateTime: FILETIME,
PublishTime: FILETIME,
};
pub const CRYPTNET_URL_CACHE_FLUSH_INFO = extern struct {
cbSize: u32,
dwExemptSeconds: u32,
ExpireTime: FILETIME,
};
pub const CRYPTNET_URL_CACHE_RESPONSE_INFO = extern struct {
cbSize: u32,
wResponseType: u16,
wResponseFlags: u16,
LastModifiedTime: FILETIME,
dwMaxAge: u32,
pwszETag: ?[*:0]const u16,
dwProxyId: u32,
};
pub const CRYPT_RETRIEVE_AUX_INFO = extern struct {
cbSize: u32,
pLastSyncTime: ?*FILETIME,
dwMaxUrlRetrievalByteCount: u32,
pPreFetchInfo: ?*CRYPTNET_URL_CACHE_PRE_FETCH_INFO,
pFlushInfo: ?*CRYPTNET_URL_CACHE_FLUSH_INFO,
ppResponseInfo: ?*?*CRYPTNET_URL_CACHE_RESPONSE_INFO,
pwszCacheFileNamePrefix: ?PWSTR,
pftCacheResync: ?*FILETIME,
fProxyCacheRetrieval: BOOL,
dwHttpStatusCode: u32,
ppwszErrorResponseHeaders: ?*?PWSTR,
ppErrorContentBlob: ?*?*CRYPTOAPI_BLOB,
};
pub const PFN_CRYPT_CANCEL_RETRIEVAL = fn(
dwFlags: u32,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC = fn(
pvCompletion: ?*c_void,
dwCompletionCode: u32,
pszUrl: ?[*:0]const u8,
pszObjectOid: ?PSTR,
pvObject: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CRYPT_ASYNC_RETRIEVAL_COMPLETION = extern struct {
pfnCompletion: ?PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC,
pvCompletion: ?*c_void,
};
pub const PFN_CANCEL_ASYNC_RETRIEVAL_FUNC = fn(
hAsyncRetrieve: ?HCRYPTASYNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CRYPT_URL_ARRAY = extern struct {
cUrl: u32,
rgwszUrl: ?*?PWSTR,
};
pub const CRYPT_URL_INFO = extern struct {
cbSize: u32,
dwSyncDeltaTime: u32,
cGroup: u32,
rgcGroupEntry: ?*u32,
};
pub const CERT_CRL_CONTEXT_PAIR = extern struct {
pCertContext: ?*const CERT_CONTEXT,
pCrlContext: ?*CRL_CONTEXT,
};
pub const CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO = extern struct {
cbSize: u32,
iDeltaCrlIndicator: i32,
pftCacheResync: ?*FILETIME,
pLastSyncTime: ?*FILETIME,
pMaxAgeTime: ?*FILETIME,
pChainPara: ?*CERT_REVOCATION_CHAIN_PARA,
pDeltaCrlIndicator: ?*CRYPTOAPI_BLOB,
};
pub const PFN_CRYPT_ENUM_KEYID_PROP = fn(
pKeyIdentifier: ?*const CRYPTOAPI_BLOB,
dwFlags: u32,
pvReserved: ?*c_void,
pvArg: ?*c_void,
cProp: u32,
rgdwPropId: [*]u32,
rgpvData: [*]?*c_void,
rgcbData: [*]u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_CHAIN_ENGINE_CONFIG = extern struct {
cbSize: u32,
hRestrictedRoot: ?*c_void,
hRestrictedTrust: ?*c_void,
hRestrictedOther: ?*c_void,
cAdditionalStore: u32,
rghAdditionalStore: ?*?*c_void,
dwFlags: u32,
dwUrlRetrievalTimeout: u32,
MaximumCachedCertificates: u32,
CycleDetectionModulus: u32,
hExclusiveRoot: ?*c_void,
hExclusiveTrustedPeople: ?*c_void,
dwExclusiveFlags: u32,
};
pub const CERT_TRUST_STATUS = extern struct {
dwErrorStatus: u32,
dwInfoStatus: u32,
};
pub const CERT_REVOCATION_INFO = extern struct {
cbSize: u32,
dwRevocationResult: u32,
pszRevocationOid: ?[*:0]const u8,
pvOidSpecificInfo: ?*c_void,
fHasFreshnessTime: BOOL,
dwFreshnessTime: u32,
pCrlInfo: ?*CERT_REVOCATION_CRL_INFO,
};
pub const CERT_TRUST_LIST_INFO = extern struct {
cbSize: u32,
pCtlEntry: ?*CTL_ENTRY,
pCtlContext: ?*CTL_CONTEXT,
};
pub const CERT_CHAIN_ELEMENT = extern struct {
cbSize: u32,
pCertContext: ?*const CERT_CONTEXT,
TrustStatus: CERT_TRUST_STATUS,
pRevocationInfo: ?*CERT_REVOCATION_INFO,
pIssuanceUsage: ?*CTL_USAGE,
pApplicationUsage: ?*CTL_USAGE,
pwszExtendedErrorInfo: ?[*:0]const u16,
};
pub const CERT_SIMPLE_CHAIN = extern struct {
cbSize: u32,
TrustStatus: CERT_TRUST_STATUS,
cElement: u32,
rgpElement: ?*?*CERT_CHAIN_ELEMENT,
pTrustListInfo: ?*CERT_TRUST_LIST_INFO,
fHasRevocationFreshnessTime: BOOL,
dwRevocationFreshnessTime: u32,
};
pub const CERT_CHAIN_CONTEXT = extern struct {
cbSize: u32,
TrustStatus: CERT_TRUST_STATUS,
cChain: u32,
rgpChain: ?*?*CERT_SIMPLE_CHAIN,
cLowerQualityChainContext: u32,
rgpLowerQualityChainContext: ?*?*CERT_CHAIN_CONTEXT,
fHasRevocationFreshnessTime: BOOL,
dwRevocationFreshnessTime: u32,
dwCreateFlags: u32,
ChainId: Guid,
};
pub const CERT_USAGE_MATCH = extern struct {
dwType: u32,
Usage: CTL_USAGE,
};
pub const CTL_USAGE_MATCH = extern struct {
dwType: u32,
Usage: CTL_USAGE,
};
pub const CERT_CHAIN_PARA = extern struct {
cbSize: u32,
RequestedUsage: CERT_USAGE_MATCH,
};
pub const CERT_REVOCATION_CHAIN_PARA = extern struct {
cbSize: u32,
hChainEngine: ?HCERTCHAINENGINE,
hAdditionalStore: ?*c_void,
dwChainFlags: u32,
dwUrlRetrievalTimeout: u32,
pftCurrentTime: ?*FILETIME,
pftCacheResync: ?*FILETIME,
cbMaxUrlRetrievalByteCount: u32,
};
pub const CRL_REVOCATION_INFO = extern struct {
pCrlEntry: ?*CRL_ENTRY,
pCrlContext: ?*CRL_CONTEXT,
pCrlIssuerChain: ?*CERT_CHAIN_CONTEXT,
};
pub const PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK = fn(
pCert: ?*const CERT_CONTEXT,
pvFindArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_CHAIN_FIND_BY_ISSUER_PARA = extern struct {
cbSize: u32,
pszUsageIdentifier: ?[*:0]const u8,
dwKeySpec: u32,
dwAcquirePrivateKeyFlags: u32,
cIssuer: u32,
rgIssuer: ?*CRYPTOAPI_BLOB,
pfnFindCallback: ?PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK,
pvFindArg: ?*c_void,
};
pub const CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwFlags: CERT_CHAIN_POLICY_FLAGS,
pvExtraPolicyPara: ?*c_void,
};
pub const CERT_CHAIN_POLICY_STATUS = extern struct {
cbSize: u32,
dwError: u32,
lChainIndex: i32,
lElementIndex: i32,
pvExtraPolicyStatus: ?*c_void,
};
pub const AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwRegPolicySettings: u32,
pSignerInfo: ?*CMSG_SIGNER_INFO,
};
pub const AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS = extern struct {
cbSize: u32,
fCommercial: BOOL,
};
pub const AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwRegPolicySettings: u32,
fCommercial: BOOL,
};
pub const HTTPSPolicyCallbackData = extern struct {
Anonymous: extern union {
cbStruct: u32,
cbSize: u32,
},
dwAuthType: HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE,
fdwChecks: u32,
pwszServerName: ?PWSTR,
};
pub const EV_EXTRA_CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwRootProgramQualifierFlags: CERT_ROOT_PROGRAM_FLAGS,
};
pub const EV_EXTRA_CERT_CHAIN_POLICY_STATUS = extern struct {
cbSize: u32,
dwQualifiers: u32,
dwIssuanceUsageIndex: u32,
};
pub const SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS = extern struct {
cbSize: u32,
dwErrorLevel: u32,
dwErrorCategory: u32,
dwReserved: u32,
wszErrorText: [256]u16,
};
pub const SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwReserved: u32,
pwszServerName: ?PWSTR,
rgpszHpkpValue: [2]?PSTR,
};
pub const SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA = extern struct {
cbSize: u32,
dwReserved: u32,
pwszServerName: ?[*:0]const u16,
};
pub const SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS = extern struct {
cbSize: u32,
lError: i32,
wszErrorText: [512]u16,
};
pub const CRYPT_PKCS12_PBE_PARAMS = extern struct {
iIterations: i32,
cbSalt: u32,
};
pub const PKCS12_PBES2_EXPORT_PARAMS = extern struct {
dwSize: u32,
hNcryptDescriptor: ?*c_void,
pwszPbes2Alg: ?PWSTR,
};
pub const CERT_SERVER_OCSP_RESPONSE_CONTEXT = extern struct {
cbSize: u32,
pbEncodedOcspResponse: ?*u8,
cbEncodedOcspResponse: u32,
};
pub const PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK = fn(
pChainContext: ?*CERT_CHAIN_CONTEXT,
pServerOcspResponseContext: ?*CERT_SERVER_OCSP_RESPONSE_CONTEXT,
pNewCrlContext: ?*CRL_CONTEXT,
pPrevCrlContext: ?*CRL_CONTEXT,
pvArg: ?*c_void,
dwWriteOcspFileError: u32,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA = extern struct {
cbSize: u32,
dwFlags: u32,
pcbUsedSize: ?*u32,
pwszOcspDirectory: ?PWSTR,
pfnUpdateCallback: ?PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK,
pvUpdateCallbackArg: ?*c_void,
};
pub const CERT_SELECT_CHAIN_PARA = extern struct {
hChainEngine: ?HCERTCHAINENGINE,
pTime: ?*FILETIME,
hAdditionalStore: ?*c_void,
pChainPara: ?*CERT_CHAIN_PARA,
dwFlags: u32,
};
pub const CERT_SELECT_CRITERIA = extern struct {
dwType: CERT_SELECT_CRITERIA_TYPE,
cPara: u32,
ppPara: ?*?*c_void,
};
pub const CRYPT_TIMESTAMP_REQUEST = extern struct {
dwVersion: CRYPT_TIMESTAMP_VERSION,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
HashedMessage: CRYPTOAPI_BLOB,
pszTSAPolicyId: ?PSTR,
Nonce: CRYPTOAPI_BLOB,
fCertReq: BOOL,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CRYPT_TIMESTAMP_RESPONSE = extern struct {
dwStatus: CRYPT_TIMESTAMP_RESPONSE_STATUS,
cFreeText: u32,
rgFreeText: ?*?PWSTR,
FailureInfo: CRYPT_BIT_BLOB,
ContentInfo: CRYPTOAPI_BLOB,
};
pub const CRYPT_TIMESTAMP_ACCURACY = extern struct {
dwSeconds: u32,
dwMillis: u32,
dwMicros: u32,
};
pub const CRYPT_TIMESTAMP_INFO = extern struct {
dwVersion: u32,
pszTSAPolicyId: ?PSTR,
HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
HashedMessage: CRYPTOAPI_BLOB,
SerialNumber: CRYPTOAPI_BLOB,
ftTime: FILETIME,
pvAccuracy: ?*CRYPT_TIMESTAMP_ACCURACY,
fOrdering: BOOL,
Nonce: CRYPTOAPI_BLOB,
Tsa: CRYPTOAPI_BLOB,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const CRYPT_TIMESTAMP_CONTEXT = extern struct {
cbEncoded: u32,
pbEncoded: ?*u8,
pTimeStamp: ?*CRYPT_TIMESTAMP_INFO,
};
pub const CRYPT_TIMESTAMP_PARA = extern struct {
pszTSAPolicyId: ?[*:0]const u8,
fRequestCerts: BOOL,
Nonce: CRYPTOAPI_BLOB,
cExtension: u32,
rgExtension: ?*CERT_EXTENSION,
};
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH = fn(
pContext: ?*c_void,
rgIdentifierOrNameList: [*]?*CRYPTOAPI_BLOB,
dwIdentifierOrNameListCount: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET = fn(
pPluginContext: ?*c_void,
pIdentifier: ?*CRYPTOAPI_BLOB,
dwNameType: u32,
pNameBlob: ?*CRYPTOAPI_BLOB,
ppbContent: ?*?*u8,
pcbContent: ?*u32,
ppwszPassword: ?*?PWSTR,
ppIdentifier: ?*?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE = fn(
dwReason: CRYPT_OBJECT_LOCATOR_RELEASE_REASON,
pPluginContext: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD = fn(
pPluginContext: ?*c_void,
pwszPassword: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) void;
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE = fn(
pPluginContext: ?*c_void,
pbData: ?*u8,
) callconv(@import("std").os.windows.WINAPI) void;
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER = fn(
pPluginContext: ?*c_void,
pIdentifier: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) void;
pub const CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE = extern struct {
cbSize: u32,
pfnGet: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET,
pfnRelease: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE,
pfnFreePassword: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD,
pfnFree: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE,
pfnFreeIdentifier: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER,
};
pub const PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE = fn(
pfnFlush: ?PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH,
pContext: ?*c_void,
pdwExpectedObjectCount: ?*u32,
ppFuncTable: ?*?*CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE,
ppPluginContext: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFN_CERT_IS_WEAK_HASH = fn(
dwHashUseType: u32,
pwszCNGHashAlgid: ?[*:0]const u16,
dwChainFlags: u32,
pSignerChainContext: ?*CERT_CHAIN_CONTEXT,
pTimeStamp: ?*FILETIME,
pwszFileName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFNCryptStreamOutputCallback = fn(
pvCallbackCtxt: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: usize,
fFinal: BOOL,
) callconv(@import("std").os.windows.WINAPI) i32;
pub const NCRYPT_PROTECT_STREAM_INFO = extern struct {
pfnStreamOutput: ?PFNCryptStreamOutputCallback,
pvCallbackCtxt: ?*c_void,
};
pub const PFNCryptStreamOutputCallbackEx = fn(
pvCallbackCtxt: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: usize,
hDescriptor: NCRYPT_DESCRIPTOR_HANDLE,
fFinal: BOOL,
) callconv(@import("std").os.windows.WINAPI) i32;
pub const NCRYPT_PROTECT_STREAM_INFO_EX = extern struct {
pfnStreamOutput: ?PFNCryptStreamOutputCallbackEx,
pvCallbackCtxt: ?*c_void,
};
pub const CRYPT_XML_CHARSET = enum(i32) {
AUTO = 0,
UTF8 = 1,
UTF16LE = 2,
UTF16BE = 3,
};
pub const CRYPT_XML_CHARSET_AUTO = CRYPT_XML_CHARSET.AUTO;
pub const CRYPT_XML_CHARSET_UTF8 = CRYPT_XML_CHARSET.UTF8;
pub const CRYPT_XML_CHARSET_UTF16LE = CRYPT_XML_CHARSET.UTF16LE;
pub const CRYPT_XML_CHARSET_UTF16BE = CRYPT_XML_CHARSET.UTF16BE;
pub const CRYPT_XML_BLOB = extern struct {
dwCharset: CRYPT_XML_CHARSET,
cbData: u32,
pbData: ?*u8,
};
pub const CRYPT_XML_DATA_BLOB = extern struct {
cbData: u32,
pbData: ?*u8,
};
pub const CRYPT_XML_PROPERTY_ID = enum(i32) {
MAX_HEAP_SIZE = 1,
SIGNATURE_LOCATION = 2,
MAX_SIGNATURES = 3,
DOC_DECLARATION = 4,
XML_OUTPUT_CHARSET = 5,
};
pub const CRYPT_XML_PROPERTY_MAX_HEAP_SIZE = CRYPT_XML_PROPERTY_ID.MAX_HEAP_SIZE;
pub const CRYPT_XML_PROPERTY_SIGNATURE_LOCATION = CRYPT_XML_PROPERTY_ID.SIGNATURE_LOCATION;
pub const CRYPT_XML_PROPERTY_MAX_SIGNATURES = CRYPT_XML_PROPERTY_ID.MAX_SIGNATURES;
pub const CRYPT_XML_PROPERTY_DOC_DECLARATION = CRYPT_XML_PROPERTY_ID.DOC_DECLARATION;
pub const CRYPT_XML_PROPERTY_XML_OUTPUT_CHARSET = CRYPT_XML_PROPERTY_ID.XML_OUTPUT_CHARSET;
pub const CRYPT_XML_PROPERTY = extern struct {
dwPropId: CRYPT_XML_PROPERTY_ID,
pvValue: ?*const c_void,
cbValue: u32,
};
pub const PFN_CRYPT_XML_WRITE_CALLBACK = fn(
pvCallbackState: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_CRYPT_XML_DATA_PROVIDER_READ = fn(
pvCallbackState: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*u8,
cbData: u32,
pcbRead: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFN_CRYPT_XML_DATA_PROVIDER_CLOSE = fn(
pvCallbackState: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CRYPT_XML_DATA_PROVIDER = extern struct {
pvCallbackState: ?*c_void,
cbBufferSize: u32,
pfnRead: ?PFN_CRYPT_XML_DATA_PROVIDER_READ,
pfnClose: ?PFN_CRYPT_XML_DATA_PROVIDER_CLOSE,
};
pub const PFN_CRYPT_XML_CREATE_TRANSFORM = fn(
pTransform: ?*const CRYPT_XML_ALGORITHM,
pProviderIn: ?*CRYPT_XML_DATA_PROVIDER,
pProviderOut: ?*CRYPT_XML_DATA_PROVIDER,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CRYPT_XML_STATUS = extern struct {
cbSize: u32,
dwErrorStatus: CRYPT_XML_STATUS_ERROR_STATUS,
dwInfoStatus: CRYPT_XML_STATUS_INFO_STATUS,
};
pub const CRYPT_XML_ALGORITHM = extern struct {
cbSize: u32,
wszAlgorithm: ?[*:0]const u16,
Encoded: CRYPT_XML_BLOB,
};
pub const CRYPT_XML_TRANSFORM_INFO = extern struct {
cbSize: u32,
wszAlgorithm: ?[*:0]const u16,
cbBufferSize: u32,
dwFlags: CRYPT_XML_TRANSFORM_FLAGS,
pfnCreateTransform: ?PFN_CRYPT_XML_CREATE_TRANSFORM,
};
pub const CRYPT_XML_TRANSFORM_CHAIN_CONFIG = extern struct {
cbSize: u32,
cTransformInfo: u32,
rgpTransformInfo: ?*?*CRYPT_XML_TRANSFORM_INFO,
};
pub const CRYPT_XML_KEY_DSA_KEY_VALUE = extern struct {
P: CRYPT_XML_DATA_BLOB,
Q: CRYPT_XML_DATA_BLOB,
G: CRYPT_XML_DATA_BLOB,
Y: CRYPT_XML_DATA_BLOB,
J: CRYPT_XML_DATA_BLOB,
Seed: CRYPT_XML_DATA_BLOB,
Counter: CRYPT_XML_DATA_BLOB,
};
pub const CRYPT_XML_KEY_ECDSA_KEY_VALUE = extern struct {
wszNamedCurve: ?[*:0]const u16,
X: CRYPT_XML_DATA_BLOB,
Y: CRYPT_XML_DATA_BLOB,
ExplicitPara: CRYPT_XML_BLOB,
};
pub const CRYPT_XML_KEY_RSA_KEY_VALUE = extern struct {
Modulus: CRYPT_XML_DATA_BLOB,
Exponent: CRYPT_XML_DATA_BLOB,
};
pub const CRYPT_XML_KEY_VALUE = extern struct {
dwType: CRYPT_XML_KEY_VALUE_TYPE,
Anonymous: extern union {
DSAKeyValue: CRYPT_XML_KEY_DSA_KEY_VALUE,
RSAKeyValue: CRYPT_XML_KEY_RSA_KEY_VALUE,
ECDSAKeyValue: CRYPT_XML_KEY_ECDSA_KEY_VALUE,
Custom: CRYPT_XML_BLOB,
},
};
pub const CRYPT_XML_ISSUER_SERIAL = extern struct {
wszIssuer: ?[*:0]const u16,
wszSerial: ?[*:0]const u16,
};
pub const CRYPT_XML_X509DATA_ITEM = extern struct {
dwType: CRYPT_XML_X509DATA_TYPE,
Anonymous: extern union {
IssuerSerial: CRYPT_XML_ISSUER_SERIAL,
SKI: CRYPT_XML_DATA_BLOB,
wszSubjectName: ?[*:0]const u16,
Certificate: CRYPT_XML_DATA_BLOB,
CRL: CRYPT_XML_DATA_BLOB,
Custom: CRYPT_XML_BLOB,
},
};
pub const CRYPT_XML_X509DATA = extern struct {
cX509Data: u32,
rgX509Data: ?*CRYPT_XML_X509DATA_ITEM,
};
pub const CRYPT_XML_KEY_INFO_ITEM = extern struct {
dwType: CRYPT_XML_KEYINFO_TYPE,
Anonymous: extern union {
wszKeyName: ?[*:0]const u16,
KeyValue: CRYPT_XML_KEY_VALUE,
RetrievalMethod: CRYPT_XML_BLOB,
X509Data: CRYPT_XML_X509DATA,
Custom: CRYPT_XML_BLOB,
},
};
pub const CRYPT_XML_KEY_INFO = extern struct {
cbSize: u32,
wszId: ?[*:0]const u16,
cKeyInfo: u32,
rgKeyInfo: ?*CRYPT_XML_KEY_INFO_ITEM,
hVerifyKey: BCRYPT_KEY_HANDLE,
};
pub const CRYPT_XML_REFERENCE = extern struct {
cbSize: u32,
hReference: ?*c_void,
wszId: ?[*:0]const u16,
wszUri: ?[*:0]const u16,
wszType: ?[*:0]const u16,
DigestMethod: CRYPT_XML_ALGORITHM,
DigestValue: CRYPTOAPI_BLOB,
cTransform: u32,
rgTransform: ?*CRYPT_XML_ALGORITHM,
};
pub const CRYPT_XML_REFERENCES = extern struct {
cReference: u32,
rgpReference: ?*?*CRYPT_XML_REFERENCE,
};
pub const CRYPT_XML_SIGNED_INFO = extern struct {
cbSize: u32,
wszId: ?[*:0]const u16,
Canonicalization: CRYPT_XML_ALGORITHM,
SignatureMethod: CRYPT_XML_ALGORITHM,
cReference: u32,
rgpReference: ?*?*CRYPT_XML_REFERENCE,
Encoded: CRYPT_XML_BLOB,
};
pub const CRYPT_XML_OBJECT = extern struct {
cbSize: u32,
hObject: ?*c_void,
wszId: ?[*:0]const u16,
wszMimeType: ?[*:0]const u16,
wszEncoding: ?[*:0]const u16,
Manifest: CRYPT_XML_REFERENCES,
Encoded: CRYPT_XML_BLOB,
};
pub const CRYPT_XML_SIGNATURE = extern struct {
cbSize: u32,
hSignature: ?*c_void,
wszId: ?[*:0]const u16,
SignedInfo: CRYPT_XML_SIGNED_INFO,
SignatureValue: CRYPTOAPI_BLOB,
pKeyInfo: ?*CRYPT_XML_KEY_INFO,
cObject: u32,
rgpObject: ?*?*CRYPT_XML_OBJECT,
};
pub const CRYPT_XML_DOC_CTXT = extern struct {
cbSize: u32,
hDocCtxt: ?*c_void,
pTransformsConfig: ?*CRYPT_XML_TRANSFORM_CHAIN_CONFIG,
cSignature: u32,
rgpSignature: ?*?*CRYPT_XML_SIGNATURE,
};
pub const CRYPT_XML_KEYINFO_PARAM = extern struct {
wszId: ?[*:0]const u16,
wszKeyName: ?[*:0]const u16,
SKI: CRYPTOAPI_BLOB,
wszSubjectName: ?[*:0]const u16,
cCertificate: u32,
rgCertificate: ?*CRYPTOAPI_BLOB,
cCRL: u32,
rgCRL: ?*CRYPTOAPI_BLOB,
};
pub const CRYPT_XML_KEYINFO_SPEC = enum(i32) {
NONE = 0,
ENCODED = 1,
PARAM = 2,
};
pub const CRYPT_XML_KEYINFO_SPEC_NONE = CRYPT_XML_KEYINFO_SPEC.NONE;
pub const CRYPT_XML_KEYINFO_SPEC_ENCODED = CRYPT_XML_KEYINFO_SPEC.ENCODED;
pub const CRYPT_XML_KEYINFO_SPEC_PARAM = CRYPT_XML_KEYINFO_SPEC.PARAM;
pub const CRYPT_XML_ALGORITHM_INFO = extern struct {
cbSize: u32,
wszAlgorithmURI: ?PWSTR,
wszName: ?PWSTR,
dwGroupId: CRYPT_XML_GROUP_ID,
wszCNGAlgid: ?PWSTR,
wszCNGExtraAlgid: ?PWSTR,
dwSignFlags: u32,
dwVerifyFlags: u32,
pvPaddingInfo: ?*c_void,
pvExtraInfo: ?*c_void,
};
pub const PFN_CRYPT_XML_ENUM_ALG_INFO = fn(
pInfo: ?*const CRYPT_XML_ALGORITHM_INFO,
pvArg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CryptXmlDllGetInterface = fn(
dwFlags: u32,
pMethod: ?*const CRYPT_XML_ALGORITHM_INFO,
pInterface: ?*CRYPT_XML_CRYPTOGRAPHIC_INTERFACE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllEncodeAlgorithm = fn(
pAlgInfo: ?*const CRYPT_XML_ALGORITHM_INFO,
dwCharset: CRYPT_XML_CHARSET,
pvCallbackState: ?*c_void,
pfnWrite: ?PFN_CRYPT_XML_WRITE_CALLBACK,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllCreateDigest = fn(
pDigestMethod: ?*const CRYPT_XML_ALGORITHM,
pcbSize: ?*u32,
phDigest: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllDigestData = fn(
hDigest: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllFinalizeDigest = fn(
hDigest: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbDigest: ?*u8,
cbDigest: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllCloseDigest = fn(
hDigest: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllSignData = fn(
pSignatureMethod: ?*const CRYPT_XML_ALGORITHM,
hCryptProvOrNCryptKey: usize,
dwKeySpec: u32,
// TODO: what to do with BytesParamIndex 4?
pbInput: ?*const u8,
cbInput: u32,
// TODO: what to do with BytesParamIndex 6?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllVerifySignature = fn(
pSignatureMethod: ?*const CRYPT_XML_ALGORITHM,
hKey: BCRYPT_KEY_HANDLE,
// TODO: what to do with BytesParamIndex 3?
pbInput: ?*const u8,
cbInput: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*const u8,
cbSignature: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllGetAlgorithmInfo = fn(
pXmlAlgorithm: ?*const CRYPT_XML_ALGORITHM,
ppAlgInfo: ?*?*CRYPT_XML_ALGORITHM_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CRYPT_XML_CRYPTOGRAPHIC_INTERFACE = extern struct {
cbSize: u32,
fpCryptXmlEncodeAlgorithm: ?CryptXmlDllEncodeAlgorithm,
fpCryptXmlCreateDigest: ?CryptXmlDllCreateDigest,
fpCryptXmlDigestData: ?CryptXmlDllDigestData,
fpCryptXmlFinalizeDigest: ?CryptXmlDllFinalizeDigest,
fpCryptXmlCloseDigest: ?CryptXmlDllCloseDigest,
fpCryptXmlSignData: ?CryptXmlDllSignData,
fpCryptXmlVerifySignature: ?CryptXmlDllVerifySignature,
fpCryptXmlGetAlgorithmInfo: ?CryptXmlDllGetAlgorithmInfo,
};
pub const CryptXmlDllEncodeKeyValue = fn(
hKey: usize,
dwCharset: CRYPT_XML_CHARSET,
pvCallbackState: ?*c_void,
pfnWrite: ?PFN_CRYPT_XML_WRITE_CALLBACK,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CryptXmlDllCreateKey = fn(
pEncoded: ?*const CRYPT_XML_BLOB,
phKey: ?*BCRYPT_KEY_HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PFNCMFILTERPROC = fn(
pCertContext: ?*const CERT_CONTEXT,
param1: LPARAM,
param2: u32,
param3: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const PFNCMHOOKPROC = fn(
hwndDialog: ?HWND,
message: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) u32;
pub const CERT_SELECT_STRUCT_A = extern struct {
dwSize: u32,
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
pTemplateName: ?[*:0]const u8,
dwFlags: CERT_SELECT_STRUCT_FLAGS,
szTitle: ?[*:0]const u8,
cCertStore: u32,
arrayCertStore: ?*?*c_void,
szPurposeOid: ?[*:0]const u8,
cCertContext: u32,
arrayCertContext: ?*?*CERT_CONTEXT,
lCustData: LPARAM,
pfnHook: ?PFNCMHOOKPROC,
pfnFilter: ?PFNCMFILTERPROC,
szHelpFileName: ?[*:0]const u8,
dwHelpId: u32,
hprov: usize,
};
pub const CERT_SELECT_STRUCT_W = extern struct {
dwSize: u32,
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
pTemplateName: ?[*:0]const u16,
dwFlags: CERT_SELECT_STRUCT_FLAGS,
szTitle: ?[*:0]const u16,
cCertStore: u32,
arrayCertStore: ?*?*c_void,
szPurposeOid: ?[*:0]const u8,
cCertContext: u32,
arrayCertContext: ?*?*CERT_CONTEXT,
lCustData: LPARAM,
pfnHook: ?PFNCMHOOKPROC,
pfnFilter: ?PFNCMFILTERPROC,
szHelpFileName: ?[*:0]const u16,
dwHelpId: u32,
hprov: usize,
};
pub const CERT_VIEWPROPERTIES_STRUCT_A = extern struct {
dwSize: u32,
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
dwFlags: CERT_VIEWPROPERTIES_STRUCT_FLAGS,
szTitle: ?[*:0]const u8,
pCertContext: ?*const CERT_CONTEXT,
arrayPurposes: ?*?PSTR,
cArrayPurposes: u32,
cRootStores: u32,
rghstoreRoots: ?*?*c_void,
cStores: u32,
rghstoreCAs: ?*?*c_void,
cTrustStores: u32,
rghstoreTrust: ?*?*c_void,
hprov: usize,
lCustData: LPARAM,
dwPad: u32,
szHelpFileName: ?[*:0]const u8,
dwHelpId: u32,
nStartPage: u32,
cArrayPropSheetPages: u32,
arrayPropSheetPages: ?*PROPSHEETPAGEA,
};
pub const CERT_VIEWPROPERTIES_STRUCT_W = extern struct {
dwSize: u32,
hwndParent: ?HWND,
hInstance: ?HINSTANCE,
dwFlags: CERT_VIEWPROPERTIES_STRUCT_FLAGS,
szTitle: ?[*:0]const u16,
pCertContext: ?*const CERT_CONTEXT,
arrayPurposes: ?*?PSTR,
cArrayPurposes: u32,
cRootStores: u32,
rghstoreRoots: ?*?*c_void,
cStores: u32,
rghstoreCAs: ?*?*c_void,
cTrustStores: u32,
rghstoreTrust: ?*?*c_void,
hprov: usize,
lCustData: LPARAM,
dwPad: u32,
szHelpFileName: ?[*:0]const u16,
dwHelpId: u32,
nStartPage: u32,
cArrayPropSheetPages: u32,
arrayPropSheetPages: ?*PROPSHEETPAGEA,
};
pub const CMOID = extern struct {
szExtensionOID: ?[*:0]const u8,
dwTestOperation: u32,
pbTestData: ?*u8,
cbTestData: u32,
};
pub const CMFLTR = extern struct {
dwSize: u32,
cExtensionChecks: u32,
arrayExtensionChecks: ?*CMOID,
dwCheckingFlags: u32,
};
pub const PFNTRUSTHELPER = fn(
pCertContext: ?*const CERT_CONTEXT,
lCustData: LPARAM,
fLeafCertificate: BOOL,
pbTrustBlob: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const CERT_VERIFY_CERTIFICATE_TRUST = extern struct {
cbSize: u32,
pccert: ?*const CERT_CONTEXT,
dwFlags: u32,
dwIgnoreErr: u32,
pdwErrors: ?*u32,
pszUsageOid: ?PSTR,
hprov: usize,
cRootStores: u32,
rghstoreRoots: ?*?*c_void,
cStores: u32,
rghstoreCAs: ?*?*c_void,
cTrustStores: u32,
rghstoreTrust: ?*?*c_void,
lCustData: LPARAM,
pfnTrustHelper: ?PFNTRUSTHELPER,
pcChain: ?*u32,
prgChain: ?*?*?*CERT_CONTEXT,
prgdwErrors: ?*?*u32,
prgpbTrustInfo: ?*?*CRYPTOAPI_BLOB,
};
pub const CTL_MODIFY_REQUEST = extern struct {
pccert: ?*const CERT_CONTEXT,
dwOperation: CTL_MODIFY_REQUEST_OPERATION,
dwError: u32,
};
pub const PFNCFILTERPROC = fn(
pCertContext: ?*const CERT_CONTEXT,
pfInitialSelectedCert: ?*BOOL,
pvCallbackData: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const CERT_SELECTUI_INPUT = extern struct {
hStore: ?*c_void,
prgpChain: ?*?*CERT_CHAIN_CONTEXT,
cChain: u32,
};
pub const CRYPTUI_CERT_MGR_STRUCT = extern struct {
dwSize: u32,
hwndParent: ?HWND,
dwFlags: u32,
pwszTitle: ?[*:0]const u16,
pszInitUsageOID: ?[*:0]const u8,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO = extern struct {
dwSize: u32,
pGuidSubject: ?*Guid,
cbBlob: u32,
pbBlob: ?*u8,
pwszDisplayName: ?[*:0]const u16,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO = extern struct {
dwSize: u32,
cCertStore: u32,
rghCertStore: ?*?*c_void,
pFilterCallback: ?PFNCFILTERPROC,
pvCallbackData: ?*c_void,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO = extern struct {
dwSize: u32,
pwszPvkFileName: ?PWSTR,
pwszProvName: ?PWSTR,
dwProvType: u32,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO = extern struct {
dwSize: u32,
pwszSigningCertFileName: ?PWSTR,
dwPvkChoice: CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION,
Anonymous: extern union {
pPvkFileInfo: ?*CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO,
pPvkProvInfo: ?*CRYPT_KEY_PROV_INFO,
},
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO = extern struct {
dwSize: u32,
dwAttrFlags: CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE,
pwszDescription: ?[*:0]const u16,
pwszMoreInfoLocation: ?[*:0]const u16,
pszHashAlg: ?[*:0]const u8,
pwszSigningCertDisplayString: ?[*:0]const u16,
hAdditionalCertStore: ?*c_void,
psAuthenticated: ?*CRYPT_ATTRIBUTES,
psUnauthenticated: ?*CRYPT_ATTRIBUTES,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_INFO = extern struct {
dwSize: u32,
dwSubjectChoice: CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT,
Anonymous1: extern union {
pwszFileName: ?[*:0]const u16,
pSignBlobInfo: ?*CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO,
},
dwSigningCertChoice: CRYPTUI_WIZ_DIGITAL_SIGN,
Anonymous2: extern union {
pSigningCertContext: ?*const CERT_CONTEXT,
pSigningCertStore: ?*CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO,
pSigningCertPvkInfo: ?*CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO,
},
pwszTimestampURL: ?[*:0]const u16,
dwAdditionalCertChoice: CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE,
pSignExtInfo: ?*CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO,
};
pub const CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT = extern struct {
dwSize: u32,
cbBlob: u32,
pbBlob: ?*u8,
};
pub const CRYPTUI_INITDIALOG_STRUCT = extern struct {
lParam: LPARAM,
pCertContext: ?*const CERT_CONTEXT,
};
pub const CRYPTUI_VIEWCERTIFICATE_STRUCTW = extern struct {
dwSize: u32,
hwndParent: ?HWND,
dwFlags: CRYPTUI_VIEWCERTIFICATE_FLAGS,
szTitle: ?[*:0]const u16,
pCertContext: ?*const CERT_CONTEXT,
rgszPurposes: ?*?PSTR,
cPurposes: u32,
Anonymous: extern union {
pCryptProviderData: ?*const CRYPT_PROVIDER_DATA,
hWVTStateData: ?HANDLE,
},
fpCryptProviderDataTrustedUsage: BOOL,
idxSigner: u32,
idxCert: u32,
fCounterSigner: BOOL,
idxCounterSigner: u32,
cStores: u32,
rghStores: ?*?*c_void,
cPropSheetPages: u32,
rgPropSheetPages: ?*PROPSHEETPAGEW,
nStartPage: u32,
};
pub const CRYPTUI_VIEWCERTIFICATE_STRUCTA = extern struct {
dwSize: u32,
hwndParent: ?HWND,
dwFlags: CRYPTUI_VIEWCERTIFICATE_FLAGS,
szTitle: ?[*:0]const u8,
pCertContext: ?*const CERT_CONTEXT,
rgszPurposes: ?*?PSTR,
cPurposes: u32,
Anonymous: extern union {
pCryptProviderData: ?*const CRYPT_PROVIDER_DATA,
hWVTStateData: ?HANDLE,
},
fpCryptProviderDataTrustedUsage: BOOL,
idxSigner: u32,
idxCert: u32,
fCounterSigner: BOOL,
idxCounterSigner: u32,
cStores: u32,
rghStores: ?*?*c_void,
cPropSheetPages: u32,
rgPropSheetPages: ?*PROPSHEETPAGEA,
nStartPage: u32,
};
pub const CRYPTUI_WIZ_EXPORT_INFO = extern struct {
dwSize: u32,
pwszExportFileName: ?[*:0]const u16,
dwSubjectChoice: CRYPTUI_WIZ_EXPORT_SUBJECT,
Anonymous: extern union {
pCertContext: ?*const CERT_CONTEXT,
pCTLContext: ?*CTL_CONTEXT,
pCRLContext: ?*CRL_CONTEXT,
hCertStore: ?*c_void,
},
cStores: u32,
rghStores: ?*?*c_void,
};
pub const CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO = extern struct {
dwSize: u32,
dwExportFormat: CRYPTUI_WIZ_EXPORT_FORMAT,
fExportChain: BOOL,
fExportPrivateKeys: BOOL,
pwszPassword: ?[*:0]const u16,
fStrongEncryption: BOOL,
};
pub const CRYPTUI_WIZ_IMPORT_SRC_INFO = extern struct {
dwSize: u32,
dwSubjectChoice: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION,
Anonymous: extern union {
pwszFileName: ?[*:0]const u16,
pCertContext: ?*const CERT_CONTEXT,
pCTLContext: ?*CTL_CONTEXT,
pCRLContext: ?*CRL_CONTEXT,
hCertStore: ?*c_void,
},
dwFlags: CRYPT_KEY_FLAGS,
pwszPassword: ?[*:0]const u16,
};
//--------------------------------------------------------------------------------
// Section: Functions (385)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptAcquireContextA(
phProv: ?*usize,
szContainer: ?[*:0]const u8,
szProvider: ?[*:0]const u8,
dwProvType: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptAcquireContextW(
phProv: ?*usize,
szContainer: ?[*:0]const u16,
szProvider: ?[*:0]const u16,
dwProvType: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptReleaseContext(
hProv: usize,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGenKey(
hProv: usize,
Algid: u32,
dwFlags: CRYPT_KEY_FLAGS,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDeriveKey(
hProv: usize,
Algid: u32,
hBaseData: usize,
dwFlags: u32,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDestroyKey(
hKey: usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetKeyParam(
hKey: usize,
dwParam: CRYPT_KEY_PARAM_ID,
pbData: ?*const u8,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetKeyParam(
hKey: usize,
dwParam: CRYPT_KEY_PARAM_ID,
// TODO: what to do with BytesParamIndex 3?
pbData: ?*u8,
pdwDataLen: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetHashParam(
hHash: usize,
dwParam: CRYPT_SET_HASH_PARAM,
pbData: ?*const u8,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetHashParam(
hHash: usize,
dwParam: u32,
// TODO: what to do with BytesParamIndex 3?
pbData: ?*u8,
pdwDataLen: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetProvParam(
hProv: usize,
dwParam: CRYPT_SET_PROV_PARAM_ID,
pbData: ?*const u8,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetProvParam(
hProv: usize,
dwParam: u32,
// TODO: what to do with BytesParamIndex 3?
pbData: ?*u8,
pdwDataLen: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGenRandom(
hProv: usize,
dwLen: u32,
// TODO: what to do with BytesParamIndex 1?
pbBuffer: ?*u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetUserKey(
hProv: usize,
dwKeySpec: u32,
phUserKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptExportKey(
hKey: usize,
hExpKey: usize,
dwBlobType: u32,
dwFlags: CRYPT_KEY_FLAGS,
// TODO: what to do with BytesParamIndex 5?
pbData: ?*u8,
pdwDataLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptImportKey(
hProv: usize,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
dwDataLen: u32,
hPubKey: usize,
dwFlags: CRYPT_KEY_FLAGS,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptEncrypt(
hKey: usize,
hHash: usize,
Final: BOOL,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 6?
pbData: ?*u8,
pdwDataLen: ?*u32,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDecrypt(
hKey: usize,
hHash: usize,
Final: BOOL,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pbData: ?*u8,
pdwDataLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptCreateHash(
hProv: usize,
Algid: u32,
hKey: usize,
dwFlags: u32,
phHash: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptHashData(
hHash: usize,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
dwDataLen: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptHashSessionKey(
hHash: usize,
hKey: usize,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDestroyHash(
hHash: usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSignHashA(
hHash: usize,
dwKeySpec: u32,
szDescription: ?[*:0]const u8,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*u8,
pdwSigLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSignHashW(
hHash: usize,
dwKeySpec: u32,
szDescription: ?[*:0]const u16,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*u8,
pdwSigLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptVerifySignatureA(
hHash: usize,
// TODO: what to do with BytesParamIndex 2?
pbSignature: ?*const u8,
dwSigLen: u32,
hPubKey: usize,
szDescription: ?[*:0]const u8,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptVerifySignatureW(
hHash: usize,
// TODO: what to do with BytesParamIndex 2?
pbSignature: ?*const u8,
dwSigLen: u32,
hPubKey: usize,
szDescription: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetProviderA(
pszProvName: ?[*:0]const u8,
dwProvType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetProviderW(
pszProvName: ?[*:0]const u16,
dwProvType: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetProviderExA(
pszProvName: ?[*:0]const u8,
dwProvType: u32,
pdwReserved: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptSetProviderExW(
pszProvName: ?[*:0]const u16,
dwProvType: u32,
pdwReserved: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetDefaultProviderA(
dwProvType: u32,
pdwReserved: ?*u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 4?
pszProvName: ?PSTR,
pcbProvName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptGetDefaultProviderW(
dwProvType: u32,
pdwReserved: ?*u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 4?
pszProvName: ?PWSTR,
pcbProvName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptEnumProviderTypesA(
dwIndex: u32,
pdwReserved: ?*u32,
dwFlags: u32,
pdwProvType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
szTypeName: ?PSTR,
pcbTypeName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptEnumProviderTypesW(
dwIndex: u32,
pdwReserved: ?*u32,
dwFlags: u32,
pdwProvType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
szTypeName: ?PWSTR,
pcbTypeName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptEnumProvidersA(
dwIndex: u32,
pdwReserved: ?*u32,
dwFlags: u32,
pdwProvType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
szProvName: ?PSTR,
pcbProvName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptEnumProvidersW(
dwIndex: u32,
pdwReserved: ?*u32,
dwFlags: u32,
pdwProvType: ?*u32,
// TODO: what to do with BytesParamIndex 5?
szProvName: ?PWSTR,
pcbProvName: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptContextAddRef(
hProv: usize,
pdwReserved: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDuplicateKey(
hKey: usize,
pdwReserved: ?*u32,
dwFlags: u32,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "ADVAPI32" fn CryptDuplicateHash(
hHash: usize,
pdwReserved: ?*u32,
dwFlags: u32,
phHash: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptOpenAlgorithmProvider(
phAlgorithm: ?*BCRYPT_ALG_HANDLE,
pszAlgId: ?[*:0]const u16,
pszImplementation: ?[*:0]const u16,
dwFlags: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumAlgorithms(
dwAlgOperations: BCRYPT_OPERATION,
pAlgCount: ?*u32,
ppAlgList: ?*?*BCRYPT_ALGORITHM_IDENTIFIER,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumProviders(
pszAlgId: ?[*:0]const u16,
pImplCount: ?*u32,
ppImplList: ?*?*BCRYPT_PROVIDER_NAME,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptGetProperty(
hObject: ?*c_void,
pszProperty: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 3?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptSetProperty(
hObject: ?*c_void,
pszProperty: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 3?
pbInput: ?*u8,
cbInput: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptCloseAlgorithmProvider(
hAlgorithm: BCRYPT_ALG_HANDLE,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptFreeBuffer(
pvBuffer: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptGenerateSymmetricKey(
hAlgorithm: BCRYPT_ALG_HANDLE,
phKey: ?*BCRYPT_KEY_HANDLE,
pbKeyObject: ?*u8,
cbKeyObject: u32,
// TODO: what to do with BytesParamIndex 5?
pbSecret: ?*u8,
cbSecret: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptGenerateKeyPair(
hAlgorithm: BCRYPT_ALG_HANDLE,
phKey: ?*BCRYPT_KEY_HANDLE,
dwLength: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEncrypt(
hKey: BCRYPT_KEY_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbInput: ?*u8,
cbInput: u32,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbIV: ?*u8,
cbIV: u32,
// TODO: what to do with BytesParamIndex 7?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDecrypt(
hKey: BCRYPT_KEY_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbInput: ?*u8,
cbInput: u32,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbIV: ?*u8,
cbIV: u32,
// TODO: what to do with BytesParamIndex 7?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptExportKey(
hKey: BCRYPT_KEY_HANDLE,
hExportKey: BCRYPT_KEY_HANDLE,
pszBlobType: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 4?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptImportKey(
hAlgorithm: BCRYPT_ALG_HANDLE,
hImportKey: BCRYPT_KEY_HANDLE,
pszBlobType: ?[*:0]const u16,
phKey: ?*BCRYPT_KEY_HANDLE,
pbKeyObject: ?*u8,
cbKeyObject: u32,
// TODO: what to do with BytesParamIndex 7?
pbInput: ?*u8,
cbInput: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptImportKeyPair(
hAlgorithm: BCRYPT_ALG_HANDLE,
hImportKey: BCRYPT_KEY_HANDLE,
pszBlobType: ?[*:0]const u16,
phKey: ?*BCRYPT_KEY_HANDLE,
// TODO: what to do with BytesParamIndex 5?
pbInput: ?*u8,
cbInput: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDuplicateKey(
hKey: BCRYPT_KEY_HANDLE,
phNewKey: ?*BCRYPT_KEY_HANDLE,
pbKeyObject: ?*u8,
cbKeyObject: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptFinalizeKeyPair(
hKey: BCRYPT_KEY_HANDLE,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDestroyKey(
hKey: BCRYPT_KEY_HANDLE,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDestroySecret(
hSecret: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptSignHash(
hKey: BCRYPT_KEY_HANDLE,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 3?
pbInput: ?*u8,
cbInput: u32,
// TODO: what to do with BytesParamIndex 5?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptVerifySignature(
hKey: BCRYPT_KEY_HANDLE,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 3?
pbHash: ?*u8,
cbHash: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*u8,
cbSignature: u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptSecretAgreement(
hPrivKey: BCRYPT_KEY_HANDLE,
hPubKey: BCRYPT_KEY_HANDLE,
phAgreedSecret: ?*?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDeriveKey(
hSharedSecret: ?*c_void,
pwszKDF: ?[*:0]const u16,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 4?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows8.0'
pub extern "bcrypt" fn BCryptKeyDerivation(
hKey: BCRYPT_KEY_HANDLE,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 3?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptCreateHash(
hAlgorithm: BCRYPT_ALG_HANDLE,
phHash: ?*?*c_void,
pbHashObject: ?*u8,
cbHashObject: u32,
// TODO: what to do with BytesParamIndex 5?
pbSecret: ?*u8,
cbSecret: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptHashData(
hHash: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbInput: ?*u8,
cbInput: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptFinishHash(
hHash: ?*c_void,
pbOutput: ?*u8,
cbOutput: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows8.1'
pub extern "bcrypt" fn BCryptCreateMultiHash(
hAlgorithm: BCRYPT_ALG_HANDLE,
phHash: ?*?*c_void,
nHashes: u32,
pbHashObject: ?*u8,
cbHashObject: u32,
// TODO: what to do with BytesParamIndex 6?
pbSecret: ?*u8,
cbSecret: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows8.1'
pub extern "bcrypt" fn BCryptProcessMultiOperations(
hObject: ?*c_void,
operationType: BCRYPT_MULTI_OPERATION_TYPE,
// TODO: what to do with BytesParamIndex 3?
pOperations: ?*c_void,
cbOperations: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDuplicateHash(
hHash: ?*c_void,
phNewHash: ?*?*c_void,
pbHashObject: ?*u8,
cbHashObject: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDestroyHash(
hHash: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "bcrypt" fn BCryptHash(
hAlgorithm: BCRYPT_ALG_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbSecret: ?*u8,
cbSecret: u32,
// TODO: what to do with BytesParamIndex 4?
pbInput: ?*u8,
cbInput: u32,
pbOutput: ?*u8,
cbOutput: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptGenRandom(
hAlgorithm: BCRYPT_ALG_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbBuffer: ?*u8,
cbBuffer: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.1'
pub extern "bcrypt" fn BCryptDeriveKeyCapi(
hHash: ?*c_void,
hTargetAlg: BCRYPT_ALG_HANDLE,
// TODO: what to do with BytesParamIndex 3?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.1'
pub extern "bcrypt" fn BCryptDeriveKeyPBKDF2(
hPrf: BCRYPT_ALG_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbPassword: ?*u8,
cbPassword: u32,
// TODO: what to do with BytesParamIndex 4?
pbSalt: ?*u8,
cbSalt: u32,
cIterations: u64,
// TODO: what to do with BytesParamIndex 7?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptQueryProviderRegistration(
pszProvider: ?[*:0]const u16,
dwMode: BCRYPT_QUERY_PROVIDER_MODE,
dwInterface: BCRYPT_INTERFACE,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 3?
ppBuffer: ?*?*CRYPT_PROVIDER_REG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumRegisteredProviders(
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 0?
ppBuffer: ?*?*CRYPT_PROVIDERS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptCreateContext(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
pConfig: ?*CRYPT_CONTEXT_CONFIG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptDeleteContext(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumContexts(
dwTable: BCRYPT_TABLE,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 1?
ppBuffer: ?*?*CRYPT_CONTEXTS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptConfigureContext(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
pConfig: ?*CRYPT_CONTEXT_CONFIG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptQueryContextConfiguration(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 2?
ppBuffer: ?*?*CRYPT_CONTEXT_CONFIG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptAddContextFunction(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
dwPosition: u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptRemoveContextFunction(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumContextFunctions(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 3?
ppBuffer: ?*?*CRYPT_CONTEXT_FUNCTIONS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptConfigureContextFunction(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
pConfig: ?*CRYPT_CONTEXT_FUNCTION_CONFIG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptQueryContextFunctionConfiguration(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 4?
ppBuffer: ?*?*CRYPT_CONTEXT_FUNCTION_CONFIG,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptEnumContextFunctionProviders(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 4?
ppBuffer: ?*?*CRYPT_CONTEXT_FUNCTION_PROVIDERS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptSetContextFunctionProperty(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
pszProperty: ?[*:0]const u16,
cbValue: u32,
// TODO: what to do with BytesParamIndex 5?
pbValue: ?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptQueryContextFunctionProperty(
dwTable: BCRYPT_TABLE,
pszContext: ?[*:0]const u16,
dwInterface: BCRYPT_INTERFACE,
pszFunction: ?[*:0]const u16,
pszProperty: ?[*:0]const u16,
pcbValue: ?*u32,
// TODO: what to do with BytesParamIndex 5?
ppbValue: ?*?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptRegisterConfigChangeNotify(
phEvent: ?*?HANDLE,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptUnregisterConfigChangeNotify(
hEvent: ?HANDLE,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptResolveProviders(
pszContext: ?[*:0]const u16,
dwInterface: u32,
pszFunction: ?[*:0]const u16,
pszProvider: ?[*:0]const u16,
dwMode: BCRYPT_QUERY_PROVIDER_MODE,
dwFlags: BCRYPT_RESOLVE_PROVIDERS_FLAGS,
pcbBuffer: ?*u32,
// TODO: what to do with BytesParamIndex 6?
ppBuffer: ?*?*CRYPT_PROVIDER_REFS,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "bcrypt" fn BCryptGetFipsAlgorithmMode(
pfEnabled: ?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptOpenStorageProvider(
phProvider: ?*usize,
pszProviderName: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptEnumAlgorithms(
hProvider: usize,
dwAlgOperations: NCRYPT_OPERATION,
pdwAlgCount: ?*u32,
ppAlgList: ?*?*NCryptAlgorithmName,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptIsAlgSupported(
hProvider: usize,
pszAlgId: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptEnumKeys(
hProvider: usize,
pszScope: ?[*:0]const u16,
ppKeyName: ?*?*NCryptKeyName,
ppEnumState: ?*?*c_void,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptEnumStorageProviders(
pdwProviderCount: ?*u32,
ppProviderList: ?*?*NCryptProviderName,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptFreeBuffer(
pvInput: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
// This function from dll 'ncrypt' is being skipped because it has some sort of issue
pub fn NCryptOpenKey() void { @panic("this function is not working"); }
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptCreatePersistedKey(
hProvider: usize,
phKey: ?*usize,
pszAlgId: ?[*:0]const u16,
pszKeyName: ?[*:0]const u16,
dwLegacyKeySpec: CERT_KEY_SPEC,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptGetProperty(
hObject: usize,
pszProperty: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 3?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: OBJECT_SECURITY_INFORMATION,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptSetProperty(
hObject: usize,
pszProperty: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 3?
pbInput: ?*u8,
cbInput: u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptFinalizeKey(
hKey: usize,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptEncrypt(
hKey: usize,
// TODO: what to do with BytesParamIndex 2?
pbInput: ?*u8,
cbInput: u32,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptDecrypt(
hKey: usize,
// TODO: what to do with BytesParamIndex 2?
pbInput: ?*u8,
cbInput: u32,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptImportKey(
hProvider: usize,
hImportKey: usize,
pszBlobType: ?[*:0]const u16,
pParameterList: ?*BCryptBufferDesc,
phKey: ?*usize,
// TODO: what to do with BytesParamIndex 6?
pbData: ?*u8,
cbData: u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptExportKey(
hKey: usize,
hExportKey: usize,
pszBlobType: ?[*:0]const u16,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 5?
pbOutput: ?*u8,
cbOutput: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptSignHash(
hKey: usize,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 3?
pbHashValue: ?*u8,
cbHashValue: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*u8,
cbSignature: u32,
pcbResult: ?*u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptVerifySignature(
hKey: usize,
pPaddingInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 3?
pbHashValue: ?*u8,
cbHashValue: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignature: ?*u8,
cbSignature: u32,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptDeleteKey(
hKey: usize,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptFreeObject(
hObject: usize,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptIsKeyHandle(
hKey: usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
// This function from dll 'ncrypt' is being skipped because it has some sort of issue
pub fn NCryptTranslateHandle() void { @panic("this function is not working"); }
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptNotifyChangeKey(
hProvider: usize,
phEvent: ?*?HANDLE,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptSecretAgreement(
hPrivKey: usize,
hPubKey: usize,
phAgreedSecret: ?*usize,
dwFlags: NCRYPT_FLAGS,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "ncrypt" fn NCryptDeriveKey(
hSharedSecret: usize,
pwszKDF: ?[*:0]const u16,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 4?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptKeyDerivation(
hKey: usize,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 3?
pbDerivedKey: ?*u8,
cbDerivedKey: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "ncrypt" fn NCryptCreateClaim(
hSubjectKey: usize,
hAuthorityKey: usize,
dwClaimType: u32,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 5?
pbClaimBlob: ?*u8,
cbClaimBlob: u32,
pcbResult: ?*u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "ncrypt" fn NCryptVerifyClaim(
hSubjectKey: usize,
hAuthorityKey: usize,
dwClaimType: u32,
pParameterList: ?*BCryptBufferDesc,
// TODO: what to do with BytesParamIndex 5?
pbClaimBlob: ?*u8,
cbClaimBlob: u32,
pOutput: ?*BCryptBufferDesc,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptFormatObject(
dwCertEncodingType: u32,
dwFormatType: u32,
dwFormatStrType: u32,
pFormatStruct: ?*c_void,
lpszStructType: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 6?
pbEncoded: ?*const u8,
cbEncoded: u32,
// TODO: what to do with BytesParamIndex 8?
pbFormat: ?*c_void,
pcbFormat: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEncodeObjectEx(
dwCertEncodingType: CERT_QUERY_ENCODING_TYPE,
lpszStructType: ?[*:0]const u8,
pvStructInfo: ?*const c_void,
dwFlags: CRYPT_ENCODE_OBJECT_FLAGS,
pEncodePara: ?*CRYPT_ENCODE_PARA,
pvEncoded: ?*c_void,
pcbEncoded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEncodeObject(
dwCertEncodingType: u32,
lpszStructType: ?[*:0]const u8,
pvStructInfo: ?*const c_void,
// TODO: what to do with BytesParamIndex 4?
pbEncoded: ?*u8,
pcbEncoded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptDecodeObjectEx(
dwCertEncodingType: u32,
lpszStructType: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 3?
pbEncoded: ?*const u8,
cbEncoded: u32,
dwFlags: u32,
pDecodePara: ?*CRYPT_DECODE_PARA,
pvStructInfo: ?*c_void,
pcbStructInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptDecodeObject(
dwCertEncodingType: u32,
lpszStructType: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 3?
pbEncoded: ?*const u8,
cbEncoded: u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 6?
pvStructInfo: ?*c_void,
pcbStructInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptInstallOIDFunctionAddress(
hModule: ?HINSTANCE,
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
cFuncEntry: u32,
rgFuncEntry: [*]const CRYPT_OID_FUNC_ENTRY,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptInitOIDFunctionSet(
pszFuncName: ?[*:0]const u8,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetOIDFunctionAddress(
hFuncSet: ?*c_void,
dwEncodingType: u32,
pszOID: ?[*:0]const u8,
dwFlags: u32,
ppvFuncAddr: ?*?*c_void,
phFuncAddr: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetDefaultOIDDllList(
hFuncSet: ?*c_void,
dwEncodingType: u32,
pwszDllList: ?[*:0]u16,
pcchDllList: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetDefaultOIDFunctionAddress(
hFuncSet: ?*c_void,
dwEncodingType: u32,
pwszDll: ?[*:0]const u16,
dwFlags: u32,
ppvFuncAddr: ?*?*c_void,
phFuncAddr: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptFreeOIDFunctionAddress(
hFuncAddr: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptRegisterOIDFunction(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
pwszDll: ?[*:0]const u16,
pszOverrideFuncName: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptUnregisterOIDFunction(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptRegisterDefaultOIDFunction(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
dwIndex: u32,
pwszDll: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptUnregisterDefaultOIDFunction(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pwszDll: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSetOIDFunctionValue(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
pwszValueName: ?[*:0]const u16,
dwValueType: REG_VALUE_TYPE,
// TODO: what to do with BytesParamIndex 6?
pbValueData: ?*const u8,
cbValueData: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetOIDFunctionValue(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
pwszValueName: ?[*:0]const u16,
pdwValueType: ?*u32,
// TODO: what to do with BytesParamIndex 6?
pbValueData: ?*u8,
pcbValueData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEnumOIDFunction(
dwEncodingType: u32,
pszFuncName: ?[*:0]const u8,
pszOID: ?[*:0]const u8,
dwFlags: u32,
pvArg: ?*c_void,
pfnEnumOIDFunc: ?PFN_CRYPT_ENUM_OID_FUNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptFindOIDInfo(
dwKeyType: u32,
pvKey: ?*c_void,
dwGroupId: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CRYPT_OID_INFO;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptRegisterOIDInfo(
pInfo: ?*CRYPT_OID_INFO,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptUnregisterOIDInfo(
pInfo: ?*CRYPT_OID_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEnumOIDInfo(
dwGroupId: u32,
dwFlags: u32,
pvArg: ?*c_void,
pfnEnumOIDInfo: ?PFN_CRYPT_ENUM_OID_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptFindLocalizedName(
pwszCryptName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgOpenToEncode(
dwMsgEncodingType: u32,
dwFlags: u32,
dwMsgType: CRYPT_MSG_TYPE,
pvMsgEncodeInfo: ?*const c_void,
pszInnerContentObjID: ?PSTR,
pStreamInfo: ?*CMSG_STREAM_INFO,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgCalculateEncodedLength(
dwMsgEncodingType: u32,
dwFlags: u32,
dwMsgType: u32,
pvMsgEncodeInfo: ?*const c_void,
pszInnerContentObjID: ?PSTR,
cbData: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgOpenToDecode(
dwMsgEncodingType: u32,
dwFlags: u32,
dwMsgType: u32,
hCryptProv: usize,
pRecipientInfo: ?*CERT_INFO,
pStreamInfo: ?*CMSG_STREAM_INFO,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgDuplicate(
hCryptMsg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgClose(
hCryptMsg: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgUpdate(
hCryptMsg: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: u32,
fFinal: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgGetParam(
hCryptMsg: ?*c_void,
dwParamType: u32,
dwIndex: u32,
// TODO: what to do with BytesParamIndex 4?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgControl(
hCryptMsg: ?*c_void,
dwFlags: u32,
dwCtrlType: u32,
pvCtrlPara: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgVerifyCountersignatureEncoded(
hCryptProv: usize,
dwEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbSignerInfo: ?*u8,
cbSignerInfo: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignerInfoCountersignature: ?*u8,
cbSignerInfoCountersignature: u32,
pciCountersigner: ?*CERT_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgVerifyCountersignatureEncodedEx(
hCryptProv: usize,
dwEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbSignerInfo: ?*u8,
cbSignerInfo: u32,
// TODO: what to do with BytesParamIndex 5?
pbSignerInfoCountersignature: ?*u8,
cbSignerInfoCountersignature: u32,
dwSignerType: u32,
pvSigner: ?*c_void,
dwFlags: u32,
pvExtra: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgCountersign(
hCryptMsg: ?*c_void,
dwIndex: u32,
cCountersigners: u32,
rgCountersigners: [*]CMSG_SIGNER_ENCODE_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgCountersignEncoded(
dwEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbSignerInfo: ?*u8,
cbSignerInfo: u32,
cCountersigners: u32,
rgCountersigners: [*]CMSG_SIGNER_ENCODE_INFO,
// TODO: what to do with BytesParamIndex 6?
pbCountersignature: ?*u8,
pcbCountersignature: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertOpenStore(
lpszStoreProvider: ?[*:0]const u8,
dwEncodingType: CERT_QUERY_ENCODING_TYPE,
hCryptProv: usize,
dwFlags: CERT_OPEN_STORE_FLAGS,
pvPara: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDuplicateStore(
hCertStore: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSaveStore(
hCertStore: ?*c_void,
dwEncodingType: CERT_QUERY_ENCODING_TYPE,
dwSaveAs: CERT_STORE_SAVE_AS,
dwSaveTo: CERT_STORE_SAVE_TO,
pvSaveToPara: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCloseStore(
hCertStore: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetSubjectCertificateFromStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
pCertId: ?*CERT_INFO,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCertificatesInStore(
hCertStore: ?*c_void,
pPrevCertContext: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindCertificateInStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
dwFindFlags: u32,
dwFindType: CERT_FIND_FLAGS,
pvFindPara: ?*const c_void,
pPrevCertContext: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetIssuerCertificateFromStore(
hCertStore: ?*c_void,
pSubjectContext: ?*const CERT_CONTEXT,
pPrevIssuerContext: ?*const CERT_CONTEXT,
pdwFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifySubjectCertificateContext(
pSubject: ?*const CERT_CONTEXT,
pIssuer: ?*const CERT_CONTEXT,
pdwFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDuplicateCertificateContext(
pCertContext: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateCertificateContext(
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbCertEncoded: ?*const u8,
cbCertEncoded: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFreeCertificateContext(
pCertContext: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetCertificateContextProperty(
pCertContext: ?*const CERT_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetCertificateContextProperty(
pCertContext: ?*const CERT_CONTEXT,
dwPropId: u32,
// TODO: what to do with BytesParamIndex 3?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCertificateContextProperties(
pCertContext: ?*const CERT_CONTEXT,
dwPropId: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateCTLEntryFromCertificateContextProperties(
pCertContext: ?*const CERT_CONTEXT,
cOptAttr: u32,
rgOptAttr: ?[*]CRYPT_ATTRIBUTE,
dwFlags: u32,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pCtlEntry: ?*CTL_ENTRY,
pcbCtlEntry: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetCertificateContextPropertiesFromCTLEntry(
pCertContext: ?*const CERT_CONTEXT,
pCtlEntry: ?*CTL_ENTRY,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetCRLFromStore(
hCertStore: ?*c_void,
pIssuerContext: ?*const CERT_CONTEXT,
pPrevCrlContext: ?*CRL_CONTEXT,
pdwFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) ?*CRL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCRLsInStore(
hCertStore: ?*c_void,
pPrevCrlContext: ?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CRL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindCRLInStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
dwFindFlags: u32,
dwFindType: u32,
pvFindPara: ?*const c_void,
pPrevCrlContext: ?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CRL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDuplicateCRLContext(
pCrlContext: ?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CRL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateCRLContext(
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbCrlEncoded: ?*const u8,
cbCrlEncoded: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CRL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFreeCRLContext(
pCrlContext: ?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetCRLContextProperty(
pCrlContext: ?*CRL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetCRLContextProperty(
pCrlContext: ?*CRL_CONTEXT,
dwPropId: u32,
// TODO: what to do with BytesParamIndex 3?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCRLContextProperties(
pCrlContext: ?*CRL_CONTEXT,
dwPropId: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindCertificateInCRL(
pCert: ?*const CERT_CONTEXT,
pCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
pvReserved: ?*c_void,
ppCrlEntry: ?*?*CRL_ENTRY,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertIsValidCRLForCertificate(
pCert: ?*const CERT_CONTEXT,
pCrl: ?*CRL_CONTEXT,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEncodedCertificateToStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbCertEncoded: ?*const u8,
cbCertEncoded: u32,
dwAddDisposition: u32,
ppCertContext: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCertificateContextToStore(
hCertStore: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddSerializedElementToStore(
hCertStore: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbElement: ?*const u8,
cbElement: u32,
dwAddDisposition: u32,
dwFlags: u32,
dwContextTypeFlags: u32,
pdwContextType: ?*u32,
ppvContext: ?*const ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDeleteCertificateFromStore(
pCertContext: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEncodedCRLToStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbCrlEncoded: ?*const u8,
cbCrlEncoded: u32,
dwAddDisposition: u32,
ppCrlContext: ?*?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCRLContextToStore(
hCertStore: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDeleteCRLFromStore(
pCrlContext: ?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSerializeCertificateStoreElement(
pCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 3?
pbElement: ?*u8,
pcbElement: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSerializeCRLStoreElement(
pCrlContext: ?*CRL_CONTEXT,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 3?
pbElement: ?*u8,
pcbElement: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDuplicateCTLContext(
pCtlContext: ?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CTL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateCTLContext(
dwMsgAndCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbCtlEncoded: ?*const u8,
cbCtlEncoded: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CTL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFreeCTLContext(
pCtlContext: ?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetCTLContextProperty(
pCtlContext: ?*CTL_CONTEXT,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetCTLContextProperty(
pCtlContext: ?*CTL_CONTEXT,
dwPropId: u32,
// TODO: what to do with BytesParamIndex 3?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCTLContextProperties(
pCtlContext: ?*CTL_CONTEXT,
dwPropId: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumCTLsInStore(
hCertStore: ?*c_void,
pPrevCtlContext: ?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CTL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindSubjectInCTL(
dwEncodingType: u32,
dwSubjectType: u32,
pvSubject: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CTL_ENTRY;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindCTLInStore(
hCertStore: ?*c_void,
dwMsgAndCertEncodingType: u32,
dwFindFlags: u32,
dwFindType: CERT_FIND_TYPE,
pvFindPara: ?*const c_void,
pPrevCtlContext: ?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CTL_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEncodedCTLToStore(
hCertStore: ?*c_void,
dwMsgAndCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbCtlEncoded: ?*const u8,
cbCtlEncoded: u32,
dwAddDisposition: u32,
ppCtlContext: ?*?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCTLContextToStore(
hCertStore: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSerializeCTLStoreElement(
pCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 3?
pbElement: ?*u8,
pcbElement: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDeleteCTLFromStore(
pCtlContext: ?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCertificateLinkToStore(
hCertStore: ?*c_void,
pCertContext: ?*const CERT_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCRLLinkToStore(
hCertStore: ?*c_void,
pCrlContext: ?*CRL_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CRL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddCTLLinkToStore(
hCertStore: ?*c_void,
pCtlContext: ?*CTL_CONTEXT,
dwAddDisposition: u32,
ppStoreContext: ?*?*CTL_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddStoreToCollection(
hCollectionStore: ?*c_void,
hSiblingStore: ?*c_void,
dwUpdateFlags: u32,
dwPriority: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRemoveStoreFromCollection(
hCollectionStore: ?*c_void,
hSiblingStore: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertControlStore(
hCertStore: ?*c_void,
dwFlags: CERT_CONTROL_STORE_FLAGS,
dwCtrlType: u32,
pvCtrlPara: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetStoreProperty(
hCertStore: ?*c_void,
dwPropId: u32,
dwFlags: u32,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetStoreProperty(
hCertStore: ?*c_void,
dwPropId: u32,
// TODO: what to do with BytesParamIndex 3?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateContext(
dwContextType: u32,
dwEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbEncoded: ?*const u8,
cbEncoded: u32,
dwFlags: u32,
pCreatePara: ?*CERT_CREATE_CONTEXT_PARA,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRegisterSystemStore(
pvSystemStore: ?*const c_void,
dwFlags: u32,
pStoreInfo: ?*CERT_SYSTEM_STORE_INFO,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRegisterPhysicalStore(
pvSystemStore: ?*const c_void,
dwFlags: u32,
pwszStoreName: ?[*:0]const u16,
pStoreInfo: ?*CERT_PHYSICAL_STORE_INFO,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertUnregisterSystemStore(
pvSystemStore: ?*const c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertUnregisterPhysicalStore(
pvSystemStore: ?*const c_void,
dwFlags: u32,
pwszStoreName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumSystemStoreLocation(
dwFlags: u32,
pvArg: ?*c_void,
pfnEnum: ?PFN_CERT_ENUM_SYSTEM_STORE_LOCATION,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumSystemStore(
dwFlags: u32,
pvSystemStoreLocationPara: ?*c_void,
pvArg: ?*c_void,
pfnEnum: ?PFN_CERT_ENUM_SYSTEM_STORE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumPhysicalStore(
pvSystemStore: ?*const c_void,
dwFlags: u32,
pvArg: ?*c_void,
pfnEnum: ?PFN_CERT_ENUM_PHYSICAL_STORE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetEnhancedKeyUsage(
pCertContext: ?*const CERT_CONTEXT,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 3?
pUsage: ?*CTL_USAGE,
pcbUsage: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertSetEnhancedKeyUsage(
pCertContext: ?*const CERT_CONTEXT,
pUsage: ?*CTL_USAGE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEnhancedKeyUsageIdentifier(
pCertContext: ?*const CERT_CONTEXT,
pszUsageIdentifier: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRemoveEnhancedKeyUsageIdentifier(
pCertContext: ?*const CERT_CONTEXT,
pszUsageIdentifier: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetValidUsages(
cCerts: u32,
rghCerts: [*]?*CERT_CONTEXT,
cNumOIDs: ?*i32,
// TODO: what to do with BytesParamIndex 4?
rghOIDs: ?*?PSTR,
pcbOIDs: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgGetAndVerifySigner(
hCryptMsg: ?*c_void,
cSignerStore: u32,
rghSignerStore: ?[*]?*c_void,
dwFlags: u32,
ppSigner: ?*?*CERT_CONTEXT,
pdwSignerIndex: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgSignCTL(
dwMsgEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbCtlContent: ?*u8,
cbCtlContent: u32,
pSignInfo: ?*CMSG_SIGNED_ENCODE_INFO,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 6?
pbEncoded: ?*u8,
pcbEncoded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMsgEncodeAndSignCTL(
dwMsgEncodingType: u32,
pCtlInfo: ?*CTL_INFO,
pSignInfo: ?*CMSG_SIGNED_ENCODE_INFO,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 5?
pbEncoded: ?*u8,
pcbEncoded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindSubjectInSortedCTL(
pSubjectIdentifier: ?*CRYPTOAPI_BLOB,
pCtlContext: ?*CTL_CONTEXT,
dwFlags: u32,
pvReserved: ?*c_void,
pEncodedAttributes: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertEnumSubjectInSortedCTL(
pCtlContext: ?*CTL_CONTEXT,
ppvNextSubject: ?*?*c_void,
pSubjectIdentifier: ?*CRYPTOAPI_BLOB,
pEncodedAttributes: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyCTLUsage(
dwEncodingType: u32,
dwSubjectType: u32,
pvSubject: ?*c_void,
pSubjectUsage: ?*CTL_USAGE,
dwFlags: u32,
pVerifyUsagePara: ?*CTL_VERIFY_USAGE_PARA,
pVerifyUsageStatus: ?*CTL_VERIFY_USAGE_STATUS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyRevocation(
dwEncodingType: u32,
dwRevType: u32,
cContext: u32,
rgpvContext: [*]?*c_void,
dwFlags: u32,
pRevPara: ?*CERT_REVOCATION_PARA,
pRevStatus: ?*CERT_REVOCATION_STATUS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCompareIntegerBlob(
pInt1: ?*CRYPTOAPI_BLOB,
pInt2: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCompareCertificate(
dwCertEncodingType: u32,
pCertId1: ?*CERT_INFO,
pCertId2: ?*CERT_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCompareCertificateName(
dwCertEncodingType: u32,
pCertName1: ?*CRYPTOAPI_BLOB,
pCertName2: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertIsRDNAttrsInCertificateName(
dwCertEncodingType: u32,
dwFlags: u32,
pCertName: ?*CRYPTOAPI_BLOB,
pRDN: ?*CERT_RDN,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertComparePublicKeyInfo(
dwCertEncodingType: u32,
pPublicKey1: ?*CERT_PUBLIC_KEY_INFO,
pPublicKey2: ?*CERT_PUBLIC_KEY_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetPublicKeyLength(
dwCertEncodingType: u32,
pPublicKey: ?*CERT_PUBLIC_KEY_INFO,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyCertificateSignature(
hCryptProv: usize,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbEncoded: ?*const u8,
cbEncoded: u32,
pPublicKey: ?*CERT_PUBLIC_KEY_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyCertificateSignatureEx(
hCryptProv: usize,
dwCertEncodingType: u32,
dwSubjectType: u32,
pvSubject: ?*c_void,
dwIssuerType: u32,
pvIssuer: ?*c_void,
dwFlags: CRYPT_VERIFY_CERT_FLAGS,
pvExtra: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "CRYPT32" fn CertIsStrongHashToSign(
pStrongSignPara: ?*CERT_STRONG_SIGN_PARA,
pwszCNGHashAlgid: ?[*:0]const u16,
pSigningCert: ?*const CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptHashToBeSigned(
hCryptProv: usize,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 3?
pbEncoded: ?*const u8,
cbEncoded: u32,
// TODO: what to do with BytesParamIndex 5?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptHashCertificate(
hCryptProv: usize,
Algid: u32,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 4?
pbEncoded: ?*const u8,
cbEncoded: u32,
// TODO: what to do with BytesParamIndex 6?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CryptHashCertificate2(
pwszCNGHashAlgid: ?[*:0]const u16,
dwFlags: u32,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 4?
pbEncoded: ?*const u8,
cbEncoded: u32,
// TODO: what to do with BytesParamIndex 6?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSignCertificate(
hCryptProvOrNCryptKey: usize,
dwKeySpec: u32,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 4?
pbEncodedToBeSigned: ?*const u8,
cbEncodedToBeSigned: u32,
pSignatureAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pvHashAuxInfo: ?*const c_void,
// TODO: what to do with BytesParamIndex 8?
pbSignature: ?*u8,
pcbSignature: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
// This function from dll 'CRYPT32' is being skipped because it has some sort of issue
pub fn CryptSignAndEncodeCertificate() void { @panic("this function is not working"); }
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyTimeValidity(
pTimeToVerify: ?*FILETIME,
pCertInfo: ?*CERT_INFO,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyCRLTimeValidity(
pTimeToVerify: ?*FILETIME,
pCrlInfo: ?*CRL_INFO,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyValidityNesting(
pSubjectInfo: ?*CERT_INFO,
pIssuerInfo: ?*CERT_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyCRLRevocation(
dwCertEncodingType: u32,
pCertId: ?*CERT_INFO,
cCrlInfo: u32,
rgpCrlInfo: [*]?*CRL_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAlgIdToOID(
dwAlgId: u32,
) callconv(@import("std").os.windows.WINAPI) ?PSTR;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertOIDToAlgId(
pszObjId: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindExtension(
pszObjId: ?[*:0]const u8,
cExtensions: u32,
rgExtensions: [*]CERT_EXTENSION,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_EXTENSION;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindAttribute(
pszObjId: ?[*:0]const u8,
cAttr: u32,
rgAttr: [*]CRYPT_ATTRIBUTE,
) callconv(@import("std").os.windows.WINAPI) ?*CRYPT_ATTRIBUTE;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindRDNAttr(
pszObjId: ?[*:0]const u8,
pName: ?*CERT_NAME_INFO,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_RDN_ATTR;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetIntendedKeyUsage(
dwCertEncodingType: u32,
pCertInfo: ?*CERT_INFO,
pbKeyUsage: ?*u8,
cbKeyUsage: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptInstallDefaultContext(
hCryptProv: usize,
dwDefaultType: CRYPT_DEFAULT_CONTEXT_TYPE,
pvDefaultPara: ?*const c_void,
dwFlags: CRYPT_DEFAULT_CONTEXT_FLAGS,
pvReserved: ?*c_void,
phDefaultContext: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptUninstallDefaultContext(
hDefaultContext: ?*c_void,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptExportPublicKeyInfo(
hCryptProvOrNCryptKey: usize,
dwKeySpec: u32,
dwCertEncodingType: u32,
// TODO: what to do with BytesParamIndex 4?
pInfo: ?*CERT_PUBLIC_KEY_INFO,
pcbInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptExportPublicKeyInfoEx(
hCryptProvOrNCryptKey: usize,
dwKeySpec: u32,
dwCertEncodingType: u32,
pszPublicKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 7?
pInfo: ?*CERT_PUBLIC_KEY_INFO,
pcbInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPT32" fn CryptExportPublicKeyInfoFromBCryptKeyHandle(
hBCryptKey: BCRYPT_KEY_HANDLE,
dwCertEncodingType: u32,
pszPublicKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pInfo: ?*CERT_PUBLIC_KEY_INFO,
pcbInfo: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptImportPublicKeyInfo(
hCryptProv: usize,
dwCertEncodingType: u32,
pInfo: ?*CERT_PUBLIC_KEY_INFO,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptImportPublicKeyInfoEx(
hCryptProv: usize,
dwCertEncodingType: u32,
pInfo: ?*CERT_PUBLIC_KEY_INFO,
aiKeyAlg: u32,
dwFlags: u32,
pvAuxInfo: ?*c_void,
phKey: ?*usize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CryptImportPublicKeyInfoEx2(
dwCertEncodingType: u32,
pInfo: ?*CERT_PUBLIC_KEY_INFO,
dwFlags: CRYPT_IMPORT_PUBLIC_KEY_FLAGS,
pvAuxInfo: ?*c_void,
phKey: ?*BCRYPT_KEY_HANDLE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptAcquireCertificatePrivateKey(
pCert: ?*const CERT_CONTEXT,
dwFlags: CRYPT_ACQUIRE_FLAGS,
pvParameters: ?*c_void,
phCryptProvOrNCryptKey: ?*usize,
pdwKeySpec: ?*CERT_KEY_SPEC,
pfCallerFreeProvOrNCryptKey: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptFindCertificateKeyProvInfo(
pCert: ?*const CERT_CONTEXT,
dwFlags: CRYPT_FIND_FLAGS,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptImportPKCS8(
sPrivateKeyAndParams: CRYPT_PKCS8_IMPORT_PARAMS,
dwFlags: CRYPT_KEY_FLAGS,
phCryptProv: ?*usize,
pvAuxInfo: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptExportPKCS8(
hCryptProv: usize,
dwKeySpec: u32,
pszPrivateKeyObjId: ?PSTR,
dwFlags: u32,
pvAuxInfo: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pbPrivateKeyBlob: ?*u8,
pcbPrivateKeyBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptHashPublicKeyInfo(
hCryptProv: usize,
Algid: u32,
dwFlags: u32,
dwCertEncodingType: u32,
pInfo: ?*CERT_PUBLIC_KEY_INFO,
// TODO: what to do with BytesParamIndex 6?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRDNValueToStrA(
dwValueType: u32,
pValue: ?*CRYPTOAPI_BLOB,
psz: ?[*:0]u8,
csz: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertRDNValueToStrW(
dwValueType: u32,
pValue: ?*CRYPTOAPI_BLOB,
psz: ?[*:0]u16,
csz: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertNameToStrA(
dwCertEncodingType: u32,
pName: ?*CRYPTOAPI_BLOB,
dwStrType: CERT_STRING_TYPE,
psz: ?[*:0]u8,
csz: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertNameToStrW(
dwCertEncodingType: u32,
pName: ?*CRYPTOAPI_BLOB,
dwStrType: CERT_STRING_TYPE,
psz: ?[*:0]u16,
csz: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertStrToNameA(
dwCertEncodingType: u32,
pszX500: ?[*:0]const u8,
dwStrType: CERT_STRING_TYPE,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbEncoded: ?*u8,
pcbEncoded: ?*u32,
ppszError: ?*?PSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertStrToNameW(
dwCertEncodingType: u32,
pszX500: ?[*:0]const u16,
dwStrType: CERT_STRING_TYPE,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 5?
pbEncoded: ?*u8,
pcbEncoded: ?*u32,
ppszError: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetNameStringA(
pCertContext: ?*const CERT_CONTEXT,
dwType: u32,
dwFlags: u32,
pvTypePara: ?*c_void,
pszNameString: ?[*:0]u8,
cchNameString: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetNameStringW(
pCertContext: ?*const CERT_CONTEXT,
dwType: u32,
dwFlags: u32,
pvTypePara: ?*c_void,
pszNameString: ?[*:0]u16,
cchNameString: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSignMessage(
pSignPara: ?*CRYPT_SIGN_MESSAGE_PARA,
fDetachedSignature: BOOL,
cToBeSigned: u32,
rgpbToBeSigned: ?[*]const ?*const u8,
rgcbToBeSigned: [*]u32,
// TODO: what to do with BytesParamIndex 6?
pbSignedBlob: ?*u8,
pcbSignedBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyMessageSignature(
pVerifyPara: ?*CRYPT_VERIFY_MESSAGE_PARA,
dwSignerIndex: u32,
// TODO: what to do with BytesParamIndex 3?
pbSignedBlob: ?*const u8,
cbSignedBlob: u32,
// TODO: what to do with BytesParamIndex 5?
pbDecoded: ?*u8,
pcbDecoded: ?*u32,
ppSignerCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetMessageSignerCount(
dwMsgEncodingType: u32,
// TODO: what to do with BytesParamIndex 2?
pbSignedBlob: ?*const u8,
cbSignedBlob: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetMessageCertificates(
dwMsgAndCertEncodingType: u32,
hCryptProv: usize,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 4?
pbSignedBlob: ?*const u8,
cbSignedBlob: u32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyDetachedMessageSignature(
pVerifyPara: ?*CRYPT_VERIFY_MESSAGE_PARA,
dwSignerIndex: u32,
// TODO: what to do with BytesParamIndex 3?
pbDetachedSignBlob: ?*const u8,
cbDetachedSignBlob: u32,
cToBeSigned: u32,
rgpbToBeSigned: [*]const ?*const u8,
rgcbToBeSigned: [*]u32,
ppSignerCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEncryptMessage(
pEncryptPara: ?*CRYPT_ENCRYPT_MESSAGE_PARA,
cRecipientCert: u32,
rgpRecipientCert: [*]?*CERT_CONTEXT,
// TODO: what to do with BytesParamIndex 4?
pbToBeEncrypted: ?*const u8,
cbToBeEncrypted: u32,
// TODO: what to do with BytesParamIndex 6?
pbEncryptedBlob: ?*u8,
pcbEncryptedBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptDecryptMessage(
pDecryptPara: ?*CRYPT_DECRYPT_MESSAGE_PARA,
// TODO: what to do with BytesParamIndex 2?
pbEncryptedBlob: ?*const u8,
cbEncryptedBlob: u32,
// TODO: what to do with BytesParamIndex 4?
pbDecrypted: ?*u8,
pcbDecrypted: ?*u32,
ppXchgCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSignAndEncryptMessage(
pSignPara: ?*CRYPT_SIGN_MESSAGE_PARA,
pEncryptPara: ?*CRYPT_ENCRYPT_MESSAGE_PARA,
cRecipientCert: u32,
rgpRecipientCert: [*]?*CERT_CONTEXT,
// TODO: what to do with BytesParamIndex 5?
pbToBeSignedAndEncrypted: ?*const u8,
cbToBeSignedAndEncrypted: u32,
// TODO: what to do with BytesParamIndex 7?
pbSignedAndEncryptedBlob: ?*u8,
pcbSignedAndEncryptedBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptDecryptAndVerifyMessageSignature(
pDecryptPara: ?*CRYPT_DECRYPT_MESSAGE_PARA,
pVerifyPara: ?*CRYPT_VERIFY_MESSAGE_PARA,
dwSignerIndex: u32,
// TODO: what to do with BytesParamIndex 4?
pbEncryptedBlob: ?*const u8,
cbEncryptedBlob: u32,
// TODO: what to do with BytesParamIndex 6?
pbDecrypted: ?*u8,
pcbDecrypted: ?*u32,
ppXchgCert: ?*?*CERT_CONTEXT,
ppSignerCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptDecodeMessage(
dwMsgTypeFlags: u32,
pDecryptPara: ?*CRYPT_DECRYPT_MESSAGE_PARA,
pVerifyPara: ?*CRYPT_VERIFY_MESSAGE_PARA,
dwSignerIndex: u32,
// TODO: what to do with BytesParamIndex 5?
pbEncodedBlob: ?*const u8,
cbEncodedBlob: u32,
dwPrevInnerContentType: u32,
pdwMsgType: ?*u32,
pdwInnerContentType: ?*u32,
// TODO: what to do with BytesParamIndex 10?
pbDecoded: ?*u8,
pcbDecoded: ?*u32,
ppXchgCert: ?*?*CERT_CONTEXT,
ppSignerCert: ?*?*CERT_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptHashMessage(
pHashPara: ?*CRYPT_HASH_MESSAGE_PARA,
fDetachedHash: BOOL,
cToBeHashed: u32,
rgpbToBeHashed: [*]const ?*const u8,
rgcbToBeHashed: [*]u32,
// TODO: what to do with BytesParamIndex 6?
pbHashedBlob: ?*u8,
pcbHashedBlob: ?*u32,
// TODO: what to do with BytesParamIndex 8?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyMessageHash(
pHashPara: ?*CRYPT_HASH_MESSAGE_PARA,
// TODO: what to do with BytesParamIndex 2?
pbHashedBlob: ?*u8,
cbHashedBlob: u32,
// TODO: what to do with BytesParamIndex 4?
pbToBeHashed: ?*u8,
pcbToBeHashed: ?*u32,
// TODO: what to do with BytesParamIndex 6?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyDetachedMessageHash(
pHashPara: ?*CRYPT_HASH_MESSAGE_PARA,
// TODO: what to do with BytesParamIndex 2?
pbDetachedHashBlob: ?*u8,
cbDetachedHashBlob: u32,
cToBeHashed: u32,
rgpbToBeHashed: [*]const ?*const u8,
rgcbToBeHashed: [*]u32,
// TODO: what to do with BytesParamIndex 7?
pbComputedHash: ?*u8,
pcbComputedHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSignMessageWithKey(
pSignPara: ?*CRYPT_KEY_SIGN_MESSAGE_PARA,
// TODO: what to do with BytesParamIndex 2?
pbToBeSigned: ?*const u8,
cbToBeSigned: u32,
// TODO: what to do with BytesParamIndex 4?
pbSignedBlob: ?*u8,
pcbSignedBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptVerifyMessageSignatureWithKey(
pVerifyPara: ?*CRYPT_KEY_VERIFY_MESSAGE_PARA,
pPublicKeyInfo: ?*CERT_PUBLIC_KEY_INFO,
// TODO: what to do with BytesParamIndex 3?
pbSignedBlob: ?*const u8,
cbSignedBlob: u32,
// TODO: what to do with BytesParamIndex 5?
pbDecoded: ?*u8,
pcbDecoded: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertOpenSystemStoreA(
hProv: usize,
szSubsystemProtocol: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertOpenSystemStoreW(
hProv: usize,
szSubsystemProtocol: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEncodedCertificateToSystemStoreA(
szCertStoreName: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 2?
pbCertEncoded: ?*const u8,
cbCertEncoded: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertAddEncodedCertificateToSystemStoreW(
szCertStoreName: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 2?
pbCertEncoded: ?*const u8,
cbCertEncoded: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "WINTRUST" fn FindCertsByIssuer(
// TODO: what to do with BytesParamIndex 1?
pCertChains: ?*CERT_CHAIN,
pcbCertChains: ?*u32,
pcCertChains: ?*u32,
// TODO: what to do with BytesParamIndex 4?
pbEncodedIssuerName: ?*u8,
cbEncodedIssuerName: u32,
pwszPurpose: ?[*:0]const u16,
dwKeySpec: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptQueryObject(
dwObjectType: CERT_QUERY_OBJECT_TYPE,
pvObject: ?*const c_void,
dwExpectedContentTypeFlags: CERT_QUERY_CONTENT_TYPE_FLAGS,
dwExpectedFormatTypeFlags: CERT_QUERY_FORMAT_TYPE_FLAGS,
dwFlags: u32,
pdwMsgAndCertEncodingType: ?*CERT_QUERY_ENCODING_TYPE,
pdwContentType: ?*CERT_QUERY_CONTENT_TYPE,
pdwFormatType: ?*CERT_QUERY_FORMAT_TYPE,
phCertStore: ?*?*c_void,
phMsg: ?*?*c_void,
ppvContext: ?*const ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMemAlloc(
cbSize: u32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMemRealloc(
pv: ?*c_void,
cbSize: u32,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptMemFree(
pv: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub extern "CRYPT32" fn CryptCreateAsyncHandle(
dwFlags: u32,
phAsync: ?*?HCRYPTASYNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPT32" fn CryptSetAsyncParam(
hAsync: ?HCRYPTASYNC,
pszParamOid: ?PSTR,
pvParam: ?*c_void,
pfnFree: ?PFN_CRYPT_ASYNC_PARAM_FREE_FUNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPT32" fn CryptGetAsyncParam(
hAsync: ?HCRYPTASYNC,
pszParamOid: ?PSTR,
ppvParam: ?*?*c_void,
ppfnFree: ?*?PFN_CRYPT_ASYNC_PARAM_FREE_FUNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPT32" fn CryptCloseAsyncHandle(
hAsync: ?HCRYPTASYNC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTNET" fn CryptRetrieveObjectByUrlA(
pszUrl: ?[*:0]const u8,
pszObjectOid: ?[*:0]const u8,
dwRetrievalFlags: u32,
dwTimeout: u32,
ppvObject: ?*?*c_void,
hAsyncRetrieve: ?HCRYPTASYNC,
pCredentials: ?*CRYPT_CREDENTIALS,
pvVerify: ?*c_void,
pAuxInfo: ?*CRYPT_RETRIEVE_AUX_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTNET" fn CryptRetrieveObjectByUrlW(
pszUrl: ?[*:0]const u16,
pszObjectOid: ?[*:0]const u8,
dwRetrievalFlags: u32,
dwTimeout: u32,
ppvObject: ?*?*c_void,
hAsyncRetrieve: ?HCRYPTASYNC,
pCredentials: ?*CRYPT_CREDENTIALS,
pvVerify: ?*c_void,
pAuxInfo: ?*CRYPT_RETRIEVE_AUX_INFO,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPTNET" fn CryptInstallCancelRetrieval(
pfnCancel: ?PFN_CRYPT_CANCEL_RETRIEVAL,
pvArg: ?*const c_void,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPTNET" fn CryptUninstallCancelRetrieval(
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTNET" fn CryptGetObjectUrl(
pszUrlOid: ?[*:0]const u8,
pvPara: ?*c_void,
dwFlags: CRYPT_GET_URL_FLAGS,
// TODO: what to do with BytesParamIndex 4?
pUrlArray: ?*CRYPT_URL_ARRAY,
pcbUrlArray: ?*u32,
// TODO: what to do with BytesParamIndex 6?
pUrlInfo: ?*CRYPT_URL_INFO,
pcbUrlInfo: ?*u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateSelfSignCertificate(
hCryptProvOrNCryptKey: usize,
pSubjectIssuerBlob: ?*CRYPTOAPI_BLOB,
dwFlags: CERT_CREATE_SELFSIGN_FLAGS,
pKeyProvInfo: ?*CRYPT_KEY_PROV_INFO,
pSignatureAlgorithm: ?*CRYPT_ALGORITHM_IDENTIFIER,
pStartTime: ?*SYSTEMTIME,
pEndTime: ?*SYSTEMTIME,
pExtensions: ?*CERT_EXTENSIONS,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptGetKeyIdentifierProperty(
pKeyIdentifier: ?*const CRYPTOAPI_BLOB,
dwPropId: u32,
dwFlags: u32,
pwszComputerName: ?[*:0]const u16,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 6?
pvData: ?*c_void,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptSetKeyIdentifierProperty(
pKeyIdentifier: ?*const CRYPTOAPI_BLOB,
dwPropId: u32,
dwFlags: u32,
pwszComputerName: ?[*:0]const u16,
pvReserved: ?*c_void,
pvData: ?*const c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptEnumKeyIdentifierProperties(
pKeyIdentifier: ?*const CRYPTOAPI_BLOB,
dwPropId: u32,
dwFlags: u32,
pwszComputerName: ?[*:0]const u16,
pvReserved: ?*c_void,
pvArg: ?*c_void,
pfnEnum: ?PFN_CRYPT_ENUM_KEYID_PROP,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptCreateKeyIdentifierFromCSP(
dwCertEncodingType: u32,
pszPubKeyOID: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 3?
pPubKeyStruc: ?*const PUBLICKEYSTRUC,
cbPubKeyStruc: u32,
dwFlags: u32,
pvReserved: ?*c_void,
// TODO: what to do with BytesParamIndex 7?
pbHash: ?*u8,
pcbHash: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertCreateCertificateChainEngine(
pConfig: ?*CERT_CHAIN_ENGINE_CONFIG,
phChainEngine: ?*?HCERTCHAINENGINE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFreeCertificateChainEngine(
hChainEngine: ?HCERTCHAINENGINE,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "CRYPT32" fn CertResyncCertificateChainEngine(
hChainEngine: ?HCERTCHAINENGINE,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertGetCertificateChain(
hChainEngine: ?HCERTCHAINENGINE,
pCertContext: ?*const CERT_CONTEXT,
pTime: ?*FILETIME,
hAdditionalStore: ?*c_void,
pChainPara: ?*CERT_CHAIN_PARA,
dwFlags: u32,
pvReserved: ?*c_void,
ppChainContext: ?*?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFreeCertificateChain(
pChainContext: ?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertDuplicateCertificateChain(
pChainContext: ?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CHAIN_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertFindChainInStore(
hCertStore: ?*c_void,
dwCertEncodingType: u32,
dwFindFlags: CERT_FIND_CHAIN_IN_STORE_FLAGS,
dwFindType: u32,
pvFindPara: ?*const c_void,
pPrevChainContext: ?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CHAIN_CONTEXT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CertVerifyCertificateChainPolicy(
pszPolicyOID: ?[*:0]const u8,
pChainContext: ?*CERT_CHAIN_CONTEXT,
pPolicyPara: ?*CERT_CHAIN_POLICY_PARA,
pPolicyStatus: ?*CERT_CHAIN_POLICY_STATUS,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptStringToBinaryA(
pszString: [*:0]const u8,
cchString: u32,
dwFlags: CRYPT_STRING,
// TODO: what to do with BytesParamIndex 4?
pbBinary: ?*u8,
pcbBinary: ?*u32,
pdwSkip: ?*u32,
pdwFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptStringToBinaryW(
pszString: [*:0]const u16,
cchString: u32,
dwFlags: CRYPT_STRING,
// TODO: what to do with BytesParamIndex 4?
pbBinary: ?*u8,
pcbBinary: ?*u32,
pdwSkip: ?*u32,
pdwFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptBinaryToStringA(
// TODO: what to do with BytesParamIndex 1?
pbBinary: ?*const u8,
cbBinary: u32,
dwFlags: CRYPT_STRING,
pszString: ?[*:0]u8,
pcchString: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn CryptBinaryToStringW(
// TODO: what to do with BytesParamIndex 1?
pbBinary: ?*const u8,
cbBinary: u32,
dwFlags: CRYPT_STRING,
pszString: ?[*:0]u16,
pcchString: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn PFXImportCertStore(
pPFX: ?*CRYPTOAPI_BLOB,
szPassword: ?[*:0]const u16,
dwFlags: CRYPT_KEY_FLAGS,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn PFXIsPFXBlob(
pPFX: ?*CRYPTOAPI_BLOB,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn PFXVerifyPassword(
pPFX: ?*CRYPTOAPI_BLOB,
szPassword: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn PFXExportCertStoreEx(
hStore: ?*c_void,
pPFX: ?*CRYPTOAPI_BLOB,
szPassword: ?[*:0]const u16,
pvPara: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPT32" fn PFXExportCertStore(
hStore: ?*c_void,
pPFX: ?*CRYPTOAPI_BLOB,
szPassword: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertOpenServerOcspResponse(
pChainContext: ?*CERT_CHAIN_CONTEXT,
dwFlags: u32,
pOpenPara: ?*CERT_SERVER_OCSP_RESPONSE_OPEN_PARA,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertAddRefServerOcspResponse(
hServerOcspResponse: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertCloseServerOcspResponse(
hServerOcspResponse: ?*c_void,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertGetServerOcspResponseContext(
hServerOcspResponse: ?*c_void,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_SERVER_OCSP_RESPONSE_CONTEXT;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertAddRefServerOcspResponseContext(
pServerOcspResponseContext: ?*CERT_SERVER_OCSP_RESPONSE_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertFreeServerOcspResponseContext(
pServerOcspResponseContext: ?*CERT_SERVER_OCSP_RESPONSE_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.0.6000'
pub extern "CRYPT32" fn CertRetrieveLogoOrBiometricInfo(
pCertContext: ?*const CERT_CONTEXT,
lpszLogoOrBiometricType: ?[*:0]const u8,
dwRetrievalFlags: u32,
dwTimeout: u32,
dwFlags: u32,
pvReserved: ?*c_void,
ppbData: ?*?*u8,
pcbData: ?*u32,
ppwszMimeType: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPT32" fn CertSelectCertificateChains(
pSelectionContext: ?*const Guid,
dwFlags: u32,
pChainParameters: ?*CERT_SELECT_CHAIN_PARA,
cCriteria: u32,
rgpCriteria: ?[*]CERT_SELECT_CRITERIA,
hStore: ?*c_void,
pcSelection: ?*u32,
pprgpSelection: ?*?*?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPT32" fn CertFreeCertificateChainList(
prgpSelection: ?*?*CERT_CHAIN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPT32" fn CryptRetrieveTimeStamp(
wszUrl: ?[*:0]const u16,
dwRetrievalFlags: u32,
dwTimeout: u32,
pszHashId: ?[*:0]const u8,
pPara: ?*const CRYPT_TIMESTAMP_PARA,
// TODO: what to do with BytesParamIndex 6?
pbData: ?*const u8,
cbData: u32,
ppTsContext: ?*?*CRYPT_TIMESTAMP_CONTEXT,
ppTsSigner: ?*?*CERT_CONTEXT,
phStore: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPT32" fn CryptVerifyTimeStampSignature(
// TODO: what to do with BytesParamIndex 1?
pbTSContentInfo: ?*const u8,
cbTSContentInfo: u32,
// TODO: what to do with BytesParamIndex 3?
pbData: ?*const u8,
cbData: u32,
hAdditionalStore: ?*c_void,
ppTsContext: ?*?*CRYPT_TIMESTAMP_CONTEXT,
ppTsSigner: ?*?*CERT_CONTEXT,
phStore: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "CRYPT32" fn CertIsWeakHash(
dwHashUseType: u32,
pwszCNGHashAlgid: ?[*:0]const u16,
dwChainFlags: u32,
pSignerChainContext: ?*CERT_CHAIN_CONTEXT,
pTimeStamp: ?*FILETIME,
pwszFileName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptRegisterProtectionDescriptorName(
pwszName: ?[*:0]const u16,
pwszDescriptorString: ?[*:0]const u16,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptQueryProtectionDescriptorName(
pwszName: ?[*:0]const u16,
pwszDescriptorString: ?[*:0]u16,
pcDescriptorString: ?*usize,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptCreateProtectionDescriptor(
pwszDescriptorString: ?[*:0]const u16,
dwFlags: u32,
phDescriptor: ?*NCRYPT_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptCloseProtectionDescriptor(
hDescriptor: NCRYPT_DESCRIPTOR_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptGetProtectionDescriptorInfo(
hDescriptor: NCRYPT_DESCRIPTOR_HANDLE,
pMemPara: ?*const NCRYPT_ALLOC_PARA,
dwInfoType: u32,
ppvInfo: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptProtectSecret(
hDescriptor: NCRYPT_DESCRIPTOR_HANDLE,
dwFlags: u32,
// TODO: what to do with BytesParamIndex 3?
pbData: ?*const u8,
cbData: u32,
pMemPara: ?*const NCRYPT_ALLOC_PARA,
hWnd: ?HWND,
ppbProtectedBlob: ?*?*u8,
pcbProtectedBlob: ?*u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptUnprotectSecret(
phDescriptor: ?*NCRYPT_DESCRIPTOR_HANDLE,
dwFlags: NCRYPT_FLAGS,
// TODO: what to do with BytesParamIndex 3?
pbProtectedBlob: ?*const u8,
cbProtectedBlob: u32,
pMemPara: ?*const NCRYPT_ALLOC_PARA,
hWnd: ?HWND,
ppbData: ?*?*u8,
pcbData: ?*u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptStreamOpenToProtect(
hDescriptor: NCRYPT_DESCRIPTOR_HANDLE,
dwFlags: u32,
hWnd: ?HWND,
pStreamInfo: ?*NCRYPT_PROTECT_STREAM_INFO,
phStream: ?*NCRYPT_STREAM_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptStreamOpenToUnprotect(
pStreamInfo: ?*NCRYPT_PROTECT_STREAM_INFO,
dwFlags: u32,
hWnd: ?HWND,
phStream: ?*NCRYPT_STREAM_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
pub extern "ncrypt" fn NCryptStreamOpenToUnprotectEx(
pStreamInfo: ?*NCRYPT_PROTECT_STREAM_INFO_EX,
dwFlags: u32,
hWnd: ?HWND,
phStream: ?*NCRYPT_STREAM_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptStreamUpdate(
hStream: NCRYPT_STREAM_HANDLE,
// TODO: what to do with BytesParamIndex 2?
pbData: ?*const u8,
cbData: usize,
fFinal: BOOL,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows8.0'
pub extern "ncrypt" fn NCryptStreamClose(
hStream: NCRYPT_STREAM_HANDLE,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlClose(
hCryptXml: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetTransforms(
ppConfig: ?*const ?*CRYPT_XML_TRANSFORM_CHAIN_CONFIG,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlOpenToEncode(
pConfig: ?*const CRYPT_XML_TRANSFORM_CHAIN_CONFIG,
dwFlags: CRYPT_XML_FLAGS,
wszId: ?[*:0]const u16,
rgProperty: ?[*]const CRYPT_XML_PROPERTY,
cProperty: u32,
pEncoded: ?*const CRYPT_XML_BLOB,
phSignature: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlOpenToDecode(
pConfig: ?*const CRYPT_XML_TRANSFORM_CHAIN_CONFIG,
dwFlags: CRYPT_XML_FLAGS,
rgProperty: ?[*]const CRYPT_XML_PROPERTY,
cProperty: u32,
pEncoded: ?*const CRYPT_XML_BLOB,
phCryptXml: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlAddObject(
hSignatureOrObject: ?*c_void,
dwFlags: u32,
rgProperty: ?[*]const CRYPT_XML_PROPERTY,
cProperty: u32,
pEncoded: ?*const CRYPT_XML_BLOB,
ppObject: ?*const ?*CRYPT_XML_OBJECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlCreateReference(
hCryptXml: ?*c_void,
dwFlags: u32,
wszId: ?[*:0]const u16,
wszURI: ?[*:0]const u16,
wszType: ?[*:0]const u16,
pDigestMethod: ?*const CRYPT_XML_ALGORITHM,
cTransform: u32,
rgTransform: ?[*]const CRYPT_XML_ALGORITHM,
phReference: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlDigestReference(
hReference: ?*c_void,
dwFlags: u32,
pDataProviderIn: ?*CRYPT_XML_DATA_PROVIDER,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlSetHMACSecret(
hSignature: ?*c_void,
// TODO: what to do with BytesParamIndex 2?
pbSecret: ?*const u8,
cbSecret: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlSign(
hSignature: ?*c_void,
hKey: usize,
dwKeySpec: CERT_KEY_SPEC,
dwFlags: CRYPT_XML_FLAGS,
dwKeyInfoSpec: CRYPT_XML_KEYINFO_SPEC,
pvKeyInfoSpec: ?*const c_void,
pSignatureMethod: ?*const CRYPT_XML_ALGORITHM,
pCanonicalization: ?*const CRYPT_XML_ALGORITHM,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlImportPublicKey(
dwFlags: CRYPT_XML_FLAGS,
pKeyValue: ?*const CRYPT_XML_KEY_VALUE,
phKey: ?*BCRYPT_KEY_HANDLE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlVerifySignature(
hSignature: ?*c_void,
hKey: BCRYPT_KEY_HANDLE,
dwFlags: CRYPT_XML_FLAGS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetDocContext(
hCryptXml: ?*c_void,
ppStruct: ?*const ?*CRYPT_XML_DOC_CTXT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetSignature(
hCryptXml: ?*c_void,
ppStruct: ?*const ?*CRYPT_XML_SIGNATURE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetReference(
hCryptXml: ?*c_void,
ppStruct: ?*const ?*CRYPT_XML_REFERENCE,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetStatus(
hCryptXml: ?*c_void,
pStatus: ?*CRYPT_XML_STATUS,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlEncode(
hCryptXml: ?*c_void,
dwCharset: CRYPT_XML_CHARSET,
rgProperty: ?[*]const CRYPT_XML_PROPERTY,
cProperty: u32,
pvCallbackState: ?*c_void,
pfnWrite: ?PFN_CRYPT_XML_WRITE_CALLBACK,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTXML" fn CryptXmlGetAlgorithmInfo(
pXmlAlgorithm: ?*const CRYPT_XML_ALGORITHM,
dwFlags: CRYPT_XML_FLAGS,
ppAlgInfo: ?*?*CRYPT_XML_ALGORITHM_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "CRYPTXML" fn CryptXmlFindAlgorithmInfo(
dwFindByType: u32,
pvFindBy: ?*const c_void,
dwGroupId: u32,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) ?*CRYPT_XML_ALGORITHM_INFO;
pub extern "CRYPTXML" fn CryptXmlEnumAlgorithmInfo(
dwGroupId: u32,
dwFlags: u32,
pvArg: ?*c_void,
pfnEnumAlgInfo: ?PFN_CRYPT_XML_ENUM_ALG_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIDlgViewContext(
dwContextType: u32,
pvContext: ?*const c_void,
hwnd: ?HWND,
pwszTitle: ?[*:0]const u16,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIDlgSelectCertificateFromStore(
hCertStore: ?*c_void,
hwnd: ?HWND,
pwszTitle: ?[*:0]const u16,
pwszDisplayString: ?[*:0]const u16,
dwDontUseColumn: u32,
dwFlags: u32,
pvReserved: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*CERT_CONTEXT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "CRYPTUI" fn CertSelectionGetSerializedBlob(
pcsi: ?*CERT_SELECTUI_INPUT,
ppOutBuffer: ?*?*c_void,
pulOutBufferSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIDlgCertMgr(
pCryptUICertMgr: ?*CRYPTUI_CERT_MGR_STRUCT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIWizDigitalSign(
dwFlags: u32,
hwndParent: ?HWND,
pwszWizardTitle: ?[*:0]const u16,
pDigitalSignInfo: ?*CRYPTUI_WIZ_DIGITAL_SIGN_INFO,
ppSignContext: ?*?*CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIWizFreeDigitalSignContext(
pSignContext: ?*CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIDlgViewCertificateW(
pCertViewInfo: ?*CRYPTUI_VIEWCERTIFICATE_STRUCTW,
pfPropertiesChanged: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIDlgViewCertificateA(
pCertViewInfo: ?*CRYPTUI_VIEWCERTIFICATE_STRUCTA,
pfPropertiesChanged: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIWizExport(
dwFlags: CRYPTUI_WIZ_FLAGS,
hwndParent: ?HWND,
pwszWizardTitle: ?[*:0]const u16,
pExportInfo: ?*CRYPTUI_WIZ_EXPORT_INFO,
pvoid: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "CRYPTUI" fn CryptUIWizImport(
dwFlags: CRYPTUI_WIZ_FLAGS,
hwndParent: ?HWND,
pwszWizardTitle: ?[*:0]const u16,
pImportSrc: ?*CRYPTUI_WIZ_IMPORT_SRC_INFO,
hDestCertStore: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) BOOL;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (22)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
pub const CRYPT_PASSWORD_CREDENTIALS = thismodule.CRYPT_PASSWORD_CREDENTIALSA;
pub const CERT_SELECT_STRUCT_ = thismodule.CERT_SELECT_STRUCT_A;
pub const CERT_VIEWPROPERTIES_STRUCT_ = thismodule.CERT_VIEWPROPERTIES_STRUCT_A;
pub const CRYPTUI_VIEWCERTIFICATE_STRUCT = thismodule.CRYPTUI_VIEWCERTIFICATE_STRUCTA;
pub const CryptAcquireContext = thismodule.CryptAcquireContextA;
pub const CryptSignHash = thismodule.CryptSignHashA;
pub const CryptVerifySignature = thismodule.CryptVerifySignatureA;
pub const CryptSetProvider = thismodule.CryptSetProviderA;
pub const CryptSetProviderEx = thismodule.CryptSetProviderExA;
pub const CryptGetDefaultProvider = thismodule.CryptGetDefaultProviderA;
pub const CryptEnumProviderTypes = thismodule.CryptEnumProviderTypesA;
pub const CryptEnumProviders = thismodule.CryptEnumProvidersA;
pub const CertRDNValueToStr = thismodule.CertRDNValueToStrA;
pub const CertNameToStr = thismodule.CertNameToStrA;
pub const CertStrToName = thismodule.CertStrToNameA;
pub const CertGetNameString = thismodule.CertGetNameStringA;
pub const CertOpenSystemStore = thismodule.CertOpenSystemStoreA;
pub const CertAddEncodedCertificateToSystemStore = thismodule.CertAddEncodedCertificateToSystemStoreA;
pub const CryptRetrieveObjectByUrl = thismodule.CryptRetrieveObjectByUrlA;
pub const CryptStringToBinary = thismodule.CryptStringToBinaryA;
pub const CryptBinaryToString = thismodule.CryptBinaryToStringA;
pub const CryptUIDlgViewCertificate = thismodule.CryptUIDlgViewCertificateA;
},
.wide => struct {
pub const CRYPT_PASSWORD_CREDENTIALS = thismodule.CRYPT_PASSWORD_CREDENTIALSW;
pub const CERT_SELECT_STRUCT_ = thismodule.CERT_SELECT_STRUCT_W;
pub const CERT_VIEWPROPERTIES_STRUCT_ = thismodule.CERT_VIEWPROPERTIES_STRUCT_W;
pub const CRYPTUI_VIEWCERTIFICATE_STRUCT = thismodule.CRYPTUI_VIEWCERTIFICATE_STRUCTW;
pub const CryptAcquireContext = thismodule.CryptAcquireContextW;
pub const CryptSignHash = thismodule.CryptSignHashW;
pub const CryptVerifySignature = thismodule.CryptVerifySignatureW;
pub const CryptSetProvider = thismodule.CryptSetProviderW;
pub const CryptSetProviderEx = thismodule.CryptSetProviderExW;
pub const CryptGetDefaultProvider = thismodule.CryptGetDefaultProviderW;
pub const CryptEnumProviderTypes = thismodule.CryptEnumProviderTypesW;
pub const CryptEnumProviders = thismodule.CryptEnumProvidersW;
pub const CertRDNValueToStr = thismodule.CertRDNValueToStrW;
pub const CertNameToStr = thismodule.CertNameToStrW;
pub const CertStrToName = thismodule.CertStrToNameW;
pub const CertGetNameString = thismodule.CertGetNameStringW;
pub const CertOpenSystemStore = thismodule.CertOpenSystemStoreW;
pub const CertAddEncodedCertificateToSystemStore = thismodule.CertAddEncodedCertificateToSystemStoreW;
pub const CryptRetrieveObjectByUrl = thismodule.CryptRetrieveObjectByUrlW;
pub const CryptStringToBinary = thismodule.CryptStringToBinaryW;
pub const CryptBinaryToString = thismodule.CryptBinaryToStringW;
pub const CryptUIDlgViewCertificate = thismodule.CryptUIDlgViewCertificateW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const CRYPT_PASSWORD_CREDENTIALS = *opaque{};
pub const CERT_SELECT_STRUCT_ = *opaque{};
pub const CERT_VIEWPROPERTIES_STRUCT_ = *opaque{};
pub const CRYPTUI_VIEWCERTIFICATE_STRUCT = *opaque{};
pub const CryptAcquireContext = *opaque{};
pub const CryptSignHash = *opaque{};
pub const CryptVerifySignature = *opaque{};
pub const CryptSetProvider = *opaque{};
pub const CryptSetProviderEx = *opaque{};
pub const CryptGetDefaultProvider = *opaque{};
pub const CryptEnumProviderTypes = *opaque{};
pub const CryptEnumProviders = *opaque{};
pub const CertRDNValueToStr = *opaque{};
pub const CertNameToStr = *opaque{};
pub const CertStrToName = *opaque{};
pub const CertGetNameString = *opaque{};
pub const CertOpenSystemStore = *opaque{};
pub const CertAddEncodedCertificateToSystemStore = *opaque{};
pub const CryptRetrieveObjectByUrl = *opaque{};
pub const CryptStringToBinary = *opaque{};
pub const CryptBinaryToString = *opaque{};
pub const CryptUIDlgViewCertificate = *opaque{};
} else struct {
pub const CRYPT_PASSWORD_CREDENTIALS = @compileError("'CRYPT_PASSWORD_CREDENTIALS' requires that UNICODE be set to true or false in the root module");
pub const CERT_SELECT_STRUCT_ = @compileError("'CERT_SELECT_STRUCT_' requires that UNICODE be set to true or false in the root module");
pub const CERT_VIEWPROPERTIES_STRUCT_ = @compileError("'CERT_VIEWPROPERTIES_STRUCT_' requires that UNICODE be set to true or false in the root module");
pub const CRYPTUI_VIEWCERTIFICATE_STRUCT = @compileError("'CRYPTUI_VIEWCERTIFICATE_STRUCT' requires that UNICODE be set to true or false in the root module");
pub const CryptAcquireContext = @compileError("'CryptAcquireContext' requires that UNICODE be set to true or false in the root module");
pub const CryptSignHash = @compileError("'CryptSignHash' requires that UNICODE be set to true or false in the root module");
pub const CryptVerifySignature = @compileError("'CryptVerifySignature' requires that UNICODE be set to true or false in the root module");
pub const CryptSetProvider = @compileError("'CryptSetProvider' requires that UNICODE be set to true or false in the root module");
pub const CryptSetProviderEx = @compileError("'CryptSetProviderEx' requires that UNICODE be set to true or false in the root module");
pub const CryptGetDefaultProvider = @compileError("'CryptGetDefaultProvider' requires that UNICODE be set to true or false in the root module");
pub const CryptEnumProviderTypes = @compileError("'CryptEnumProviderTypes' requires that UNICODE be set to true or false in the root module");
pub const CryptEnumProviders = @compileError("'CryptEnumProviders' requires that UNICODE be set to true or false in the root module");
pub const CertRDNValueToStr = @compileError("'CertRDNValueToStr' requires that UNICODE be set to true or false in the root module");
pub const CertNameToStr = @compileError("'CertNameToStr' requires that UNICODE be set to true or false in the root module");
pub const CertStrToName = @compileError("'CertStrToName' requires that UNICODE be set to true or false in the root module");
pub const CertGetNameString = @compileError("'CertGetNameString' requires that UNICODE be set to true or false in the root module");
pub const CertOpenSystemStore = @compileError("'CertOpenSystemStore' requires that UNICODE be set to true or false in the root module");
pub const CertAddEncodedCertificateToSystemStore = @compileError("'CertAddEncodedCertificateToSystemStore' requires that UNICODE be set to true or false in the root module");
pub const CryptRetrieveObjectByUrl = @compileError("'CryptRetrieveObjectByUrl' requires that UNICODE be set to true or false in the root module");
pub const CryptStringToBinary = @compileError("'CryptStringToBinary' requires that UNICODE be set to true or false in the root module");
pub const CryptBinaryToString = @compileError("'CryptBinaryToString' requires that UNICODE be set to true or false in the root module");
pub const CryptUIDlgViewCertificate = @compileError("'CryptUIDlgViewCertificate' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (24)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const CERT_RDN_ATTR_VALUE_TYPE = @import("../../security/cryptography/certificates.zig").CERT_RDN_ATTR_VALUE_TYPE;
const CERT_VIEWPROPERTIES_STRUCT_FLAGS = @import("../../system/system_services.zig").CERT_VIEWPROPERTIES_STRUCT_FLAGS;
const CHAR = @import("../../system/system_services.zig").CHAR;
const CRYPT_PROVIDER_DATA = @import("../../security.zig").CRYPT_PROVIDER_DATA;
const FILETIME = @import("../../foundation.zig").FILETIME;
const HANDLE = @import("../../foundation.zig").HANDLE;
const HINSTANCE = @import("../../foundation.zig").HINSTANCE;
const HKEY = @import("../../system/registry.zig").HKEY;
const HRESULT = @import("../../foundation.zig").HRESULT;
const HWND = @import("../../foundation.zig").HWND;
const LPARAM = @import("../../foundation.zig").LPARAM;
const NCRYPT_DESCRIPTOR_HANDLE = @import("../../security.zig").NCRYPT_DESCRIPTOR_HANDLE;
const NCRYPT_STREAM_HANDLE = @import("../../security.zig").NCRYPT_STREAM_HANDLE;
const NTSTATUS = @import("../../foundation.zig").NTSTATUS;
const OBJECT_SECURITY_INFORMATION = @import("../../security/authorization.zig").OBJECT_SECURITY_INFORMATION;
const PROPSHEETPAGEA = @import("../../ui/controls.zig").PROPSHEETPAGEA;
const PROPSHEETPAGEW = @import("../../ui/controls.zig").PROPSHEETPAGEW;
const PSTR = @import("../../foundation.zig").PSTR;
const PWSTR = @import("../../foundation.zig").PWSTR;
const REG_VALUE_TYPE = @import("../../system/registry.zig").REG_VALUE_TYPE;
const SYSTEMTIME = @import("../../foundation.zig").SYSTEMTIME;
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(), "PFN_NCRYPT_ALLOC")) { _ = PFN_NCRYPT_ALLOC; }
if (@hasDecl(@This(), "PFN_NCRYPT_FREE")) { _ = PFN_NCRYPT_FREE; }
if (@hasDecl(@This(), "PCRYPT_DECRYPT_PRIVATE_KEY_FUNC")) { _ = PCRYPT_DECRYPT_PRIVATE_KEY_FUNC; }
if (@hasDecl(@This(), "PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC")) { _ = PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC; }
if (@hasDecl(@This(), "PCRYPT_RESOLVE_HCRYPTPROV_FUNC")) { _ = PCRYPT_RESOLVE_HCRYPTPROV_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_ALLOC")) { _ = PFN_CRYPT_ALLOC; }
if (@hasDecl(@This(), "PFN_CRYPT_FREE")) { _ = PFN_CRYPT_FREE; }
if (@hasDecl(@This(), "PFN_CRYPT_ENUM_OID_FUNC")) { _ = PFN_CRYPT_ENUM_OID_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_ENUM_OID_INFO")) { _ = PFN_CRYPT_ENUM_OID_INFO; }
if (@hasDecl(@This(), "PFN_CMSG_STREAM_OUTPUT")) { _ = PFN_CMSG_STREAM_OUTPUT; }
if (@hasDecl(@This(), "PFN_CMSG_ALLOC")) { _ = PFN_CMSG_ALLOC; }
if (@hasDecl(@This(), "PFN_CMSG_FREE")) { _ = PFN_CMSG_FREE; }
if (@hasDecl(@This(), "PFN_CMSG_GEN_ENCRYPT_KEY")) { _ = PFN_CMSG_GEN_ENCRYPT_KEY; }
if (@hasDecl(@This(), "PFN_CMSG_EXPORT_ENCRYPT_KEY")) { _ = PFN_CMSG_EXPORT_ENCRYPT_KEY; }
if (@hasDecl(@This(), "PFN_CMSG_IMPORT_ENCRYPT_KEY")) { _ = PFN_CMSG_IMPORT_ENCRYPT_KEY; }
if (@hasDecl(@This(), "PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY")) { _ = PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY; }
if (@hasDecl(@This(), "PFN_CMSG_EXPORT_KEY_TRANS")) { _ = PFN_CMSG_EXPORT_KEY_TRANS; }
if (@hasDecl(@This(), "PFN_CMSG_EXPORT_KEY_AGREE")) { _ = PFN_CMSG_EXPORT_KEY_AGREE; }
if (@hasDecl(@This(), "PFN_CMSG_EXPORT_MAIL_LIST")) { _ = PFN_CMSG_EXPORT_MAIL_LIST; }
if (@hasDecl(@This(), "PFN_CMSG_IMPORT_KEY_TRANS")) { _ = PFN_CMSG_IMPORT_KEY_TRANS; }
if (@hasDecl(@This(), "PFN_CMSG_IMPORT_KEY_AGREE")) { _ = PFN_CMSG_IMPORT_KEY_AGREE; }
if (@hasDecl(@This(), "PFN_CMSG_IMPORT_MAIL_LIST")) { _ = PFN_CMSG_IMPORT_MAIL_LIST; }
if (@hasDecl(@This(), "PFN_CMSG_CNG_IMPORT_KEY_TRANS")) { _ = PFN_CMSG_CNG_IMPORT_KEY_TRANS; }
if (@hasDecl(@This(), "PFN_CMSG_CNG_IMPORT_KEY_AGREE")) { _ = PFN_CMSG_CNG_IMPORT_KEY_AGREE; }
if (@hasDecl(@This(), "PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY")) { _ = PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY; }
if (@hasDecl(@This(), "PFN_CERT_DLL_OPEN_STORE_PROV_FUNC")) { _ = PFN_CERT_DLL_OPEN_STORE_PROV_FUNC; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_CLOSE")) { _ = PFN_CERT_STORE_PROV_CLOSE; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_READ_CERT")) { _ = PFN_CERT_STORE_PROV_READ_CERT; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_WRITE_CERT")) { _ = PFN_CERT_STORE_PROV_WRITE_CERT; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_DELETE_CERT")) { _ = PFN_CERT_STORE_PROV_DELETE_CERT; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_SET_CERT_PROPERTY")) { _ = PFN_CERT_STORE_PROV_SET_CERT_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_READ_CRL")) { _ = PFN_CERT_STORE_PROV_READ_CRL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_WRITE_CRL")) { _ = PFN_CERT_STORE_PROV_WRITE_CRL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_DELETE_CRL")) { _ = PFN_CERT_STORE_PROV_DELETE_CRL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_SET_CRL_PROPERTY")) { _ = PFN_CERT_STORE_PROV_SET_CRL_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_READ_CTL")) { _ = PFN_CERT_STORE_PROV_READ_CTL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_WRITE_CTL")) { _ = PFN_CERT_STORE_PROV_WRITE_CTL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_DELETE_CTL")) { _ = PFN_CERT_STORE_PROV_DELETE_CTL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_SET_CTL_PROPERTY")) { _ = PFN_CERT_STORE_PROV_SET_CTL_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_CONTROL")) { _ = PFN_CERT_STORE_PROV_CONTROL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FIND_CERT")) { _ = PFN_CERT_STORE_PROV_FIND_CERT; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FREE_FIND_CERT")) { _ = PFN_CERT_STORE_PROV_FREE_FIND_CERT; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_GET_CERT_PROPERTY")) { _ = PFN_CERT_STORE_PROV_GET_CERT_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FIND_CRL")) { _ = PFN_CERT_STORE_PROV_FIND_CRL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FREE_FIND_CRL")) { _ = PFN_CERT_STORE_PROV_FREE_FIND_CRL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_GET_CRL_PROPERTY")) { _ = PFN_CERT_STORE_PROV_GET_CRL_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FIND_CTL")) { _ = PFN_CERT_STORE_PROV_FIND_CTL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_FREE_FIND_CTL")) { _ = PFN_CERT_STORE_PROV_FREE_FIND_CTL; }
if (@hasDecl(@This(), "PFN_CERT_STORE_PROV_GET_CTL_PROPERTY")) { _ = PFN_CERT_STORE_PROV_GET_CTL_PROPERTY; }
if (@hasDecl(@This(), "PFN_CERT_CREATE_CONTEXT_SORT_FUNC")) { _ = PFN_CERT_CREATE_CONTEXT_SORT_FUNC; }
if (@hasDecl(@This(), "PFN_CERT_ENUM_SYSTEM_STORE_LOCATION")) { _ = PFN_CERT_ENUM_SYSTEM_STORE_LOCATION; }
if (@hasDecl(@This(), "PFN_CERT_ENUM_SYSTEM_STORE")) { _ = PFN_CERT_ENUM_SYSTEM_STORE; }
if (@hasDecl(@This(), "PFN_CERT_ENUM_PHYSICAL_STORE")) { _ = PFN_CERT_ENUM_PHYSICAL_STORE; }
if (@hasDecl(@This(), "PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC")) { _ = PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC")) { _ = PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC")) { _ = PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC")) { _ = PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC")) { _ = PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC; }
if (@hasDecl(@This(), "PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC")) { _ = PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC; }
if (@hasDecl(@This(), "PFN_IMPORT_PRIV_KEY_FUNC")) { _ = PFN_IMPORT_PRIV_KEY_FUNC; }
if (@hasDecl(@This(), "PFN_EXPORT_PRIV_KEY_FUNC")) { _ = PFN_EXPORT_PRIV_KEY_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_GET_SIGNER_CERTIFICATE")) { _ = PFN_CRYPT_GET_SIGNER_CERTIFICATE; }
if (@hasDecl(@This(), "PFN_CRYPT_ASYNC_PARAM_FREE_FUNC")) { _ = PFN_CRYPT_ASYNC_PARAM_FREE_FUNC; }
if (@hasDecl(@This(), "PFN_FREE_ENCODED_OBJECT_FUNC")) { _ = PFN_FREE_ENCODED_OBJECT_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_CANCEL_RETRIEVAL")) { _ = PFN_CRYPT_CANCEL_RETRIEVAL; }
if (@hasDecl(@This(), "PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC")) { _ = PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC; }
if (@hasDecl(@This(), "PFN_CANCEL_ASYNC_RETRIEVAL_FUNC")) { _ = PFN_CANCEL_ASYNC_RETRIEVAL_FUNC; }
if (@hasDecl(@This(), "PFN_CRYPT_ENUM_KEYID_PROP")) { _ = PFN_CRYPT_ENUM_KEYID_PROP; }
if (@hasDecl(@This(), "PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK")) { _ = PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK; }
if (@hasDecl(@This(), "PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK")) { _ = PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER; }
if (@hasDecl(@This(), "PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE")) { _ = PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE; }
if (@hasDecl(@This(), "PFN_CERT_IS_WEAK_HASH")) { _ = PFN_CERT_IS_WEAK_HASH; }
if (@hasDecl(@This(), "PFNCryptStreamOutputCallback")) { _ = PFNCryptStreamOutputCallback; }
if (@hasDecl(@This(), "PFNCryptStreamOutputCallbackEx")) { _ = PFNCryptStreamOutputCallbackEx; }
if (@hasDecl(@This(), "PFN_CRYPT_XML_WRITE_CALLBACK")) { _ = PFN_CRYPT_XML_WRITE_CALLBACK; }
if (@hasDecl(@This(), "PFN_CRYPT_XML_DATA_PROVIDER_READ")) { _ = PFN_CRYPT_XML_DATA_PROVIDER_READ; }
if (@hasDecl(@This(), "PFN_CRYPT_XML_DATA_PROVIDER_CLOSE")) { _ = PFN_CRYPT_XML_DATA_PROVIDER_CLOSE; }
if (@hasDecl(@This(), "PFN_CRYPT_XML_CREATE_TRANSFORM")) { _ = PFN_CRYPT_XML_CREATE_TRANSFORM; }
if (@hasDecl(@This(), "PFN_CRYPT_XML_ENUM_ALG_INFO")) { _ = PFN_CRYPT_XML_ENUM_ALG_INFO; }
if (@hasDecl(@This(), "CryptXmlDllGetInterface")) { _ = CryptXmlDllGetInterface; }
if (@hasDecl(@This(), "CryptXmlDllEncodeAlgorithm")) { _ = CryptXmlDllEncodeAlgorithm; }
if (@hasDecl(@This(), "CryptXmlDllCreateDigest")) { _ = CryptXmlDllCreateDigest; }
if (@hasDecl(@This(), "CryptXmlDllDigestData")) { _ = CryptXmlDllDigestData; }
if (@hasDecl(@This(), "CryptXmlDllFinalizeDigest")) { _ = CryptXmlDllFinalizeDigest; }
if (@hasDecl(@This(), "CryptXmlDllCloseDigest")) { _ = CryptXmlDllCloseDigest; }
if (@hasDecl(@This(), "CryptXmlDllSignData")) { _ = CryptXmlDllSignData; }
if (@hasDecl(@This(), "CryptXmlDllVerifySignature")) { _ = CryptXmlDllVerifySignature; }
if (@hasDecl(@This(), "CryptXmlDllGetAlgorithmInfo")) { _ = CryptXmlDllGetAlgorithmInfo; }
if (@hasDecl(@This(), "CryptXmlDllEncodeKeyValue")) { _ = CryptXmlDllEncodeKeyValue; }
if (@hasDecl(@This(), "CryptXmlDllCreateKey")) { _ = CryptXmlDllCreateKey; }
if (@hasDecl(@This(), "PFNCMFILTERPROC")) { _ = PFNCMFILTERPROC; }
if (@hasDecl(@This(), "PFNCMHOOKPROC")) { _ = PFNCMHOOKPROC; }
if (@hasDecl(@This(), "PFNTRUSTHELPER")) { _ = PFNTRUSTHELPER; }
if (@hasDecl(@This(), "PFNCFILTERPROC")) { _ = PFNCFILTERPROC; }
@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;
}
}
} | deps/zigwin32/win32/security/cryptography/core.zig |
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
const kernel = @import("__trig.zig");
const __rem_pio2 = @import("__rem_pio2.zig").__rem_pio2;
const __rem_pio2f = @import("__rem_pio2f.zig").__rem_pio2f;
/// Returns the sine of the radian value x.
///
/// Special Cases:
/// - sin(+-0) = +-0
/// - sin(+-inf) = nan
/// - sin(nan) = nan
pub fn sin(x: anytype) @TypeOf(x) {
const T = @TypeOf(x);
return switch (T) {
f32 => sin32(x),
f64 => sin64(x),
else => @compileError("sin not implemented for " ++ @typeName(T)),
};
}
fn sin32(x: f32) f32 {
// Small multiples of pi/2 rounded to double precision.
const s1pio2: f64 = 1.0 * math.pi / 2.0; // 0x3FF921FB, 0x54442D18
const s2pio2: f64 = 2.0 * math.pi / 2.0; // 0x400921FB, 0x54442D18
const s3pio2: f64 = 3.0 * math.pi / 2.0; // 0x4012D97C, 0x7F3321D2
const s4pio2: f64 = 4.0 * math.pi / 2.0; // 0x401921FB, 0x54442D18
var ix = @bitCast(u32, x);
const sign = ix >> 31 != 0;
ix &= 0x7fffffff;
if (ix <= 0x3f490fda) { // |x| ~<= pi/4
if (ix < 0x39800000) { // |x| < 2**-12
// raise inexact if x!=0 and underflow if subnormal
math.doNotOptimizeAway(if (ix < 0x00800000) x / 0x1p120 else x + 0x1p120);
return x;
}
return kernel.__sindf(x);
}
if (ix <= 0x407b53d1) { // |x| ~<= 5*pi/4
if (ix <= 0x4016cbe3) { // |x| ~<= 3pi/4
if (sign) {
return -kernel.__cosdf(x + s1pio2);
} else {
return kernel.__cosdf(x - s1pio2);
}
}
return kernel.__sindf(if (sign) -(x + s2pio2) else -(x - s2pio2));
}
if (ix <= 0x40e231d5) { // |x| ~<= 9*pi/4
if (ix <= 0x40afeddf) { // |x| ~<= 7*pi/4
if (sign) {
return kernel.__cosdf(x + s3pio2);
} else {
return -kernel.__cosdf(x - s3pio2);
}
}
return kernel.__sindf(if (sign) x + s4pio2 else x - s4pio2);
}
// sin(Inf or NaN) is NaN
if (ix >= 0x7f800000) {
return x - x;
}
var y: f64 = undefined;
const n = __rem_pio2f(x, &y);
return switch (n & 3) {
0 => kernel.__sindf(y),
1 => kernel.__cosdf(y),
2 => kernel.__sindf(-y),
else => -kernel.__cosdf(y),
};
}
fn sin64(x: f64) f64 {
var ix = @bitCast(u64, x) >> 32;
ix &= 0x7fffffff;
// |x| ~< pi/4
if (ix <= 0x3fe921fb) {
if (ix < 0x3e500000) { // |x| < 2**-26
// raise inexact if x != 0 and underflow if subnormal
math.doNotOptimizeAway(if (ix < 0x00100000) x / 0x1p120 else x + 0x1p120);
return x;
}
return kernel.__sin(x, 0.0, 0);
}
// sin(Inf or NaN) is NaN
if (ix >= 0x7ff00000) {
return x - x;
}
var y: [2]f64 = undefined;
const n = __rem_pio2(x, &y);
return switch (n & 3) {
0 => kernel.__sin(y[0], y[1], 1),
1 => kernel.__cos(y[0], y[1]),
2 => -kernel.__sin(y[0], y[1], 1),
else => -kernel.__cos(y[0], y[1]),
};
}
test "math.sin" {
try expect(sin(@as(f32, 0.0)) == sin32(0.0));
try expect(sin(@as(f64, 0.0)) == sin64(0.0));
try expect(comptime (math.sin(@as(f64, 2))) == math.sin(@as(f64, 2)));
}
test "math.sin32" {
const epsilon = 0.00001;
try expect(math.approxEqAbs(f32, sin32(0.0), 0.0, epsilon));
try expect(math.approxEqAbs(f32, sin32(0.2), 0.198669, epsilon));
try expect(math.approxEqAbs(f32, sin32(0.8923), 0.778517, epsilon));
try expect(math.approxEqAbs(f32, sin32(1.5), 0.997495, epsilon));
try expect(math.approxEqAbs(f32, sin32(-1.5), -0.997495, epsilon));
try expect(math.approxEqAbs(f32, sin32(37.45), -0.246544, epsilon));
try expect(math.approxEqAbs(f32, sin32(89.123), 0.916166, epsilon));
}
test "math.sin64" {
const epsilon = 0.000001;
try expect(math.approxEqAbs(f64, sin64(0.0), 0.0, epsilon));
try expect(math.approxEqAbs(f64, sin64(0.2), 0.198669, epsilon));
try expect(math.approxEqAbs(f64, sin64(0.8923), 0.778517, epsilon));
try expect(math.approxEqAbs(f64, sin64(1.5), 0.997495, epsilon));
try expect(math.approxEqAbs(f64, sin64(-1.5), -0.997495, epsilon));
try expect(math.approxEqAbs(f64, sin64(37.45), -0.246543, epsilon));
try expect(math.approxEqAbs(f64, sin64(89.123), 0.916166, epsilon));
}
test "math.sin32.special" {
try expect(sin32(0.0) == 0.0);
try expect(sin32(-0.0) == -0.0);
try expect(math.isNan(sin32(math.inf(f32))));
try expect(math.isNan(sin32(-math.inf(f32))));
try expect(math.isNan(sin32(math.nan(f32))));
}
test "math.sin64.special" {
try expect(sin64(0.0) == 0.0);
try expect(sin64(-0.0) == -0.0);
try expect(math.isNan(sin64(math.inf(f64))));
try expect(math.isNan(sin64(-math.inf(f64))));
try expect(math.isNan(sin64(math.nan(f64))));
}
test "math.sin32 #9901" {
const float = @bitCast(f32, @as(u32, 0b11100011111111110000000000000000));
_ = std.math.sin(float);
}
test "math.sin64 #9901" {
const float = @bitCast(f64, @as(u64, 0b1111111101000001000000001111110111111111100000000000000000000001));
_ = std.math.sin(float);
} | lib/std/math/sin.zig |
const std = @import("std");
const log = std.debug.warn;
const stdout = &std.io.getStdOut().outStream();
const assert = @import("std").debug.assert;
const fmt = @import("std").fmt;
const c = @import("c.zig");
const gw = c.gw;
const gmp = c.gmp;
const glue = @import("glue.zig");
const helper = @import("helper.zig");
const u_zero = @import("u_zero.zig");
pub fn full_fermat_run(k: u32, b: u32, n: u32, c_: i32, threads_: u8) !bool {
const PRP_BASE: usize = 2;
var N: gmp.mpz_t = u_zero.calculate_N(k, n);
const n_digits = gmp.mpz_sizeinbase(&N, 10);
log("Fermat {}-PRP testing: {}*{}^{}{} [{} digits] on {} threads\n", .{ PRP_BASE, k, b, n, c_, n_digits, threads_ });
var N_min_1: gmp.mpz_t = undefined;
gmp.mpz_init_set(&N_min_1, &N);
gmp.mpz_sub_ui(&N_min_1, &N_min_1, 1);
const N_min_1_bits = gmp.mpz_sizeinbase(&N_min_1, 2);
var gmp_one: gmp.mpz_t = undefined;
gmp.mpz_init_set_ui(&gmp_one, 1);
var gmp_base: gmp.mpz_t = undefined;
gmp.mpz_init_set_ui(&gmp_base, PRP_BASE);
var ctx: gw.gwhandle = undefined;
helper.create_gwhandle(&ctx, threads_, k, n);
var buf: gw.gwnum = gw.gwalloc(&ctx);
glue.gmp_to_gw(gmp_one, buf, &ctx);
var gw_base: gw.gwnum = gw.gwalloc(&ctx);
glue.gmp_to_gw(gmp_base, gw_base, &ctx);
var gw_one: gw.gwnum = gw.gwalloc(&ctx);
glue.gmp_to_gw(gmp_one, gw_one, &ctx);
var i: usize = N_min_1_bits - 1;
// we activate this with the setting of ctx.NORMNUM
var near_fft = false;
var errored = false;
gw.gwsetmulbyconst(&ctx, PRP_BASE);
ctx.NORMNUM = 0;
while (i <= N_min_1_bits) : (_ = @subWithOverflow(usize, i, 1, &i)) {
if (i == 1 and 1 == gw.gwequal(&ctx, buf, gw_one)) {
log("!!! SANITY CHECK FAILED, PREMATURE PRP STATUS, THIS IS A BUG\n", .{});
}
// allow for 64 bit k to mangle the first bits
// this if/else allows us to not check bits in most of the number
const optimized_mult = i < N_min_1_bits - helper.min(usize, 64, N_min_1_bits) and N_min_1_bits >= 64;
// first log2(k) bits _have_ to be handled here
// FIXME: the optimized case does not work for small numbers, eg. 3*2^11-1
if (!optimized_mult) {
const bit_set = gmp.mpz_tstbit(&N_min_1, i) == 1;
if (i < 50 or i > N_min_1_bits - 50) {
gw.gwsquare2_carefully(&ctx, buf, buf);
} else {
gw.gwsquare2(&ctx, buf, buf);
}
if (bit_set) {
gw.gwsmallmul(&ctx, PRP_BASE, buf);
}
} else {
// here we assume all bits are set (b/c we have Riesel numbers, they have all 1's after a point)
ctx.NORMNUM = 3;
if (i == 0) {
// turn off const multiplication for last bit, b/c it's 0 for some reason
const bit_set = gmp.mpz_tstbit(&N_min_1, i) == 1;
ctx.NORMNUM = 0;
}
if (i > 50 and i < N_min_1_bits - 50) {
gw.gwstartnextfft(&ctx, 1);
} else {
gw.gwstartnextfft(&ctx, 0);
}
const careful = i < 50 or i > N_min_1_bits - 49;
if (careful) {
gw.gwsquare2_carefully(&ctx, buf, buf);
} else {
gw.gwsquare2(&ctx, buf, buf);
}
}
// check if near fft limit
if (gw.gwnear_fft_limit(&ctx, 0.5) != 0) {
if (!near_fft) {
log("WARNING: near FFT limit @ {}\n", .{i});
near_fft = true;
}
}
// error_check
if (true) {
if (gw.gw_test_illegal_sumout(&ctx) != 0) {
errored = true;
log("ERROR: illegal sumout @ {}\n", .{i});
}
if (gw.gw_test_mismatched_sums(&ctx) != 0) {
errored = true;
log("ERROR: mismatched sums @ {}\n", .{i});
}
if (gw.gw_get_maxerr(&ctx) >= 0.40) {
errored = true;
log("ERROR: maxerr > 0.4 @ {} = {}\n", .{ i, gw.gw_get_maxerr(&ctx) });
}
}
}
var is_prp = gw.gwequal(&ctx, buf, gw_one);
if (is_prp == 1) {
const maybe = "maybe";
log("#> {}*{}^{}{} [{} digits] IS {}-PRP!\n", .{ k, b, n, c_, n_digits, PRP_BASE });
} else {
log("#> {}*{}^{}{} [{} digits] is not prime ({})\n", .{
k,
b,
n,
c_,
n_digits,
is_prp,
});
}
return is_prp == 1;
} | fermat.zig |
const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const bog = @import("bog.zig");
const Value = bog.Value;
const expect = std.testing.expect;
//! A non-moving garbage collector.
//! Inspired by https://www.pllab.riec.tohoku.ac.jp/papers/icfp2011UenoOhoriOtomoAuthorVersion.pdf
/// A pool of values prefixed with a header containing two bitmaps for
/// the old and young generation.
const Page = struct {
const max_size = 1_048_576;
comptime {
// 2^20, 1 MiB
assert(@sizeOf(Page) == max_size);
}
const val_count = 25_574;
const pad_size = max_size - @sizeOf(u32) - (@sizeOf(Value) + @sizeOf(State)) * val_count;
const State = packed enum(u8) {
empty = 0,
white,
gray,
black,
};
/// States of all values.
meta: [val_count]State,
/// Padding to ensure size is 1 MiB.
__padding: [pad_size]u8 = @compileError("do not initiate directly"),
/// Index to the first free slot.
free: u32,
/// Actual values, all pointers will stay valid as long as they are
/// referenced from a root.
values: [val_count]Value,
fn create() !*Page {
const page = try std.heap.page_allocator.create(Page);
mem.set(usize, mem.bytesAsSlice(usize, mem.asBytes(page)), 0);
return page;
}
fn deinit(page: *Page, gc: *Gc) void {
for (page.meta) |s, i| {
if (s == .empty) continue;
page.values[i].deinit(gc.gpa);
}
std.heap.page_allocator.destroy(page);
}
fn alloc(page: *Page) ?*Value {
while (page.free < page.values.len) {
defer page.free += 1;
if (page.meta[page.free] == .empty) {
page.meta[page.free] = .white;
return &page.values[page.free];
}
}
return null;
}
fn clear(page: *Page, gc: *Gc) u32 {
var freed: u32 = 0;
for (page.meta) |s, i| {
switch (s) {
.black, .gray => {
// value lives to see another day
page.meta[i] = .white;
},
.white => {
freed += 1;
page.meta[i] = .empty;
page.values[i].deinit(gc.gpa);
if (page.free > i) {
page.free = @truncate(u32, i);
}
},
.empty => {},
}
}
return freed;
}
};
const Gc = @This();
pages: std.ArrayListUnmanaged(*Page) = .{},
stack: std.ArrayListUnmanaged(?*Value) = .{},
gpa: *Allocator,
page_limit: u32,
stack_protect_start: usize = 0,
const PageAndIndex = struct {
page: *Page,
index: usize,
};
fn findInPage(gc: *Gc, value: *const Value) ?PageAndIndex {
// These will never be allocated
if (value == &Value.None or
value == &Value.True or
value == &Value.False) return null;
for (gc.pages.items) |page| {
// is the value before this page
if (@ptrToInt(value) < @ptrToInt(&page.values[0])) continue;
// is the value after this page
if (@ptrToInt(value) > @ptrToInt(&page.values[page.values.len - 1])) continue;
// value is in this page
return PageAndIndex{
.page = page,
// calculate index from offset from `Page.values`
.index = (@ptrToInt(value) - @ptrToInt(&page.values[0])) / @sizeOf(Value),
};
}
return null; // value was not allocated by the gc.
}
fn markVal(gc: *Gc, value: *const Value) void {
const loc = gc.findInPage(value) orelse return;
if (loc.page.meta[loc.index] == .white) {
loc.page.meta[loc.index] = .gray;
}
}
fn markGray(gc: *Gc) void {
// mark all white values reachable from gray values as gray
for (gc.pages.items) |page| {
for (page.meta) |*s, i| {
if (s.* == .gray) {
s.* = .black;
switch (page.values[i]) {
.list => |list| {
for (list.items) |val| {
gc.markVal(val);
}
},
.tuple => |tuple| {
for (tuple) |val| {
gc.markVal(val);
}
},
.map => |map| {
for (map.items()) |*entry| {
gc.markVal(entry.key);
gc.markVal(entry.value);
}
},
.err => |err| {
gc.markVal(err);
},
.func => |func| {
for (func.captures) |val| {
gc.markVal(val);
}
},
.iterator => |iter| {
gc.markVal(iter.value);
},
.tagged => |tag| {
gc.markVal(tag.value);
},
// These values don't reference any other values
.native, .str, .int, .num, .range, .none, .bool => {},
}
}
}
}
}
/// Collect all unreachable values.
pub fn collect(gc: *Gc) usize {
// mark roots as reachable
for (gc.stack.items) |val| {
// beautiful
const loc = gc.findInPage(val orelse continue) orelse continue;
loc.page.meta[loc.index] = .gray;
}
if (gc.stack_protect_start != 0) {
var i = @intToPtr([*]*Value, gc.stack_protect_start);
while (@ptrToInt(i) > @frameAddress()) : (i -= 1) {
const loc = gc.findInPage(i[0]) orelse continue;
if (loc.page.meta[loc.index] != .empty) {
loc.page.meta[loc.index] = .gray;
}
}
}
// mark values referenced from root values as reachable
gc.markGray();
// free all unreachable values
var freed: usize = 0;
for (gc.pages.items) |page| {
freed += page.clear(gc);
}
return freed;
}
pub fn init(allocator: *Allocator, page_limit: u32) Gc {
std.debug.assert(page_limit >= 1);
return .{
.gpa = allocator,
.page_limit = page_limit,
};
}
/// Frees all values and their allocations.
pub fn deinit(gc: *Gc) void {
for (gc.pages.items) |page| page.deinit(gc);
gc.pages.deinit(gc.gpa);
gc.stack.deinit(gc.gpa);
}
/// Allocate a new Value on the heap.
pub fn alloc(gc: *Gc) !*Value {
if (gc.pages.items.len == 0) {
const page = try Page.create();
errdefer page.deinit(gc);
try gc.pages.append(gc.gpa, page);
// we just created this page so it is empty.
return page.alloc() orelse unreachable;
}
for (gc.pages.items) |page| {
if (page.alloc()) |some| return some;
}
const freed = gc.collect();
if (freed < Page.val_count / 4 and gc.pages.items.len != gc.page_limit) {
const page = try Page.create();
errdefer page.deinit(gc);
try gc.pages.append(gc.gpa, page);
// we just created this page so it is empty.
return page.alloc() orelse unreachable;
} else if (freed != 0) {
// we just freed over Page.val_count / 4, values, allocation cannot fail
return gc.alloc() catch unreachable;
}
// no values could be collected and page_limit has been reached
return error.OutOfMemory;
}
/// Allocates a shallow copy of `val`.
pub fn dupe(gc: *Gc, val: *const Value) !*Value {
// no need to copy always memoized values
switch (val.*) {
.none => return &Value.None,
.bool => |b| return if (b) &Value.True else &Value.False,
else => {},
}
const new = try gc.alloc();
switch (val.*) {
.list => |*l| {
new.* = .{ .list = .{} };
try new.list.appendSlice(gc.gpa, l.items);
},
.tuple => |t| {
new.* = .{ .tuple = try gc.gpa.dupe(*Value, t) };
},
.map => |*m| {
new.* = .{ .map = try m.clone(gc.gpa) };
},
.str => |*s| {
if (s.capacity != 0) {
new.* = Value.string(try gc.gpa.dupe(u8, s.data));
} else {
new.* = val.*;
}
},
else => new.* = val.*,
}
return new;
}
/// Get value from stack at `index`.
/// Returns `error.NullPtrDeref` if stack has no value at `index`.
pub fn stackGet(gc: *Gc, index: usize) !*Value {
if (index >= gc.stack.items.len)
return error.NullPtrDeref;
return gc.stack.items[index] orelse
error.NullPtrDeref;
}
/// Only valid until next `stackAlloc` call.
pub fn stackRef(gc: *Gc, index: usize) !*?*Value {
try gc.stack.ensureCapacity(gc.gpa, index + 1);
while (index >= gc.stack.items.len) {
gc.stack.appendAssumeCapacity(null);
}
return &gc.stack.items[index];
}
/// Allocates new value on stack, invalidates all references to stack values.
pub fn stackAlloc(gc: *Gc, index: usize) !*Value {
const val = try gc.stackRef(index);
if (val.*) |some| switch (some.*) {
.int, .num, .native, .tagged, .str => {},
else => val.* = try gc.alloc(),
} else {
val.* = try gc.alloc();
}
return val.*.?;
}
/// Shrinks stack to `size`, doesn't free any memory.
pub fn stackShrink(gc: *Gc, size: usize) void {
if (size > gc.stack.items.len) return;
gc.stack.items.len = size;
}
test "basic collect" {
var gc = Gc.init(std.testing.allocator, 1);
defer gc.deinit();
var tuple = try gc.stackAlloc(0);
tuple.* = .{ .tuple = try gc.gpa.alloc(*Value, 32) };
for (tuple.tuple) |*e, i| {
const val = try gc.alloc();
val.* = .{ .int = @intCast(i64, i) };
e.* = val;
}
var i: i64 = 0;
while (i < (1024 - 32 - 1 - 2)) : (i += 1) {
const val = try gc.alloc();
val.* = .{ .int = @intCast(i64, i) };
}
{
// self referencing values should be collected
const a = try gc.alloc();
const b = try gc.alloc();
a.* = .{ .err = b };
b.* = .{ .err = a };
}
expect(gc.pages.items[0].free == 1024);
expect(gc.collect() == 1024 - 32 - 1);
expect(gc.pages.items[0].free == 33);
}
test "major collection" {
var gc = Gc.init(std.testing.allocator, 2);
defer gc.deinit();
// ensure we allocate at least 2 pages.
const alloc_count = Page.val_count + Page.val_count / 2;
// create a looped chain of values
var i: i64 = 0;
var first: *Value = try gc.stackAlloc(0);
var prev: *Value = first;
while (i < alloc_count) : (i += 1) {
const val = try gc.alloc();
prev.* = .{ .err = val };
prev = val;
val.* = .{ .int = 1 };
}
prev.* = .{ .err = first };
gc.stack.items.len = 0;
expect(gc.collect() == alloc_count + 1);
}
test "stack protect" {
if (std.builtin.os.tag == .windows) {
// TODO @frameAddress returns an address after &val1 on windows?
return error.SkipZigTest;
}
var gc = Gc.init(std.testing.allocator, 2);
defer gc.deinit();
gc.stack_protect_start = @frameAddress();
var val1 = try gc.alloc();
var val2 = try gc.alloc();
expect(gc.collect() == 0);
gc.stack_protect_start = 0;
expect(gc.collect() == 2);
} | src/Gc.zig |
const std = @import("std");
const lexer = @import("tokenizer.zig");
const ast = @import("ast.zig");
const diag = @import("diagnostics.zig");
const Location = @import("location.zig").Location;
const EscapedStringIterator = @import("string-escaping.zig").EscapedStringIterator;
/// Parses a sequence of tokens into an abstract syntax tree.
/// Returns either a successfully parsed tree or puts all found
/// syntax errors into `diagnostics`.
pub fn parse(
allocator: *std.mem.Allocator,
diagnostics: *diag.Diagnostics,
sequence: []const lexer.Token,
) !ast.Program {
var arena = std.heap.ArenaAllocator.init(allocator);
errdefer arena.deinit();
var root_script = std.ArrayList(ast.Statement).init(&arena.allocator);
defer root_script.deinit();
var functions = std.ArrayList(ast.Function).init(&arena.allocator);
defer functions.deinit();
const Parser = struct {
const Self = @This();
const Predicate = fn (lexer.Token) bool;
const AcceptError = error{SyntaxError};
const ParseError = std.mem.Allocator.Error || AcceptError;
const SavedState = struct {
index: usize,
};
allocator: *std.mem.Allocator,
sequence: []const lexer.Token,
index: usize = 0,
diagnostics: *diag.Diagnostics,
fn emitDiagnostics(self: *Self, comptime fmt: []const u8, args: anytype) !error{SyntaxError} {
try self.diagnostics.emit(.@"error", self.getCurrentLocation(), fmt, args);
return error.SyntaxError;
}
fn getCurrentLocation(self: Self) Location {
return self.sequence[self.index].location;
}
/// Applies all known string escape codes
fn escapeString(self: Self, input: []const u8) ![]u8 {
var iterator = EscapedStringIterator.init(input);
var len: usize = 0;
while (try iterator.next()) |_| {
len += 1;
}
iterator = EscapedStringIterator.init(input);
const result = try self.allocator.alloc(u8, len);
var i: usize = 0;
while (iterator.next() catch unreachable) |c| {
result[i] = c;
i += 1;
}
std.debug.assert(i == len);
return result;
}
/// Create a save state that allows rewinding the parser process.
/// This should be used when a parsing function calls accept mulitple
/// times and may emit a syntax error.
/// The state should be restored in a errdefer.
fn saveState(self: Self) SavedState {
return SavedState{
.index = self.index,
};
}
/// Restores a previously created save state.
fn restoreState(self: *Self, state: SavedState) void {
self.index = state.index;
}
fn moveToHeap(self: *Self, value: anytype) !*@TypeOf(value) {
const T = @TypeOf(value);
std.debug.assert(@typeInfo(T) != .Pointer);
const ptr = try self.allocator.create(T);
ptr.* = value;
std.debug.assert(std.meta.eql(ptr.*, value));
return ptr;
}
fn any(token: lexer.Token) bool {
return true;
}
fn is(comptime kind: lexer.TokenType) Predicate {
return struct {
fn pred(token: lexer.Token) bool {
return token.type == kind;
}
}.pred;
}
fn oneOf(comptime kinds: anytype) Predicate {
return struct {
fn pred(token: lexer.Token) bool {
return inline for (kinds) |k| {
if (token.type == k)
break true;
} else false;
}
}.pred;
}
fn peek(self: Self) AcceptError!lexer.Token {
if (self.index >= self.sequence.len)
return error.SyntaxError;
return self.sequence[self.index];
}
fn accept(self: *Self, predicate: Predicate) AcceptError!lexer.Token {
if (self.index >= self.sequence.len)
return error.SyntaxError;
const tok = self.sequence[self.index];
if (predicate(tok)) {
self.index += 1;
return tok;
} else {
// std.debug.print("cannot accept {} here!\n", .{tok});
return error.SyntaxError;
}
}
fn acceptFunction(self: *Self) ParseError!ast.Function {
const state = self.saveState();
errdefer self.restoreState(state);
const initial_pos = try self.accept(is(.function));
const name = try self.accept(is(.identifier));
_ = try self.accept(is(.@"("));
var args = std.ArrayList([]const u8).init(self.allocator);
defer args.deinit();
while (true) {
const arg_or_end = try self.accept(oneOf(.{ .identifier, .@")" }));
switch (arg_or_end.type) {
.@")" => break,
.identifier => {
try args.append(arg_or_end.text);
const delimit = try self.accept(oneOf(.{ .@",", .@")" }));
if (delimit.type == .@")")
break;
},
else => unreachable,
}
}
const block = try self.acceptBlock();
return ast.Function{
.location = initial_pos.location,
.name = name.text,
.parameters = args.toOwnedSlice(),
.body = block,
};
}
fn acceptBlock(self: *Self) ParseError!ast.Statement {
const state = self.saveState();
errdefer self.restoreState(state);
const begin = try self.accept(is(.@"{"));
var body = std.ArrayList(ast.Statement).init(self.allocator);
defer body.deinit();
while (true) {
const stmt = self.acceptStatement() catch break;
try body.append(stmt);
}
const end = try self.accept(is(.@"}"));
return ast.Statement{
.location = begin.location,
.type = .{
.block = body.toOwnedSlice(),
},
};
}
fn acceptStatement(self: *Self) ParseError!ast.Statement {
const state = self.saveState();
errdefer self.restoreState(state);
const start = try self.peek();
switch (start.type) {
.@";" => {
_ = try self.accept(is(.@";"));
return ast.Statement{
.location = start.location,
.type = .empty,
};
},
.@"break" => {
_ = try self.accept(is(.@"break"));
_ = try self.accept(is(.@";"));
return ast.Statement{
.location = start.location,
.type = .@"break",
};
},
.@"continue" => {
_ = try self.accept(is(.@"continue"));
_ = try self.accept(is(.@";"));
return ast.Statement{
.location = start.location,
.type = .@"continue",
};
},
.@"{" => {
return try self.acceptBlock();
},
.@"while" => {
_ = try self.accept(is(.@"while"));
_ = try self.accept(is(.@"("));
const condition = try self.acceptExpression();
_ = try self.accept(is(.@")"));
const body = try self.acceptBlock();
return ast.Statement{
.location = start.location,
.type = .{
.while_loop = .{
.condition = condition,
.body = try self.moveToHeap(body),
},
},
};
},
.@"if" => {
_ = try self.accept(is(.@"if"));
_ = try self.accept(is(.@"("));
const condition = try self.acceptExpression();
_ = try self.accept(is(.@")"));
const true_body = try self.acceptStatement();
if (self.accept(is(.@"else"))) |_| {
const false_body = try self.acceptStatement();
return ast.Statement{
.location = start.location,
.type = .{
.if_statement = .{
.condition = condition,
.true_body = try self.moveToHeap(true_body),
.false_body = try self.moveToHeap(false_body),
},
},
};
} else |_| {
return ast.Statement{
.location = start.location,
.type = .{
.if_statement = .{
.condition = condition,
.true_body = try self.moveToHeap(true_body),
.false_body = null,
},
},
};
}
},
.@"for" => {
_ = try self.accept(is(.@"for"));
_ = try self.accept(is(.@"("));
const name = try self.accept(is(.identifier));
_ = try self.accept(is(.in));
const source = try self.acceptExpression();
_ = try self.accept(is(.@")"));
const body = try self.acceptBlock();
return ast.Statement{
.location = start.location,
.type = .{
.for_loop = .{
.variable = name.text,
.source = source,
.body = try self.moveToHeap(body),
},
},
};
},
.@"return" => {
_ = try self.accept(is(.@"return"));
if (self.accept(is(.@";"))) |_| {
return ast.Statement{
.location = start.location,
.type = .return_void,
};
} else |_| {
const value = try self.acceptExpression();
_ = try self.accept(is(.@";"));
return ast.Statement{
.location = start.location,
.type = .{
.return_expr = value,
},
};
}
},
.@"var", .@"const" => {
const decl_type = try self.accept(oneOf(.{ .@"var", .@"const" }));
const name = try self.accept(is(.identifier));
const decider = try self.accept(oneOf(.{ .@";", .@"=" }));
var stmt = ast.Statement{
.location = start.location.merge(name.location),
.type = .{
.declaration = .{
.variable = name.text,
.initial_value = null,
.is_const = (decl_type.type == .@"const"),
},
},
};
if (decider.type == .@"=") {
const value = try self.acceptExpression();
_ = try self.accept(is(.@";"));
stmt.type.declaration.initial_value = value;
}
return stmt;
},
else => {
const expr = try self.acceptExpression();
if ((expr.type == .function_call) or (expr.type == .method_call)) {
_ = try self.accept(is(.@";"));
return ast.Statement{
.location = expr.location,
.type = .{
.discard_value = expr,
},
};
} else {
const mode = try self.accept(oneOf(.{
.@"=",
.@"+=",
.@"-=",
.@"*=",
.@"/=",
.@"%=",
}));
const value = try self.acceptExpression();
_ = try self.accept(is(.@";"));
return switch (mode.type) {
.@"+=", .@"-=", .@"*=", .@"/=", .@"%=" => ast.Statement{
.location = expr.location,
.type = .{
.assignment = .{
.target = expr,
.value = ast.Expression{
.location = expr.location,
.type = .{
.binary_operator = .{
.operator = switch (mode.type) {
.@"+=" => .add,
.@"-=" => .subtract,
.@"*=" => .multiply,
.@"/=" => .divide,
.@"%=" => .modulus,
else => unreachable,
},
.lhs = try self.moveToHeap(expr),
.rhs = try self.moveToHeap(value),
},
},
},
},
},
},
.@"=" => ast.Statement{
.location = expr.location,
.type = .{
.assignment = .{
.target = expr,
.value = value,
},
},
},
else => unreachable,
};
}
},
}
}
fn acceptExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
return try self.acceptLogicCombinatorExpression();
}
fn acceptLogicCombinatorExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var expr = try self.acceptComparisonExpression();
while (true) {
var and_or = self.accept(oneOf(.{ .@"and", .@"or" })) catch break;
var rhs = try self.acceptComparisonExpression();
var new_expr = ast.Expression{
.location = expr.location.merge(and_or.location).merge(rhs.location),
.type = .{
.binary_operator = .{
.operator = switch (and_or.type) {
.@"and" => .boolean_and,
.@"or" => .boolean_or,
else => unreachable,
},
.lhs = try self.moveToHeap(expr),
.rhs = try self.moveToHeap(rhs),
},
},
};
expr = new_expr;
}
return expr;
}
fn acceptComparisonExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var expr = try self.acceptSumExpression();
while (true) {
var and_or = self.accept(oneOf(.{
.@"<=",
.@">=",
.@">",
.@"<",
.@"==",
.@"!=",
})) catch break;
var rhs = try self.acceptSumExpression();
var new_expr = ast.Expression{
.location = expr.location.merge(and_or.location).merge(rhs.location),
.type = .{
.binary_operator = .{
.operator = switch (and_or.type) {
.@"<=" => .less_or_equal_than,
.@">=" => .greater_or_equal_than,
.@">" => .greater_than,
.@"<" => .less_than,
.@"==" => .equal,
.@"!=" => .different,
else => unreachable,
},
.lhs = try self.moveToHeap(expr),
.rhs = try self.moveToHeap(rhs),
},
},
};
expr = new_expr;
}
return expr;
}
fn acceptSumExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var expr = try self.acceptMulExpression();
while (true) {
var and_or = self.accept(oneOf(.{
.@"+",
.@"-",
})) catch break;
var rhs = try self.acceptMulExpression();
var new_expr = ast.Expression{
.location = expr.location.merge(and_or.location).merge(rhs.location),
.type = .{
.binary_operator = .{
.operator = switch (and_or.type) {
.@"+" => .add,
.@"-" => .subtract,
else => unreachable,
},
.lhs = try self.moveToHeap(expr),
.rhs = try self.moveToHeap(rhs),
},
},
};
expr = new_expr;
}
return expr;
}
fn acceptMulExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var expr = try self.acceptUnaryPrefixOperatorExpression();
while (true) {
var and_or = self.accept(oneOf(.{
.@"*",
.@"/",
.@"%",
})) catch break;
var rhs = try self.acceptUnaryPrefixOperatorExpression();
var new_expr = ast.Expression{
.location = expr.location.merge(and_or.location).merge(rhs.location),
.type = .{
.binary_operator = .{
.operator = switch (and_or.type) {
.@"*" => .multiply,
.@"/" => .divide,
.@"%" => .modulus,
else => unreachable,
},
.lhs = try self.moveToHeap(expr),
.rhs = try self.moveToHeap(rhs),
},
},
};
expr = new_expr;
}
return expr;
}
fn acceptUnaryPrefixOperatorExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
if (self.accept(oneOf(.{ .@"not", .@"-" }))) |prefix| {
// this must directly recurse as we can write `not not x`
const value = try self.acceptUnaryPrefixOperatorExpression();
return ast.Expression{
.location = prefix.location.merge(value.location),
.type = .{
.unary_operator = .{
.operator = switch (prefix.type) {
.@"not" => .boolean_not,
.@"-" => .negate,
else => unreachable,
},
.value = try self.moveToHeap(value),
},
},
};
} else |_| {
return try self.acceptIndexingExpression();
}
}
fn acceptIndexingExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var value = try self.acceptCallExpression();
while (self.accept(is(.@"["))) |_| {
const index = try self.acceptExpression();
_ = try self.accept(is(.@"]"));
var new_value = ast.Expression{
.location = value.location.merge(index.location),
.type = .{
.array_indexer = .{
.value = try self.moveToHeap(value),
.index = try self.moveToHeap(index),
},
},
};
value = new_value;
} else |_| {}
return value;
}
fn acceptCallExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
var value = try self.acceptValueExpression();
while (self.accept(oneOf(.{ .@"(", .@"." }))) |sym| {
var new_value = switch (sym.type) {
// call
.@"(" => blk: {
var args = std.ArrayList(ast.Expression).init(self.allocator);
defer args.deinit();
var loc = value.location;
if (self.accept(is(.@")"))) |_| {
// this is the end of the argument list
} else |_| {
while (true) {
const arg = try self.acceptExpression();
try args.append(arg);
const terminator = try self.accept(oneOf(.{ .@")", .@"," }));
loc = terminator.location.merge(loc);
if (terminator.type == .@")")
break;
}
}
break :blk ast.Expression{
.location = loc,
.type = .{
.function_call = .{
.function = try self.moveToHeap(value),
.arguments = args.toOwnedSlice(),
},
},
};
},
// method call
.@"." => blk: {
const method_name = try self.accept(is(.identifier));
_ = try self.accept(is(.@"("));
var args = std.ArrayList(ast.Expression).init(self.allocator);
defer args.deinit();
var loc = value.location;
if (self.accept(is(.@")"))) |_| {
// this is the end of the argument list
} else |_| {
while (true) {
const arg = try self.acceptExpression();
try args.append(arg);
const terminator = try self.accept(oneOf(.{ .@")", .@"," }));
loc = terminator.location.merge(loc);
if (terminator.type == .@")")
break;
}
}
break :blk ast.Expression{
.location = loc,
.type = .{
.method_call = .{
.object = try self.moveToHeap(value),
.name = method_name.text,
.arguments = args.toOwnedSlice(),
},
},
};
},
else => unreachable,
};
value = new_value;
} else |_| {}
return value;
}
fn acceptValueExpression(self: *Self) ParseError!ast.Expression {
const state = self.saveState();
errdefer self.restoreState(state);
const token = try self.accept(oneOf(.{
.@"(",
.@"[",
.number_literal,
.string_literal,
.character_literal,
.identifier,
}));
switch (token.type) {
.@"(" => {
const value = try self.acceptExpression();
_ = try self.accept(is(.@")"));
return value;
},
.@"[" => {
var array = std.ArrayList(ast.Expression).init(self.allocator);
defer array.deinit();
while (true) {
if (self.accept(is(.@"]"))) |_| {
break;
} else |_| {
const item = try self.acceptExpression();
try array.append(item);
const delimit = try self.accept(oneOf(.{ .@",", .@"]" }));
if (delimit.type == .@"]")
break;
}
}
return ast.Expression{
.location = token.location,
.type = .{
.array_literal = array.toOwnedSlice(),
},
};
},
.number_literal => {
const val = if (std.mem.startsWith(u8, token.text, "0x"))
@intToFloat(f64, std.fmt.parseInt(i54, token.text[2..], 16) catch return try self.emitDiagnostics("`{}` is not a valid hexadecimal number!", .{token.text}))
else
std.fmt.parseFloat(f64, token.text) catch return try self.emitDiagnostics("`{}` is not a valid number!", .{token.text});
return ast.Expression{
.location = token.location,
.type = .{
.number_literal = val,
},
};
},
.string_literal => {
std.debug.assert(token.text.len >= 2);
return ast.Expression{
.location = token.location,
.type = .{
.string_literal = self.escapeString(token.text[1 .. token.text.len - 1]) catch return try self.emitDiagnostics("Invalid escape sequence in {}!", .{token.text}),
},
};
},
.character_literal => {
std.debug.assert(token.text.len >= 2);
const escaped_text = self.escapeString(token.text[1 .. token.text.len - 1]) catch return try self.emitDiagnostics("Invalid escape sequence in {}!", .{token.text});
var value: u21 = undefined;
if (escaped_text.len == 0) {
return error.SyntaxError;
} else if (escaped_text.len == 1) {
// this is a shortcut for non-utf8 encoded files.
// it's not a perfect heuristic, but it's okay.
value = escaped_text[0];
} else {
const utf8_len = std.unicode.utf8ByteSequenceLength(escaped_text[0]) catch return try self.emitDiagnostics("Invalid utf8 sequence: `{}`!", .{escaped_text});
if (escaped_text.len != utf8_len)
return error.SyntaxError;
value = std.unicode.utf8Decode(escaped_text[0..utf8_len]) catch return try self.emitDiagnostics("Invalid utf8 sequence: `{}`!", .{escaped_text});
}
return ast.Expression{
.location = token.location,
.type = .{
.number_literal = @intToFloat(f64, value),
},
};
},
.identifier => return ast.Expression{
.location = token.location,
.type = .{
.variable_expr = token.text,
},
},
else => unreachable,
}
}
};
var parser = Parser{
.allocator = &arena.allocator,
.sequence = sequence,
.diagnostics = diagnostics,
};
while (parser.index < parser.sequence.len) {
const state = parser.saveState();
// look-ahead one token and try accepting a "function" keyword,
// use that to select between parsing a function or a statement.
if (parser.accept(Parser.is(.function))) |_| {
// we need to unaccept the function token
parser.restoreState(state);
const fun = try parser.acceptFunction();
try functions.append(fun);
} else |_| {
// no need to unaccept here as we didn't accept in the first place
const stmt = parser.acceptStatement() catch |err| switch (err) {
error.SyntaxError => {
// Do some recovery here:
try diagnostics.emit(.@"error", parser.getCurrentLocation(), "syntax error!", .{});
while (parser.index < parser.sequence.len) {
const recovery_state = parser.saveState();
const tok = try parser.accept(Parser.any);
if (tok.type == .@";")
break;
// We want to be able to parse the next function properly
// even if we have syntax errors.
if (tok.type == .function) {
parser.restoreState(recovery_state);
break;
}
}
continue;
},
else => |e| return e,
};
try root_script.append(stmt);
}
}
return ast.Program{
.arena = arena,
.root_script = root_script.toOwnedSlice(),
.functions = functions.toOwnedSlice(),
};
}
fn testTokenize(str: []const u8) ![]lexer.Token {
var result = std.ArrayList(lexer.Token).init(std.testing.allocator);
var tokenizer = lexer.Tokenizer.init("testsrc", str);
while (true) {
switch (tokenizer.next()) {
.end_of_file => return result.toOwnedSlice(),
.invalid_sequence => unreachable, // we don't do that here
.token => |token| try result.append(token),
}
}
}
test "empty file parsing" {
var diagnostics = diag.Diagnostics.init(std.testing.allocator);
defer diagnostics.deinit();
var pgm = try parse(std.testing.allocator, &diagnostics, &[_]lexer.Token{});
defer pgm.deinit();
// assert that an empty file results in a empty AST
std.testing.expectEqual(@as(usize, 0), pgm.root_script.len);
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
// assert that we didn't encounter syntax errors
std.testing.expectEqual(@as(usize, 0), diagnostics.messages.items.len);
}
fn parseTest(string: []const u8) !ast.Program {
const seq = try testTokenize(string);
defer std.testing.allocator.free(seq);
var diagnostics = diag.Diagnostics.init(std.testing.allocator);
defer diagnostics.deinit();
return try parse(std.testing.allocator, &diagnostics, seq);
}
test "parse single top level statement" {
// test with the simplest of all statements:
// the empty one
var pgm = try parseTest(";");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[0].type);
}
test "parse single empty function" {
// 0 params
{
var pgm = try parseTest("function empty(){}");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 1), pgm.functions.len);
std.testing.expectEqual(@as(usize, 0), pgm.root_script.len);
const fun = pgm.functions[0];
std.testing.expectEqualStrings("empty", fun.name);
std.testing.expectEqual(ast.Statement.Type.block, fun.body.type);
std.testing.expectEqual(@as(usize, 0), fun.body.type.block.len);
std.testing.expectEqual(@as(usize, 0), fun.parameters.len);
}
// 1 param
{
var pgm = try parseTest("function empty(p0){}");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 1), pgm.functions.len);
std.testing.expectEqual(@as(usize, 0), pgm.root_script.len);
const fun = pgm.functions[0];
std.testing.expectEqualStrings("empty", fun.name);
std.testing.expectEqual(ast.Statement.Type.block, fun.body.type);
std.testing.expectEqual(@as(usize, 0), fun.body.type.block.len);
std.testing.expectEqual(@as(usize, 1), fun.parameters.len);
std.testing.expectEqualStrings("p0", fun.parameters[0]);
}
// 3 param
{
var pgm = try parseTest("function empty(p0,p1,p2){}");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 1), pgm.functions.len);
std.testing.expectEqual(@as(usize, 0), pgm.root_script.len);
const fun = pgm.functions[0];
std.testing.expectEqualStrings("empty", fun.name);
std.testing.expectEqual(ast.Statement.Type.block, fun.body.type);
std.testing.expectEqual(@as(usize, 0), fun.body.type.block.len);
std.testing.expectEqual(@as(usize, 3), fun.parameters.len);
std.testing.expectEqualStrings("p0", fun.parameters[0]);
std.testing.expectEqualStrings("p1", fun.parameters[1]);
std.testing.expectEqualStrings("p2", fun.parameters[2]);
}
}
test "parse multiple top level statements" {
// test with the simplest of all statements:
// the empty one
var pgm = try parseTest(";;;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 3), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[1].type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[2].type);
}
test "parse mixed function and top level statement" {
var pgm = try parseTest(";function n(){};");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 1), pgm.functions.len);
std.testing.expectEqual(@as(usize, 2), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[1].type);
const fun = pgm.functions[0];
std.testing.expectEqualStrings("n", fun.name);
std.testing.expectEqual(ast.Statement.Type.block, fun.body.type);
std.testing.expectEqual(@as(usize, 0), fun.body.type.block.len);
std.testing.expectEqual(@as(usize, 0), fun.parameters.len);
}
test "nested blocks" {
var pgm = try parseTest(
\\{ }
\\{
\\ { ; }
\\ { ; ; }
\\ ;
\\}
\\{ }
);
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 3), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[1].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[2].type);
std.testing.expectEqual(@as(usize, 0), pgm.root_script[0].type.block.len);
std.testing.expectEqual(@as(usize, 3), pgm.root_script[1].type.block.len);
std.testing.expectEqual(@as(usize, 0), pgm.root_script[2].type.block.len);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[1].type.block[0].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[1].type.block[1].type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[1].type.block[2].type);
std.testing.expectEqual(@as(usize, 1), pgm.root_script[1].type.block[0].type.block.len);
std.testing.expectEqual(@as(usize, 2), pgm.root_script[1].type.block[1].type.block.len);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[1].type.block[1].type.block[0].type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[1].type.block[1].type.block[0].type);
}
test "nested blocks in functions" {
var pgm = try parseTest(
\\function foo() {
\\ { }
\\ {
\\ { ; }
\\ { ; ; }
\\ ;
\\ }
\\ { }
\\}
);
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 1), pgm.functions.len);
std.testing.expectEqual(@as(usize, 0), pgm.root_script.len);
const fun = pgm.functions[0];
std.testing.expectEqual(ast.Statement.Type.block, fun.body.type);
const items = fun.body.type.block;
std.testing.expectEqual(ast.Statement.Type.block, items[0].type);
std.testing.expectEqual(ast.Statement.Type.block, items[1].type);
std.testing.expectEqual(ast.Statement.Type.block, items[2].type);
std.testing.expectEqual(@as(usize, 0), items[0].type.block.len);
std.testing.expectEqual(@as(usize, 3), items[1].type.block.len);
std.testing.expectEqual(@as(usize, 0), items[2].type.block.len);
std.testing.expectEqual(ast.Statement.Type.block, items[1].type.block[0].type);
std.testing.expectEqual(ast.Statement.Type.block, items[1].type.block[1].type);
std.testing.expectEqual(ast.Statement.Type.empty, items[1].type.block[2].type);
std.testing.expectEqual(@as(usize, 1), items[1].type.block[0].type.block.len);
std.testing.expectEqual(@as(usize, 2), items[1].type.block[1].type.block.len);
std.testing.expectEqual(ast.Statement.Type.empty, items[1].type.block[1].type.block[0].type);
std.testing.expectEqual(ast.Statement.Type.empty, items[1].type.block[1].type.block[0].type);
}
test "parsing break" {
var pgm = try parseTest("break;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.@"break", pgm.root_script[0].type);
}
test "parsing continue" {
var pgm = try parseTest("continue;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.@"continue", pgm.root_script[0].type);
}
test "parsing while" {
var pgm = try parseTest("while(1) { }");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.while_loop, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[0].type.while_loop.body.type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.while_loop.condition.type);
}
test "parsing for" {
var pgm = try parseTest("for(name in 1) { }");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.for_loop, pgm.root_script[0].type);
std.testing.expectEqualStrings("name", pgm.root_script[0].type.for_loop.variable);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[0].type.for_loop.body.type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.for_loop.source.type);
}
test "parsing single if" {
var pgm = try parseTest("if(1) { }");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.if_statement, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[0].type.if_statement.true_body.type);
std.testing.expectEqual(@as(?*ast.Statement, null), pgm.root_script[0].type.if_statement.false_body);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.if_statement.condition.type);
}
test "parsing if-else" {
var pgm = try parseTest("if(1) { } else ;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.if_statement, pgm.root_script[0].type);
std.testing.expectEqual(ast.Statement.Type.block, pgm.root_script[0].type.if_statement.true_body.type);
std.testing.expectEqual(ast.Statement.Type.empty, pgm.root_script[0].type.if_statement.false_body.?.type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.if_statement.condition.type);
}
test "parsing return (void)" {
var pgm = try parseTest("return;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.return_void, pgm.root_script[0].type);
}
test "parsing return (value)" {
var pgm = try parseTest("return 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.return_expr, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.return_expr.type);
}
test "parsing var declaration (no value)" {
var pgm = try parseTest("var name;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.declaration, pgm.root_script[0].type);
std.testing.expectEqualStrings("name", pgm.root_script[0].type.declaration.variable);
std.testing.expectEqual(false, pgm.root_script[0].type.declaration.is_const);
std.testing.expectEqual(@as(?ast.Expression, null), pgm.root_script[0].type.declaration.initial_value);
}
test "parsing var declaration (initial value)" {
var pgm = try parseTest("var name = 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.declaration, pgm.root_script[0].type);
std.testing.expectEqualStrings("name", pgm.root_script[0].type.declaration.variable);
std.testing.expectEqual(false, pgm.root_script[0].type.declaration.is_const);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.declaration.initial_value.?.type);
}
test "parsing const declaration (no value)" {
var pgm = try parseTest("const name;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.declaration, pgm.root_script[0].type);
std.testing.expectEqualStrings("name", pgm.root_script[0].type.declaration.variable);
std.testing.expectEqual(true, pgm.root_script[0].type.declaration.is_const);
std.testing.expectEqual(@as(?ast.Expression, null), pgm.root_script[0].type.declaration.initial_value);
}
test "parsing const declaration (initial value)" {
var pgm = try parseTest("const name = 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.declaration, pgm.root_script[0].type);
std.testing.expectEqualStrings("name", pgm.root_script[0].type.declaration.variable);
std.testing.expectEqual(true, pgm.root_script[0].type.declaration.is_const);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.declaration.initial_value.?.type);
}
test "parsing assignment" {
var pgm = try parseTest("1 = 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.value.type);
}
test "parsing operator-assignment addition" {
var pgm = try parseTest("1 += 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.binary_operator, pgm.root_script[0].type.assignment.value.type);
std.testing.expectEqual(ast.BinaryOperator.add, pgm.root_script[0].type.assignment.value.type.binary_operator.operator);
}
test "parsing operator-assignment subtraction" {
var pgm = try parseTest("1 -= 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.binary_operator, pgm.root_script[0].type.assignment.value.type);
std.testing.expectEqual(ast.BinaryOperator.subtract, pgm.root_script[0].type.assignment.value.type.binary_operator.operator);
}
test "parsing operator-assignment multiplication" {
var pgm = try parseTest("1 *= 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.binary_operator, pgm.root_script[0].type.assignment.value.type);
std.testing.expectEqual(ast.BinaryOperator.multiply, pgm.root_script[0].type.assignment.value.type.binary_operator.operator);
}
test "parsing operator-assignment division" {
var pgm = try parseTest("1 /= 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.binary_operator, pgm.root_script[0].type.assignment.value.type);
std.testing.expectEqual(ast.BinaryOperator.divide, pgm.root_script[0].type.assignment.value.type.binary_operator.operator);
}
test "parsing operator-assignment modulus" {
var pgm = try parseTest("1 %= 1;");
defer pgm.deinit();
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Statement.Type.assignment, pgm.root_script[0].type);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
std.testing.expectEqual(ast.Expression.Type.binary_operator, pgm.root_script[0].type.assignment.value.type);
std.testing.expectEqual(ast.BinaryOperator.modulus, pgm.root_script[0].type.assignment.value.type.binary_operator.operator);
}
/// Parse a program with `1 = $(EXPR)`, will return `$(EXPR)`
fn getTestExpr(pgm: ast.Program) ast.Expression {
std.testing.expectEqual(@as(usize, 0), pgm.functions.len);
std.testing.expectEqual(@as(usize, 1), pgm.root_script.len);
std.testing.expectEqual(ast.Expression.Type.number_literal, pgm.root_script[0].type.assignment.target.type);
var expr = pgm.root_script[0].type.assignment.value;
return expr;
}
test "integer literal" {
var pgm = try parseTest("1 = 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.number_literal, expr.type);
std.testing.expectWithinEpsilon(@as(f64, 1), expr.type.number_literal, 0.000001);
}
test "decimal literal" {
var pgm = try parseTest("1 = 1.0;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.number_literal, expr.type);
std.testing.expectWithinEpsilon(@as(f64, 1), expr.type.number_literal, 0.000001);
}
test "hexadecimal literal" {
var pgm = try parseTest("1 = 0x1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.number_literal, expr.type);
std.testing.expectWithinEpsilon(@as(f64, 1), expr.type.number_literal, 0.000001);
}
test "string literal" {
var pgm = try parseTest("1 = \"string content\";");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.string_literal, expr.type);
std.testing.expectEqualStrings("string content", expr.type.string_literal);
}
test "escaped string literal" {
var pgm = try parseTest("1 = \"\\\"content\\\"\";");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.string_literal, expr.type);
std.testing.expectEqualStrings("\"content\"", expr.type.string_literal);
}
test "character literal" {
var pgm = try parseTest("1 = ' ';");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.number_literal, expr.type);
std.testing.expectEqual(@as(f64, ' '), expr.type.number_literal);
}
test "variable reference" {
var pgm = try parseTest("1 = variable_name;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type);
std.testing.expectEqualStrings("variable_name", expr.type.variable_expr);
}
test "addition expression" {
var pgm = try parseTest("1 = 1 + 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.add, expr.type.binary_operator.operator);
}
test "subtraction expression" {
var pgm = try parseTest("1 = 1 - 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.subtract, expr.type.binary_operator.operator);
}
test "multiplication expression" {
var pgm = try parseTest("1 = 1 * 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.multiply, expr.type.binary_operator.operator);
}
test "division expression" {
var pgm = try parseTest("1 = 1 / 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.divide, expr.type.binary_operator.operator);
}
test "modulus expression" {
var pgm = try parseTest("1 = 1 % 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.modulus, expr.type.binary_operator.operator);
}
test "boolean or expression" {
var pgm = try parseTest("1 = 1 or 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.boolean_or, expr.type.binary_operator.operator);
}
test "boolean and expression" {
var pgm = try parseTest("1 = 1 and 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.boolean_and, expr.type.binary_operator.operator);
}
test "greater than expression" {
var pgm = try parseTest("1 = 1 > 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.greater_than, expr.type.binary_operator.operator);
}
test "less than expression" {
var pgm = try parseTest("1 = 1 < 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.less_than, expr.type.binary_operator.operator);
}
test "greater or equal than expression" {
var pgm = try parseTest("1 = 1 >= 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.greater_or_equal_than, expr.type.binary_operator.operator);
}
test "less or equal than expression" {
var pgm = try parseTest("1 = 1 <= 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.less_or_equal_than, expr.type.binary_operator.operator);
}
test "equal expression" {
var pgm = try parseTest("1 = 1 == 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.equal, expr.type.binary_operator.operator);
}
test "different expression" {
var pgm = try parseTest("1 = 1 != 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.different, expr.type.binary_operator.operator);
}
test "operator precedence (binaries)" {
var pgm = try parseTest("1 = 1 + 1 * 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.add, expr.type.binary_operator.operator);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type.binary_operator.rhs.type);
std.testing.expectEqual(ast.BinaryOperator.multiply, expr.type.binary_operator.rhs.type.binary_operator.operator);
}
test "operator precedence (unary and binary mixed)" {
var pgm = try parseTest("1 = -1 * 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.multiply, expr.type.binary_operator.operator);
std.testing.expectEqual(ast.Expression.Type.unary_operator, expr.type.binary_operator.lhs.type);
std.testing.expectEqual(ast.UnaryOperator.negate, expr.type.binary_operator.lhs.type.unary_operator.operator);
}
test "invers operator precedence with parens" {
var pgm = try parseTest("1 = 1 * (1 + 1);");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type);
std.testing.expectEqual(ast.BinaryOperator.multiply, expr.type.binary_operator.operator);
std.testing.expectEqual(ast.Expression.Type.binary_operator, expr.type.binary_operator.rhs.type);
std.testing.expectEqual(ast.BinaryOperator.add, expr.type.binary_operator.rhs.type.binary_operator.operator);
}
test "unary minus expression" {
var pgm = try parseTest("1 = -1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.unary_operator, expr.type);
std.testing.expectEqual(ast.UnaryOperator.negate, expr.type.unary_operator.operator);
}
test "unary not expression" {
var pgm = try parseTest("1 = not 1;");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.unary_operator, expr.type);
std.testing.expectEqual(ast.UnaryOperator.boolean_not, expr.type.unary_operator.operator);
}
test "single array indexing expression" {
var pgm = try parseTest("1 = 1[\"\"];");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.array_indexer, expr.type);
std.testing.expectEqual(ast.Expression.Type.number_literal, expr.type.array_indexer.value.type);
std.testing.expectEqual(ast.Expression.Type.string_literal, expr.type.array_indexer.index.type);
}
test "multiple array indexing expressions" {
var pgm = try parseTest("1 = a[b][c];");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.array_indexer, expr.type);
std.testing.expectEqual(ast.Expression.Type.array_indexer, expr.type.array_indexer.value.type);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.array_indexer.index.type);
std.testing.expectEqualStrings("c", expr.type.array_indexer.index.type.variable_expr);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.array_indexer.value.type.array_indexer.value.type);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.array_indexer.value.type.array_indexer.index.type);
std.testing.expectEqualStrings("a", expr.type.array_indexer.value.type.array_indexer.value.type.variable_expr);
std.testing.expectEqualStrings("b", expr.type.array_indexer.value.type.array_indexer.index.type.variable_expr);
}
test "zero parameter function call expression" {
var pgm = try parseTest("1 = foo();");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.function_call, expr.type);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.function_call.function.type);
std.testing.expectEqual(@as(usize, 0), expr.type.function_call.arguments.len);
}
test "one parameter function call expression" {
var pgm = try parseTest("1 = foo(a);");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.function_call, expr.type);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.function_call.function.type);
std.testing.expectEqual(@as(usize, 1), expr.type.function_call.arguments.len);
std.testing.expectEqualStrings("a", expr.type.function_call.arguments[0].type.variable_expr);
}
test "4 parameter function call expression" {
var pgm = try parseTest("1 = foo(a,b,c,d);");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.function_call, expr.type);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.function_call.function.type);
std.testing.expectEqual(@as(usize, 4), expr.type.function_call.arguments.len);
std.testing.expectEqualStrings("a", expr.type.function_call.arguments[0].type.variable_expr);
std.testing.expectEqualStrings("b", expr.type.function_call.arguments[1].type.variable_expr);
std.testing.expectEqualStrings("c", expr.type.function_call.arguments[2].type.variable_expr);
std.testing.expectEqualStrings("d", expr.type.function_call.arguments[3].type.variable_expr);
}
test "zero parameter method call expression" {
var pgm = try parseTest("1 = a.foo();");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.method_call, expr.type);
std.testing.expectEqualStrings("foo", expr.type.method_call.name);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.method_call.object.type);
std.testing.expectEqual(@as(usize, 0), expr.type.method_call.arguments.len);
}
test "one parameter method call expression" {
var pgm = try parseTest("1 = a.foo(a);");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.method_call, expr.type);
std.testing.expectEqualStrings("foo", expr.type.method_call.name);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.method_call.object.type);
std.testing.expectEqual(@as(usize, 1), expr.type.method_call.arguments.len);
std.testing.expectEqualStrings("a", expr.type.method_call.arguments[0].type.variable_expr);
}
test "4 parameter method call expression" {
var pgm = try parseTest("1 = a.foo(a,b,c,d);");
defer pgm.deinit();
const expr = getTestExpr(pgm);
std.testing.expectEqual(ast.Expression.Type.method_call, expr.type);
std.testing.expectEqualStrings("foo", expr.type.method_call.name);
std.testing.expectEqual(ast.Expression.Type.variable_expr, expr.type.method_call.object.type);
std.testing.expectEqual(@as(usize, 4), expr.type.method_call.arguments.len);
std.testing.expectEqualStrings("a", expr.type.method_call.arguments[0].type.variable_expr);
std.testing.expectEqualStrings("b", expr.type.method_call.arguments[1].type.variable_expr);
std.testing.expectEqualStrings("c", expr.type.method_call.arguments[2].type.variable_expr);
std.testing.expectEqualStrings("d", expr.type.method_call.arguments[3].type.variable_expr);
}
test "full suite parsing" {
const seq = try testTokenize(@embedFile("../../test/compiler.lola"));
defer std.testing.allocator.free(seq);
var diagnostics = diag.Diagnostics.init(std.testing.allocator);
defer diagnostics.deinit();
var pgm = try parse(std.testing.allocator, &diagnostics, seq);
defer pgm.deinit();
for (diagnostics.messages.items) |msg| {
std.debug.warn("{}\n", .{msg});
}
// assert that we don't have an empty AST
std.testing.expect(pgm.root_script.len > 0);
std.testing.expect(pgm.functions.len > 0);
// assert that we didn't encounter syntax errors
std.testing.expectEqual(@as(usize, 0), diagnostics.messages.items.len);
} | src/library/compiler/parser.zig |
const testing = @import("std").testing;
const math = @import("std").math;
const v4 = @import("vector4.zig").v4;
const v3 = @import("vector3.zig").v3;
const warn = @import("std").debug.warn;
pub const m4 = struct {
v: [4][4]f32,
/// returns a new identity matrix
pub fn init() m4 {
const ident = [4][4]f32 {
[_]f32{1, 0, 0, 0},
[_]f32{0, 1, 0, 0},
[_]f32{0, 0, 1, 0},
[_]f32{0, 0, 0, 1},
};
return m4 {
.v = ident,
};
}
/// creates a scaling matrix from the passed v4
pub fn scaling(vec: v4) m4 {
const res = [4][4]f32 {
[_]f32{vec.x, 0, 0, 0},
[_]f32{0, vec.y, 0, 0},
[_]f32{0, 0, vec.z, 0},
[_]f32{0, 0, 0, vec.w},
};
return m4 {
.v = res,
};
}
/// creates a rotation matrix. angle must be in radians
pub fn rotation(angle: f32, axis: v3) m4 {
var res = m4.init();
const c = math.cos(angle);
const c1 = 1 - c;
const s = math.sin(angle);
const a = axis.normalized();
res.set(0, 0, a.x * a.x * c1 + c);
res.set(0, 1, a.x * a.y * c1 - a.z * s);
res.set(0, 2, a.x * a.z * c1 + a.y * s);
res.set(1, 0, a.y * a.x * c1 + a.z * s);
res.set(1, 1, a.y * a.y * c1 + c);
res.set(1, 2, a.y * a.z * c1 - a.x * s);
res.set(2, 0, a.z * a.x * c1 - a.y * s);
res.set(2, 1, a.z * a.y * c1 + a.x * s);
res.set(2, 2, a.z * a.z * c1 + c);
return res;
}
/// creates a translation matrix
pub fn translation(v: v3) m4 {
var res = m4.init();
var i: u16 = 0;
while (i < 3) : (i += 1) {
res.set(i, 3, res.at(i, 3) + v.at(i));
}
return res;
}
/// creates a look at matrix
pub fn lookAt(eye: v3, target: v3, up: v3) m4 {
const z = eye.subv(target).normalized();
const x = up.neg().cross(z).normalized();
const y = z.cross(x.neg());
const l = [4][4]f32 {
[_]f32{-x.x, -x.y, -x.z, x.dot(eye)},
[_]f32{ y.x, y.y, y.z, -y.dot(eye)},
[_]f32{ z.x, z.y, z.z, -z.dot(eye)},
[_]f32{ 0, 0, 0, 1 },
};
return m4 {
.v = l,
};
}
/// creates an orthographic projection matrix
pub fn orthographic(left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32) m4 {
const dx = right - left;
const dy = top - bottom;
const dz = far - near;
const tx = -(right + left) / dx;
const ty = -(top + bottom) / dy;
const tz = -(far + near) / dz;
const l = [4][4]f32 {
[_]f32{2/dx, 0, 0, tx},
[_]f32{0, 2/dy, 0, ty},
[_]f32{0, 0, -2/dz, tz},
[_]f32{0, 0, 0, 1},
};
return m4 {
.v = l,
};
}
/// creates a perspective projection matrix. fov is in radians
pub fn perspective(fov: f32, aspect: f32, near: f32, far: f32) m4 {
const f = 1 / (math.tan(fov/2));
const d = 1 / (near - far);
const l = [4][4]f32 {
[_]f32{f/aspect, 0, 0, 0},
[_]f32{0, f, 0, 0},
[_]f32{0, 0, (far + near) * d, 2 * d * far * near},
[_]f32{0, 0, -1, 0},
};
return m4 {
.v = l,
};
}
/// returns the value at [i, j]
pub fn at(m: m4, i: u16, j: u16) f32 {
return m.v[i][j];
}
/// sets the value at [i, j]
pub fn set(m: *m4, i: u16, j: u16, val: f32) void {
m.v[i][j] = val;
}
/// returns the mul of an m4 with a scalar
pub fn muls(m: m4, s: f32) m4 {
var res = m4.init();
var i: u16 = 0;
var j: u16 = 0;
while (i < 4) : (i += 1) {
j = 0;
while (j < 4) : (j += 1) {
res.set(i, j, m.at(i, j) * s);
}
}
return res;
}
/// returns the mul of an m4 with a v4
pub fn mulv(m: m4, v: v4) v4 {
var res = v4.init(0, 0, 0, 0);
var i: u16 = 0;
var j: u16 = 0;
while (i < 4) : (i += 1) {
j = 0;
var sum: f32 = 0;
while (j < 4) : (j += 1) {
sum += m.at(i, j) * v.at(j);
}
res.set(i, sum);
}
return res;
}
/// returns the mul of an m4 with another m4
pub fn mulm(a: m4, b: m4) m4 {
var res = m4.init();
var i: u16 = 0;
var j: u16 = 0;
var k: u16 = 0;
while (i < 4) : (i += 1) {
j = 0;
while (j < 4) : (j += 1) {
k = 0;
var sum: f32 = 0;
while (k < 4) : (k += 1) {
sum += a.at(i, k) * b.at(k, j);
}
res.set(i, j, sum);
}
}
return res;
}
/// returns the sum of of an m4 with another m4
pub fn summ(a: m4, b: m4) m4 {
var res = m4.init();
var i: u16 = 0;
var j: u16 = 0;
while (i < 4) : (i += 1) {
j = 0;
while (j < 4) : (j += 1) {
res.set(i, j, a.at(i, j) + b.at(i, j));
}
}
return res;
}
/// returns the sub of of an m4 with another m4
pub fn subm(a: m4, b: m4) m4 {
var res = m4.init();
var i: u16 = 0;
var j: u16 = 0;
while (i < 4) : (i += 1) {
j = 0;
while (j < 4) : (j += 1) {
res.set(i, j, a.at(i, j) - b.at(i, j));
}
}
return res;
}
/// returns the inverse of the provided matrix. if no inverse can be found it returns a m4(nan)
pub fn inverse(a: m4) m4 {
var t = a;
const det2_01_01 = t.at(0, 0) * t.at(1, 1) - t.at(0, 1) * t.at(1, 0);
const det2_01_02 = t.at(0, 0) * t.at(1, 2) - t.at(0, 2) * t.at(1, 0);
const det2_01_03 = t.at(0, 0) * t.at(1, 3) - t.at(0, 3) * t.at(1, 0);
const det2_01_12 = t.at(0, 1) * t.at(1, 2) - t.at(0, 2) * t.at(1, 1);
const det2_01_13 = t.at(0, 1) * t.at(1, 3) - t.at(0, 3) * t.at(1, 1);
const det2_01_23 = t.at(0, 2) * t.at(1, 3) - t.at(0, 3) * t.at(1, 2);
const det3_201_012 = t.at(2, 0) * det2_01_12 - t.at(2, 1) * det2_01_02 + t.at(2, 2) * det2_01_01;
const det3_201_013 = t.at(2, 0) * det2_01_13 - t.at(2, 1) * det2_01_03 + t.at(2, 3) * det2_01_01;
const det3_201_023 = t.at(2, 0) * det2_01_23 - t.at(2, 2) * det2_01_03 + t.at(2, 3) * det2_01_02;
const det3_201_123 = t.at(2, 1) * det2_01_23 - t.at(2, 2) * det2_01_13 + t.at(2, 3) * det2_01_12;
const det = - det3_201_123 * t.at(3, 0) + det3_201_023 * t.at(3, 1) - det3_201_013 * t.at(3, 2) + det3_201_012 * t.at(3, 3);
const invDet = 1 / det;
const det2_03_01 = t.at(0, 0) * t.at(3, 1) - t.at(0, 1) * t.at(3, 0);
const det2_03_02 = t.at(0, 0) * t.at(3, 2) - t.at(0, 2) * t.at(3, 0);
const det2_03_03 = t.at(0, 0) * t.at(3, 3) - t.at(0, 3) * t.at(3, 0);
const det2_03_12 = t.at(0, 1) * t.at(3, 2) - t.at(0, 2) * t.at(3, 1);
const det2_03_13 = t.at(0, 1) * t.at(3, 3) - t.at(0, 3) * t.at(3, 1);
const det2_03_23 = t.at(0, 2) * t.at(3, 3) - t.at(0, 3) * t.at(3, 2);
const det2_13_01 = t.at(1, 0) * t.at(3, 1) - t.at(1, 1) * t.at(3, 0);
const det2_13_02 = t.at(1, 0) * t.at(3, 2) - t.at(1, 2) * t.at(3, 0);
const det2_13_03 = t.at(1, 0) * t.at(3, 3) - t.at(1, 3) * t.at(3, 0);
const det2_13_12 = t.at(1, 1) * t.at(3, 2) - t.at(1, 2) * t.at(3, 1);
const det2_13_13 = t.at(1, 1) * t.at(3, 3) - t.at(1, 3) * t.at(3, 1);
const det2_13_23 = t.at(1, 2) * t.at(3, 3) - t.at(1, 3) * t.at(3, 2);
const det3_203_012 = t.at(2, 0) * det2_03_12 - t.at(2, 1) * det2_03_02 + t.at(2, 2) * det2_03_01;
const det3_203_013 = t.at(2, 0) * det2_03_13 - t.at(2, 1) * det2_03_03 + t.at(2, 3) * det2_03_01;
const det3_203_023 = t.at(2, 0) * det2_03_23 - t.at(2, 2) * det2_03_03 + t.at(2, 3) * det2_03_02;
const det3_203_123 = t.at(2, 1) * det2_03_23 - t.at(2, 2) * det2_03_13 + t.at(2, 3) * det2_03_12;
const det3_213_012 = t.at(2, 0) * det2_13_12 - t.at(2, 1) * det2_13_02 + t.at(2, 2) * det2_13_01;
const det3_213_013 = t.at(2, 0) * det2_13_13 - t.at(2, 1) * det2_13_03 + t.at(2, 3) * det2_13_01;
const det3_213_023 = t.at(2, 0) * det2_13_23 - t.at(2, 2) * det2_13_03 + t.at(2, 3) * det2_13_02;
const det3_213_123 = t.at(2, 1) * det2_13_23 - t.at(2, 2) * det2_13_13 + t.at(2, 3) * det2_13_12;
const det3_301_012 = t.at(3, 0) * det2_01_12 - t.at(3, 1) * det2_01_02 + t.at(3, 2) * det2_01_01;
const det3_301_013 = t.at(3, 0) * det2_01_13 - t.at(3, 1) * det2_01_03 + t.at(3, 3) * det2_01_01;
const det3_301_023 = t.at(3, 0) * det2_01_23 - t.at(3, 2) * det2_01_03 + t.at(3, 3) * det2_01_02;
const det3_301_123 = t.at(3, 1) * det2_01_23 - t.at(3, 2) * det2_01_13 + t.at(3, 3) * det2_01_12;
var res = m4.init();
res.set(0, 0, -det3_213_123 * invDet);
res.set(1, 0, det3_213_023 * invDet);
res.set(2, 0, -det3_213_013 * invDet);
res.set(3, 0, det3_213_012 * invDet);
res.set(0, 1, det3_203_123 * invDet);
res.set(1, 1, -det3_203_023 * invDet);
res.set(2, 1, det3_203_013 * invDet);
res.set(3, 1, -det3_203_012 * invDet);
res.set(0, 2, det3_301_123 * invDet);
res.set(1, 2, -det3_301_023 * invDet);
res.set(2, 2, det3_301_013 * invDet);
res.set(3, 2, -det3_301_012 * invDet);
res.set(0, 3, -det3_201_123 * invDet);
res.set(1, 3, det3_201_023 * invDet);
res.set(2, 3, -det3_201_013 * invDet);
res.set(3, 3, det3_201_012 * invDet);
return res;
}
};
test "creating an m4" {
const x = m4.init();
testing.expect(x.at(0, 0) == 1);
testing.expect(x.at(1, 1) == 1);
testing.expect(x.at(2, 2) == 1);
testing.expect(x.at(3, 3) == 1);
}
test "settings m4 values" {
var x = m4.init();
x.set(0, 2, 10);
testing.expect(x.at(0, 2) == 10);
}
test "multiplying m4 with scalars" {
const x = m4.init().muls(4);
testing.expect(x.at(0, 0) == 4);
testing.expect(x.at(1, 1) == 4);
testing.expect(x.at(2, 2) == 4);
testing.expect(x.at(3, 3) == 4);
}
test "multiplying m4 with v4" {
const v = v4.init(1, 2, 3, 4);
const x = m4.init().muls(2).mulv(v);
testing.expect(x.x == 2);
testing.expect(x.y == 4);
testing.expect(x.z == 6);
testing.expect(x.w == 8);
}
test "multiplying m4 with m4" {
const a = m4.init().muls(2);
const b = m4.init().muls(3);
const x = a.mulm(b);
testing.expect(x.at(0, 0) == 6);
testing.expect(x.at(1, 1) == 6);
testing.expect(x.at(2, 2) == 6);
testing.expect(x.at(3, 3) == 6);
}
test "subtracting and summing two m4" {
const a = m4.init().muls(2);
const b = m4.init().muls(3);
const sm = a.summ(b);
testing.expect(sm.at(0, 0) == 5);
testing.expect(sm.at(1, 1) == 5);
testing.expect(sm.at(2, 2) == 5);
testing.expect(sm.at(3, 3) == 5);
const sb = a.subm(b);
testing.expect(sb.at(0, 0) == -1);
testing.expect(sb.at(1, 1) == -1);
testing.expect(sb.at(2, 2) == -1);
testing.expect(sb.at(3, 3) == -1);
}
test "scaling m4" {
const x = m4.scaling(v4.init(0, 1, 0, 0));
testing.expect(x.at(1, 1) == 1);
}
test "rotation m4" {
const x = m4.rotation(45, v3.init(0, 1, 0));
testing.expect(math.approxEq(f32, x.at(0, 0), 0.525323450, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(0, 1), 0, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(0, 2), 0.850902616, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 0), 0, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 1), 1, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 2), 0, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 0), -0.850902616, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 1), 0, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 2), 0.525323450, math.f32_epsilon));
}
test "translation m4" {
const x = m4.translation(v3.init(1, 2, 3));
testing.expect(x.at(0, 3) == 1);
testing.expect(x.at(1, 3) == 2);
testing.expect(x.at(2, 3) == 3);
}
test "look at m4" {
const x = m4.lookAt(v3.init(0, 0, 0), v3.init(1, 1, 1), v3.init(0, 1, 0));
testing.expect(math.approxEq(f32, x.at(0, 0), -0.707106769, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(0, 2), 0.707106769, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 0), -0.408248275, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 1), 0.816496551, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 2), -0.408248275, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 0), -0.577350258, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 1), -0.577350258, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 2), -0.577350258, math.f32_epsilon));
}
test "orthographic projection m4" {
const x = m4.orthographic(0, 1280, 720, 0, 5, 10);
testing.expect(math.approxEq(f32, x.at(0, 0), 0.00156250002, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(0, 3), -1, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 1), -0.00277777784, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 3), 1, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 2), -0.4, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 3), -3, math.f32_epsilon));
}
test "perspective projection m4" {
const x = m4.perspective(1.57, 1.7, 0, 5);
testing.expect(math.approxEq(f32, x.at(0, 0), 0.588703811, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(1, 1), 1.00079655, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(2, 2), -1, math.f32_epsilon));
testing.expect(math.approxEq(f32, x.at(3, 2), -1, math.f32_epsilon));
}
test "inverse m4" {
const x = m4.init().muls(5);
const res = x.inverse();
testing.expect(math.approxEq(f32, res.at(0, 0), 0.2, math.f32_epsilon));
testing.expect(math.approxEq(f32, res.at(1, 1), 0.2, math.f32_epsilon));
testing.expect(math.approxEq(f32, res.at(2, 2), 0.2, math.f32_epsilon));
testing.expect(math.approxEq(f32, res.at(3, 3), 0.2, math.f32_epsilon));
} | src/matrix4.zig |
const base = @import("../base.zig");
const gen = @import("../gen.zig");
const cal_454 = @import("symmetry454.zig");
const COMMON = [_:null]?base.Segment{
.{ .offset = 30 * 0 + 31 * 0, .month = 1, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 1 + 31 * 0, .month = 2, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 1 + 31 * 1, .month = 3, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 2 + 31 * 1, .month = 4, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 3 + 31 * 1, .month = 5, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 3 + 31 * 2, .month = 6, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 4 + 31 * 2, .month = 7, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 5 + 31 * 2, .month = 8, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 5 + 31 * 3, .month = 9, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 6 + 31 * 3, .month = 10, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 7 + 31 * 3, .month = 11, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 7 + 31 * 4, .month = 12, .day_start = 1, .day_end = 30 },
};
const LEAP = [_:null]?base.Segment{
.{ .offset = 30 * 0 + 31 * 0, .month = 1, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 1 + 31 * 0, .month = 2, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 1 + 31 * 1, .month = 3, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 2 + 31 * 1, .month = 4, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 3 + 31 * 1, .month = 5, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 3 + 31 * 2, .month = 6, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 4 + 31 * 2, .month = 7, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 5 + 31 * 2, .month = 8, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 5 + 31 * 3, .month = 9, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 6 + 31 * 3, .month = 10, .day_start = 1, .day_end = 30 },
.{ .offset = 30 * 7 + 31 * 3, .month = 11, .day_start = 1, .day_end = 31 },
.{ .offset = 30 * 7 + 31 * 4, .month = 12, .day_start = 1, .day_end = 37 },
};
var common_var: [COMMON.len:null]?base.Segment = COMMON;
var leap_var: [LEAP.len:null]?base.Segment = LEAP;
pub const symmetry010 = base.Cal{
.intercalary_list = cal_454.symmetry454.intercalary_list,
.common_lookup_list = @as([*:null]?base.Segment, &common_var),
.leap_lookup_list = @as([*:null]?base.Segment, &leap_var),
.leap_cycle = cal_454.symmetry454.leap_cycle,
.week = cal_454.symmetry454.week,
.epoch_mjd = cal_454.symmetry454.epoch_mjd,
.common_month_max = gen.monthMax(COMMON[0..COMMON.len]),
.leap_month_max = gen.monthMax(LEAP[0..LEAP.len]),
.year0 = cal_454.symmetry454.year0,
}; | src/cal/symmetry010.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const config = @import("config.zig");
const vr = @import("vr.zig");
const Header = vr.Header;
const MessageBus = @import("message_bus.zig").MessageBusClient;
const Message = @import("message_bus.zig").Message;
const StateMachine = @import("state_machine.zig").StateMachine;
const RingBuffer = @import("ring_buffer.zig").RingBuffer;
const tb = @import("tigerbeetle.zig");
const Account = tb.Account;
const Transfer = tb.Transfer;
const Commit = tb.Commit;
const CreateAccountsResult = tb.CreateAccountsResult;
const CreateTransfersResult = tb.CreateTransfersResult;
const CommitTransfersResult = tb.CommitTransfersResult;
const log = std.log;
pub const ClientError = error{
TooManyOutstandingRequests,
};
pub const Client = struct {
const Request = struct {
const Callback = fn (
user_data: u128,
operation: StateMachine.Operation,
results: ClientError![]const u8,
) void;
user_data: u128,
callback: Callback,
operation: StateMachine.Operation,
message: *Message,
};
allocator: *mem.Allocator,
id: u128,
cluster: u128,
replica_count: u16,
message_bus: *MessageBus,
// TODO Track the latest view number received in .pong and .reply messages.
// TODO Ask the cluster for our last request number.
request_number_min: u32 = 0,
request_number_max: u32 = 0,
/// Leave one Message free to receive with
request_queue: RingBuffer(Request, config.message_bus_messages_max - 1) = .{},
request_timeout: vr.Timeout,
ping_timeout: vr.Timeout,
pub fn init(
allocator: *mem.Allocator,
cluster: u128,
replica_count: u16,
message_bus: *MessageBus,
) !Client {
assert(cluster > 0);
assert(replica_count > 0);
// We require the client ID to be non-zero for client requests.
// The probability of this actually being zero is unlikely (more likely a CSPRNG bug):
var id = std.crypto.random.int(u128);
assert(id > 0);
var self = Client{
.allocator = allocator,
.id = id,
.cluster = cluster,
.replica_count = replica_count,
.message_bus = message_bus,
.request_timeout = .{
.name = "request_timeout",
.replica = std.math.maxInt(u16),
.after = 100,
},
.ping_timeout = .{
.name = "ping_timeout",
.replica = std.math.maxInt(u16),
.after = 100,
},
};
self.ping_timeout.start();
return self;
}
pub fn deinit(self: *Client) void {}
pub fn tick(self: *Client) void {
self.message_bus.tick();
self.request_timeout.tick();
if (self.request_timeout.fired()) self.on_request_timeout();
self.ping_timeout.tick();
if (self.ping_timeout.fired()) self.on_ping_timeout();
// TODO Resend the request to the leader when the request_timeout fires.
// This covers for dropped packets, when the leader is still the leader.
// TODO Resend the request to the next replica and so on each time the reply_timeout fires.
// This anticipates the next view change, without the cost of broadcast against the cluster.
// TODO Tick ping_timeout and send ping if necessary to all replicas.
// We need to keep doing this until we discover our latest request_number.
// Thereafter, we can extend our ping_timeout considerably.
// The cluster can use this ping information to do LRU eviction from the client table when
// it is overflowed by the number of unique client IDs.
// TODO Resend the request to the leader when the request_timeout fires.
// This covers for dropped packets, when the leader is still the leader.
// TODO Resend the request to the next replica and so on each time the reply_timeout fires.
// This anticipates the next view change, without the cost of broadcast against the cluster.
}
/// A client is allowed at most one inflight request at a time, concurrent requests are queued.
pub fn request(
self: *Client,
user_data: u128,
callback: Request.Callback,
operation: StateMachine.Operation,
message: *Message,
body_size: usize,
) void {
const message_size = @intCast(u32, @sizeOf(Header) + body_size);
assert(message_size <= config.message_size_max);
self.request_number_max += 1;
log.debug("{} request: setting request={}", .{ self.id, self.request_number_max });
message.header.* = .{
.client = self.id,
.cluster = self.cluster,
.request = self.request_number_max,
.command = .request,
.operation = vr.Operation.from_state_machine_op(StateMachine, operation),
.size = message_size,
};
const body = message.buffer[@sizeOf(Header)..][0..body_size];
message.header.set_checksum_body(body);
message.header.set_checksum();
const was_empty = self.request_queue.empty();
self.request_queue.push(.{
.user_data = user_data,
.callback = callback,
.operation = operation,
.message = message.ref(),
}) catch |err| switch (err) {
error.NoSpaceLeft => {
callback(
user_data,
operation,
error.TooManyOutstandingRequests,
);
return;
},
else => unreachable,
};
// If the queue was empty, there is no currently inflight message, so send this one.
if (was_empty) self.send_request(message);
}
/// Helper function to get an available message from the message bus.
pub fn get_message(self: *Client) ?*Message {
return self.message_bus.get_message();
}
/// Helper function to get the message bus to unref the message.
pub fn unref(self: *Client, message: *Message) void {
self.message_bus.unref(message);
}
fn on_request_timeout(self: *Client) void {
const current_request = self.request_queue.peek() orelse return;
log.debug("Retrying timed out request {o}.", .{current_request.message.header});
self.request_timeout.stop();
self.retry_request(current_request.message);
}
fn send(self: *Client, message: *Message, isRetry: bool) void {
if (!isRetry) self.request_number_min += 1;
log.debug("{} send: request_number_min={}", .{ self.id, self.request_number_min });
assert(message.header.valid_checksum());
assert(message.header.request == self.request_number_min);
assert(message.header.client == self.id);
assert(message.header.cluster == self.cluster);
assert(!self.request_timeout.ticking);
self.send_message_to_replicas(message);
self.request_timeout.start();
}
fn send_request(self: *Client, message: *Message) void {
self.send(message, false);
}
fn retry_request(self: *Client, message: *Message) void {
self.send(message, true);
}
fn on_reply(self: *Client, reply: *Message) void {
assert(reply.header.valid_checksum());
assert(reply.header.valid_checksum_body(reply.body()));
const queued_request = self.request_queue.peek().?;
if (reply.header.client != self.id or reply.header.cluster != self.cluster) {
log.debug("{} on_reply: Dropping unsolicited message.", .{self.id});
return;
}
if (reply.header.request < queued_request.message.header.request) {
log.debug(
"{} on_reply: Dropping duplicate message. request={}",
.{ self.id, reply.header.request },
);
return;
}
assert(reply.header.request == queued_request.message.header.request);
assert(reply.header.operation.to_state_machine_op(StateMachine) == queued_request.operation);
self.request_timeout.stop();
queued_request.callback(
queued_request.user_data,
queued_request.operation,
reply.body(),
);
_ = self.request_queue.pop().?;
self.message_bus.unref(queued_request.message);
if (self.request_queue.peek()) |next_request| {
self.send_request(next_request.message);
}
}
pub fn on_message(self: *Client, message: *Message) void {
log.debug("{}: on_message: {}", .{ self.id, message.header });
if (message.header.invalid()) |reason| {
log.debug("{}: on_message: invalid ({s})", .{ self.id, reason });
return;
}
if (message.header.cluster != self.cluster) {
log.warn("{}: on_message: wrong cluster (message.header.cluster={} instead of {})", .{
self.id,
message.header.cluster,
self.cluster,
});
return;
}
switch (message.header.command) {
.reply => self.on_reply(message),
.ping => self.on_ping(message),
.pong => {
// TODO: when we implement proper request number usage, we will
// need to get the request number from a pong message on startup.
},
else => {
log.warn(
"{}: on_message: unexpected command {}",
.{ self.id, message.header.command },
);
},
}
}
fn on_ping_timeout(self: *Client) void {
self.ping_timeout.reset();
const ping = Header{
.command = .ping,
.cluster = self.cluster,
.client = self.id,
};
self.send_header_to_replicas(ping);
}
fn on_ping(self: Client, ping: *const Message) void {
const pong: Header = .{
.command = .pong,
.cluster = self.cluster,
.client = self.id,
};
self.message_bus.send_header_to_replica(ping.header.replica, pong);
}
fn send_message_to_leader(self: *Client, message: *Message) void {
// TODO For this to work, we need to send pings to the cluster every N ticks.
// Otherwise, the latest leader will have our connection.peer set to .unknown.
// TODO Use the latest view number modulo the configuration length to find the leader.
// For now, replica 0 will forward onto the latest leader.
self.message_bus.send_message_to_replica(0, message);
}
fn send_message_to_replicas(self: *Client, message: *Message) void {
var replica: u16 = 0;
while (replica < self.replica_count) : (replica += 1) {
self.message_bus.send_message_to_replica(replica, message);
}
}
fn send_header_to_replicas(self: *Client, header: Header) void {
var replica: u16 = 0;
while (replica < self.replica_count) : (replica += 1) {
self.message_bus.send_header_to_replica(replica, header);
}
}
}; | src/client.zig |
const messageNs = @import("message.zig");
const MessageHeader = messageNs.MessageHeader;
const messageQueueNs = @import("message_queue.zig");
const MessageQueue = messageQueueNs.MessageQueue;
const std = @import("std");
const warn = std.debug.warn;
/// ActorInterface is a member of all Actor's and
/// every Actor must implement processMessage who's
/// address is saved in this interface when an Actor
/// is initialized by calling Actor(BodyType).init().
///
/// There must also be a BodyType.init(*Actor(BodyType))
pub const ActorInterface = packed struct {
// The routine which processes the actors messages.
pub processMessage: fn (actorInterface: *ActorInterface, msg: *MessageHeader) void,
// An optional queue used to send messages to the actor.
// Typically initialized when adding the actor to
// a dispatcher.
pub pQueue: ?*MessageQueue(),
// An optional fn that the actor will call when it completes.
// Typicall initialized when adding the actor to
// a dispatcher. The doneFn_handle will be passed as
// a parameter to the doneFn.
pub doneFn: ?fn (doneFn_handle: usize) void,
pub doneFn_handle: usize,
};
/// Actor that can process messages. Actors implement
/// processMessage in the BodyType passed to this Actor
/// Type Constructor.
///
/// TODO: Should an actor have a fn send? Now that I've
/// added the pQueue to an ActorInterface we can.
pub fn Actor(comptime BodyType: type) type {
return struct {
const Self = @This();
pub interface: ActorInterface,
pub body: BodyType,
pub fn init() Self {
return Self.initFull(null, 0);
}
pub fn initFull(doneFn: ?fn (doneFn_handle: usize) void, doneFn_handle: usize) Self {
var self: Self = undefined;
self.interface.pQueue = null;
self.interface.processMessage = BodyType.processMessage;
self.interface.doneFn = doneFn;
self.interface.doneFn_handle = doneFn_handle;
BodyType.init(&self);
//warn("Actor.init: pAi={*} self={*} processMessage={x}\n",
// &self.interface, &self, @ptrToInt(self.interface.processMessage));
return self;
}
/// Return a pointer to the Actor this interface is a member of.
pub fn getActorPtr(pAi: *ActorInterface) *Self {
return @fieldParentPtr(Self, "interface", pAi);
}
};
}
// Tests
const Message = messageNs.Message;
const mem = std.mem;
const assert = std.debug.assert;
const MyMsgBody = packed struct {
const Self = @This();
data: [3]u8,
fn init(pSelf: *Self) void {
mem.set(u8, pSelf.data[0..], 'Z');
}
pub fn format(
m: *const MyMsgBody,
comptime fmt: []const u8,
context: var,
comptime FmtError: type,
output: fn (@typeOf(context), []const u8) FmtError!void
) FmtError!void {
try std.fmt.format(context, FmtError, output, "data={{");
for (m.data) |v| {
if ((v >= ' ') and (v <= 0x7f)) {
try std.fmt.format(context, FmtError, output, "{c}," , v);
} else {
try std.fmt.format(context, FmtError, output, "{x},", v);
}
}
try std.fmt.format(context, FmtError, output, "}},");
}
};
const MyActorBody = struct {
const Self = @This();
count: u64,
fn init(actor: *Actor(MyActorBody)) void {
actor.body.count = 0;
}
pub fn processMessage(actorInterface: *ActorInterface, msgHeader: *MessageHeader) void {
var pActor = Actor(MyActorBody).getActorPtr(actorInterface);
var pMsg = Message(MyMsgBody).getMessagePtr(msgHeader);
assert(pMsg.header.cmd == msgHeader.cmd);
pActor.body.count += pMsg.header.cmd;
//warn("MyActorBody: &processMessage={x} cmd={} count={}\n",
// @ptrToInt(processMessage), msgHeader.cmd, pActor.body.count);
}
};
test "Actor" {
// Create a message
const MyMsg = Message(MyMsgBody);
var myMsg: MyMsg = undefined;
myMsg.init(123);
// Create an Actor
const MyActor = Actor(MyActorBody);
var myActor = MyActor.init();
myActor.interface.processMessage(&myActor.interface, &myMsg.header);
assert(myActor.body.count == 1 * 123);
myActor.interface.processMessage(&myActor.interface, &myMsg.header);
assert(myActor.body.count == 2 * 123);
} | actor.zig |
const clap = @import("zig-clap");
const std = @import("std");
const fmt = std.fmt;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const testing = std.testing;
const unicode = std.unicode;
const Names = clap.Names;
const Param = clap.Param(clap.Help);
const params = [_]Param{
clap.parseParam("-h, --help print this message to stdout") catch unreachable,
clap.parseParam("-l, --length <NUM> the length of the bar (default: 10)") catch unreachable,
clap.parseParam("-m, --min <NUM> minimum value (default: 0)") catch unreachable,
clap.parseParam("-M, --max <NUM> maximum value (default: 100)") catch unreachable,
clap.parseParam("-s, --steps <LIST> a comma separated list of the steps used to draw the bar (default: ' ,=')") catch unreachable,
clap.parseParam("-t, --type <normal|mark-center> the type of bar to draw (default: normal)") catch unreachable,
};
fn usage(stream: anytype) !void {
try stream.writeAll(
\\Usage: sab [OPTION]...
\\sab will draw bars/spinners based on the values piped in through
\\stdin.
\\
\\To draw a simple bar, simply pipe a value between 0-100 into sab:
\\echo 35 | sab
\\====
\\
\\You can customize your bar with the '-s, --steps' option:
\\echo 35 | sab -s ' ,-,='
\\===-
\\
\\`sab` has two ways of drawing bars, which can be chosen with the `-t, --type` option:
\\echo 50 | sab -s ' ,|,='
\\=====
\\echo 55 | sab -s ' ,|,='
\\=====|
\\echo 50 | sab -s ' ,|,=' -t mark-center
\\====|
\\echo 55 | sab -s ' ,|,=' -t mark-center
\\=====|
\\
\\To draw a simple spinner, simply set the length of the bar to 1
\\and set max to be the last step:
\\echo 2 | sab -l 1 -M 3 -s '/,-,\,|'
\\\
\\
\\sab will draw multible lines, one for each line piped into it.
\\echo -e '0\n1\n2\n3' | sab -l 1 -M 3 -s '/,-,\,|'
\\/
\\-
\\\
\\|
\\
\\Options:
\\
);
try clap.help(stream, ¶ms);
}
const TypeArg = enum {
normal,
@"mark-center",
};
pub fn main() !void {
const stderr = io.getStdErr().writer();
const stdout = io.getStdOut().writer();
const stdin = io.getStdIn().reader();
var arena = heap.ArenaAllocator.init(heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
var diag = clap.Diagnostic{};
var args = clap.parse(clap.Help, ¶ms, .{ .diagnostic = &diag }) catch |err| {
diag.report(stderr, err) catch {};
usage(stderr) catch {};
return err;
};
if (args.flag("--help"))
return try usage(stdout);
const min = try fmt.parseInt(isize, args.option("--min") orelse "0", 10);
const max = try fmt.parseInt(isize, args.option("--max") orelse "100", 10);
const len = try fmt.parseUnsigned(usize, args.option("--length") orelse "10", 10);
const typ = std.meta.stringToEnum(TypeArg, args.option("--type") orelse "normal") orelse return error.InvalidType;
const steps = blk: {
var str = std.ArrayList(u8).init(allocator);
var res = std.ArrayList([]const u8).init(allocator);
const list = args.option("--steps") orelse " ,=";
var i: usize = 0;
while (i < list.len) : (i += 1) {
const c = list[i];
switch (c) {
',' => try res.append(str.toOwnedSlice()),
'\\' => {
i += 1;
const c2 = if (i < list.len) list[i] else 0;
switch (c2) {
',', '\\' => try str.append(c2),
else => return error.InvalidEscape,
}
},
else => try str.append(c),
}
}
try res.append(str.toOwnedSlice());
if (res.items.len == 0)
return error.NoSteps;
break :blk res.toOwnedSlice();
};
var buf = std.ArrayList(u8).init(allocator);
while (true) {
stdin.readUntilDelimiterArrayList(&buf, '\n', math.maxInt(usize)) catch |err| switch (err) {
error.EndOfStream => break,
else => |e| return e,
};
const curr = try fmt.parseInt(isize, buf.items, 10);
try draw(stdout, isize, curr, .{
.min = min,
.max = max,
.len = len,
.type = switch (typ) {
.normal => Type.normal,
.@"mark-center" => Type.mark_center,
},
.steps = steps,
});
try stdout.writeAll("\n");
}
}
pub const Type = enum {
normal,
mark_center,
};
pub fn DrawOptions(comptime T: type) type {
return struct {
min: T = 0,
max: T = 100,
len: usize = 10,
type: Type = .normal,
steps: []const []const u8 = &[_][]const u8{ " ", "=" },
};
}
pub fn draw(stream: anytype, comptime T: type, _curr: T, opts: DrawOptions(T)) !void {
std.debug.assert(opts.steps.len != 0);
const curr = math.min(_curr, opts.max);
const abs_max = @intToFloat(f64, try math.cast(usize, opts.max - opts.min));
const abs_curr = @intToFloat(f64, math.max(curr - opts.min, 0));
const step = abs_max / @intToFloat(f64, opts.len);
// Draw upto the center of the bar
var i: usize = 0;
while (abs_curr > @intToFloat(f64, i + 1) * step) : (i += 1)
try stream.writeAll(opts.steps[opts.steps.len - 1]);
const min_index: usize = @boolToInt(opts.type == .mark_center);
const _max_index = math.sub(usize, opts.steps.len, 1 + min_index) catch 1;
const max_index = math.max(_max_index, 1);
const mid_steps = opts.steps[min_index..max_index];
const drawn = @intToFloat(f64, i) * step;
const fullness = (abs_curr - drawn) / step;
const full_to_index = @floatToInt(usize, @intToFloat(f64, mid_steps.len) * fullness);
const real_index = math.min(full_to_index + min_index, max_index);
try stream.writeAll(opts.steps[real_index]);
i += 1;
// Draw the rest of the bar
while (i < opts.len) : (i += 1)
try stream.writeAll(opts.steps[0]);
}
fn testDraw(res: []const u8, curr: isize, opts: DrawOptions(isize)) !void {
var buf: [100]u8 = undefined;
var stream = io.fixedBufferStream(&buf);
try draw(stream.writer(), isize, curr, opts);
try testing.expectEqualStrings(res, stream.getWritten());
}
test "draw" {
try testDraw(" ", -1, .{ .min = 0, .max = 6, .len = 6 });
try testDraw(" ", 0, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("= ", 1, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("== ", 2, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("=== ", 3, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("==== ", 4, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("===== ", 5, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("======", 6, .{ .min = 0, .max = 6, .len = 6 });
try testDraw("======", 7, .{ .min = 0, .max = 6, .len = 6 });
try testDraw(" ", 0, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("- ", 1, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("= ", 2, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("=- ", 3, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("== ", 4, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("==-", 5, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("===", 6, .{ .min = 0, .max = 6, .len = 3, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("= ", -1, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("= ", 0, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("= ", 1, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("== ", 2, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("=== ", 3, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("==== ", 4, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("===== ", 5, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("======", 6, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("======", 7, .{ .min = 0, .max = 6, .len = 6, .type = .mark_center, .steps = &[_][]const u8{ " ", "=" } });
try testDraw("- ", 0, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("- ", 1, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("- ", 2, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("=- ", 3, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("=- ", 4, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("==-", 5, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
try testDraw("==-", 6, .{ .min = 0, .max = 6, .len = 3, .type = .mark_center, .steps = &[_][]const u8{ " ", "-", "=" } });
} | src/main.zig |
const std = @import("std");
usingnamespace @import("kiragine").kira.log;
const engine = @import("kiragine");
const ComponentList = struct {
rect: engine.Rectangle = undefined,
motion: engine.Vec2f = undefined,
is_alive: bool = false,
};
const ComponentTags = enum {
rectangle,
motion,
isAlive,
};
const MaxObjectTag = 3;
const MaxObject = 1024 * 100;
const MaxFilter = 10;
const Object = engine.ecs.ObjectGeneric(MaxObjectTag, ComponentList);
const World = engine.ecs.WorldGeneric(MaxObject, MaxFilter, Object);
var alloc = std.heap.page_allocator;
var world = World{};
pub fn main() !void {
const callbacks = engine.Callbacks{
.draw = draw,
.fixed = fupdate,
};
try engine.init(callbacks, 1024, 768, "ECS", 0, alloc);
world.clearObjects();
world.clearFilters();
try world.addFilter(@enumToInt(ComponentTags.rectangle));
try world.addFilter(@enumToInt(ComponentTags.motion));
try world.addFilter(@enumToInt(ComponentTags.isAlive));
var i: u64 = 0;
while (i < MaxObject) : (i += 1) {
var object = Object{ .id = i };
object.clearTags();
object.components = .{
.rect = .{ .x = @intToFloat(f32, i * i), .y = 200, .width = 30, .height = 32 },
.motion = .{ .x = 0, .y = 150 },
.is_alive = true,
};
try object.addTags([MaxObjectTag]u64{ @enumToInt(ComponentTags.isAlive), @enumToInt(ComponentTags.motion), @enumToInt(ComponentTags.rectangle) });
try world.addObject(object);
}
world.filterObjects() catch |err| {
if (err != engine.Error.FailedToAdd) return err;
};
try engine.open();
try engine.update();
try engine.deinit();
}
fn fupdate(fdt: f32) !void {
if (world.hasFilters(3, [3]u64{ @enumToInt(ComponentTags.isAlive), @enumToInt(ComponentTags.motion), @enumToInt(ComponentTags.rectangle) }))
try systemMotion(&world, fdt);
std.log.emerg("fps: {}", .{engine.getFps()});
}
fn draw() !void {
engine.clearScreen(0.1, 0.1, 0.1, 1.0);
try engine.pushBatch2D(engine.Renderer2DBatchTag.quads);
if (world.hasFilters(2, [2]u64{ @enumToInt(ComponentTags.isAlive), @enumToInt(ComponentTags.rectangle) }))
try systemDrawRectangle(&world);
try engine.popBatch2D();
}
fn systemMotion(self: *World, fdt: f32) engine.Error!void {
var i: u64 = 0;
while (i < self.filteredidlist.count) : (i += 1) {
if (!self.filteredidlist.items[i].is_exists) continue;
var ent = self.filteredlist[i];
const is_alive = try ent.getComponent(bool, "is_alive", @enumToInt(ComponentTags.isAlive));
if (is_alive) {
const motion = try ent.getComponent(engine.Vec2f, "motion", @enumToInt(ComponentTags.motion));
var rect = try ent.getComponent(engine.Rectangle, "rect", @enumToInt(ComponentTags.rectangle));
rect.x += motion.x * fdt;
rect.y += motion.y * fdt;
if (rect.y > 768) rect.y = 0;
try ent.replaceComponent(engine.Rectangle, "rect", rect, @enumToInt(ComponentTags.rectangle));
}
}
}
fn systemDrawRectangle(self: *World) engine.Error!void {
var i: u64 = 0;
while (i < self.filteredidlist.count) : (i += 1) {
if (!self.filteredidlist.items[i].is_exists) continue;
const ent = self.filteredlist[i];
const is_alive = try ent.getComponent(bool, "is_alive", @enumToInt(ComponentTags.isAlive));
if (is_alive) {
const rect = try ent.getComponent(engine.Rectangle, "rect", @enumToInt(ComponentTags.rectangle));
try engine.drawRectangle(rect, .{ .r = 1, .g = 1, .b = 1, .a = 1 });
}
}
} | examples/ecs.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const print = std.debug.print;
const util = @import("./util.zig");
const data = @embedFile("../data/day03.txt");
//Calculate the amount of lines in comptime.
const lineCount = comptime {
@setEvalBranchQuota(28000);
return util.countScalar(u8, data, '\n') + 1;
};
fn part1() !void {
var tokenizer = std.mem.tokenize(data, "\r\n");
var oneCount = [_]u16{0} ** 12;
var zeroCount = [_]u16{0} ** 12;
while (tokenizer.next()) |line| {
for (line) |bit, i| {
if (bit == '1') {
oneCount[i] += 1;
} else {
zeroCount[i] += 1;
}
}
}
var gamma: u32 = 0;
var epsilon: u32 = 0;
var i: u32 = 0;
while (i < 12) : (i += 1) {
gamma <<= 1;
epsilon <<= 1;
if (oneCount[i] > zeroCount[i]) {
gamma |= 1;
} else {
epsilon |= 1;
}
}
print("Part1:\n\tγ = {d}\n\tε = {d}\n\tε × γ = {d}\n", .{ gamma, epsilon, gamma * epsilon });
}
fn countSelected1Bits(lines: [][]const u8, availables: []bool, position: usize) usize {
var count: usize = 0;
var i: usize = 0;
while (i < availables.len) : (i += 1) {
if (availables[i]) {
if (lines[i][position] == '1')
count += 1;
}
}
return count;
}
fn part2() !void {
var tokenizer = std.mem.tokenize(data, "\r\n");
var lines: [lineCount][]const u8 = undefined;
//Block to limit the scope of lineIndex
{
var lineIndex: usize = 0;
while (tokenizer.next()) |line| {
lines[lineIndex] = line;
lineIndex += 1;
}
}
var oxygenRatings: [lineCount]bool = undefined;
var co2scrubberRatings: [lineCount]bool = undefined;
//Initialize both sets to true
{
var i: usize = 0;
while (i < lineCount) : (i += 1) {
oxygenRatings[i] = true;
co2scrubberRatings[i] = true;
}
}
//Calculate oxygen ratings
{
var i: usize = 0;
while (i < 12) : (i += 1) {
const oxygenRatingsCount = util.countScalar(bool, &oxygenRatings, true);
const co2scrubberRatingsCount = util.countScalar(bool, &co2scrubberRatings, true);
if (oxygenRatingsCount > 1 or co2scrubberRatingsCount > 1) {
const oxygen1BitsCount = countSelected1Bits(&lines, &oxygenRatings, i);
const bestOxygenBit: u8 = if (oxygen1BitsCount >= (oxygenRatingsCount - oxygen1BitsCount)) '1' else '0';
const co21BitsCount = countSelected1Bits(&lines, &co2scrubberRatings, i);
const bestCO2Bit: u8 = if (co21BitsCount >= (co2scrubberRatingsCount - co21BitsCount)) '0' else '1';
for (lines) |line, lineIndex| {
const c = line[i];
if (oxygenRatingsCount > 1 and oxygenRatings[lineIndex]) {
if (c != bestOxygenBit)
oxygenRatings[lineIndex] = false;
}
if (co2scrubberRatingsCount > 1 and co2scrubberRatings[lineIndex]) {
if (c != bestCO2Bit)
co2scrubberRatings[lineIndex] = false;
}
}
}
}
}
print("\nPart2:\n", .{});
var bestOxygenRating: u32 = 0;
var bestCO2Rating: u32 = 0;
for (oxygenRatings) |value, index| {
if (value) {
bestOxygenRating = try std.fmt.parseUnsigned(u32, lines[index], 2);
print("\tBest Oxygen {s} => {d}\n", .{ lines[index], bestOxygenRating });
}
}
for (co2scrubberRatings) |value, index| {
if (value) {
bestCO2Rating = try std.fmt.parseUnsigned(u32, lines[index], 2);
print("\tBest CO2 Scrubber {s} => {d}\n", .{ lines[index], bestCO2Rating });
}
}
print("\tResulting value: {d}\n", .{bestOxygenRating * bestCO2Rating});
}
pub fn main() !void {
try part1();
try part2();
} | src/day03.zig |
const std = @import("std");
const Node = struct {
x: i32,
y: i32,
r: i8,
g: i32,
h: i32,
f: i32,
s: i64,
updated: bool,
closed: bool
};
const Grid = struct {
width: i32,
height: i32,
nodes: std.ArrayList(Node)
};
pub fn newNode(x: i32, y: i32, r: i8) Node {
return Node {
.x = x,
.y = y,
.r = r,
.g = -1,
.h = 0,
.f = 0,
.s = 0,
.updated = false,
.closed = false
};
}
pub fn updateGrid(grid: Grid) !bool {
var minS: i64 = 1 << 62;
var idx: usize = 0;
var node: Node = undefined;
var x: i32 = 0;
while (x < grid.width) : (x += 1) {
var y: i32 = 0;
while (y < grid.height) : (y += 1) {
const cidx: usize = @intCast(usize, x + y * grid.width);
if (!grid.nodes.items[cidx].closed and grid.nodes.items[cidx].updated and grid.nodes.items[cidx].s < minS) {
idx = cidx;
node = grid.nodes.items[idx];
minS = grid.nodes.items[idx].s;
}
}
}
if (minS < (1 << 61)) {
node.closed = true;
grid.nodes.items[idx] = node;
try updateNode(grid, node.x - 1, node.y, node.g);
try updateNode(grid, node.x + 1, node.y, node.g);
try updateNode(grid, node.x, node.y - 1, node.g);
try updateNode(grid, node.x, node.y + 1, node.g);
if (node.x != grid.width - 1 or node.y != grid.height - 1) {
return true;
}
}
return false;
}
pub fn updateNode(grid: Grid, x: i32, y: i32, g: i32) !void {
if (x >= 0 and x < grid.width and y >= 0 and y < grid.height) {
var node = grid.nodes.items[@intCast(usize, x + y * grid.width)];
var ng = g + node.r;
if (!node.closed and (!node.updated or ng < node.g)) {
node.updated = true;
node.g = ng;
node.h = abs(grid.width - 1 - node.x) + abs(grid.height - 1 - node.y);
node.f = node.g + node.h;
node.s = (@intCast(i64, node.f) << 32) | node.h;
grid.nodes.items[@intCast(usize, x + y * grid.width)] = node;
}
}
}
pub fn abs(v: i32) i32 {
if (v >= 0) {
return v;
} else {
return -v;
}
}
pub fn readln(stdin: std.fs.File) ![]const u8 {
var line_buf: [200]u8 = undefined;
const amount = try stdin.read(&line_buf);
const line = std.mem.trimRight(u8, line_buf[0..amount], "\r\n");
return line;
}
pub fn main() !void {
const stdin = std.io.getStdIn();
const stdout = std.io.getStdOut().writer();
const nline = try readln(stdin);
const size = try std.fmt.parseUnsigned(u15, nline, 10);
const caveSize = 5 * size;
var nodes: std.ArrayList(Node) = std.ArrayList(Node).init(std.heap.page_allocator);
var y: i32 = 0;
while (y < size) : (y += 1) {
var x: i32 = 0;
while (x < size) : (x += 1) {
var buf: [1]u8 = undefined;
const value = try stdin.read(&buf);
var ptr: *Node = try nodes.addOne();
ptr.* = newNode(x, y, @intCast(i8, buf[0]) - 48);
}
while (x < caveSize) : (x += 1) {
var ptr: *Node = try nodes.addOne();
ptr.* = newNode(x, y, 0);
}
var buf: [1]u8 = undefined;
const value = try stdin.read(&buf);
}
while (y < caveSize) : (y += 1) {
var x: i32 = 0;
while (x < caveSize) : (x += 1) {
var ptr: *Node = try nodes.addOne();
ptr.* = newNode(x, y, 0);
}
}
y = 0;
while (y < caveSize) : (y += 1) {
var x: i32 = 0;
while (x < caveSize) : (x += 1) {
if (x >= size or y >= size) {
const dst: i32 = @divTrunc(x, size) + @divTrunc(y, size);
const r_o: i32 = nodes.items[@intCast(usize, @mod(x, size) + @mod(y, size) * caveSize)].r;
const r: i8 = @intCast(i8, @mod((r_o + dst - 1), 9) + 1);
nodes.items[@intCast(usize, x + y * caveSize)] = newNode(x, y, r);
}
}
}
const grid = Grid {
.width = caveSize,
.height = caveSize,
.nodes = nodes
};
try updateNode(grid, 0, 0, 0);
while (try updateGrid(grid)) {
//
}
try stdout.print("{d}\n", .{grid.nodes.items[@intCast(usize, (grid.width * grid.height) - 1)].g - grid.nodes.items[0].r});
} | 2021/day15/part2.zig |
const std = @import("std");
const kernel = @import("root");
const mm = kernel.mm;
const lib = kernel.lib;
const x86 = kernel.arch.x86;
const BIT = kernel.lib.BIT;
const bit_set = kernel.lib.bit_set;
const PhysicalAddress = mm.PhysicalAddress;
const VirtualAddress = mm.VirtualAddress;
const mask: u64 = ~@as(u64, 0xfff);
pub fn flushTlb() void {
x86.CR3.write(x86.CR3.read());
}
pub const PT = struct {
root: PhysicalAddress,
base: ?VirtualAddress,
phys2virt: fn (PhysicalAddress) VirtualAddress = kernel.mm.directTranslate,
const EntryType = u64;
const IdxType = u9;
const MaxIndex = std.math.maxInt(IdxType);
const TableFormat = [512]EntryType;
pub const EntryKind = enum {
Missing,
Page4K,
};
pub const PRESENT = BIT(0);
pub const WRITABLE = BIT(1);
pub const USER = BIT(2);
pub const WRITE_THROUGH = BIT(3);
pub const CACHE_DISABLE = BIT(4);
pub const ACCESSED = BIT(5);
pub const DIRTY = BIT(6);
pub const GLOBAL = BIT(8);
pub const NO_EXECUTE = BIT(63);
const Self = @This();
pub fn to_pfn(entry: EntryType) u64 {
return (x86.get_phy_mask() >> 12) & (entry >> 12);
}
fn get_table(self: Self) *TableFormat {
return self.phys2virt(self.root).into_pointer(*TableFormat);
}
pub fn get_entry_kind(self: Self, idx: IdxType) EntryKind {
const entry = self.get_table()[idx];
const is_present = bit_set(entry, PRESENT);
if (is_present) {
return EntryKind.Page4K;
}
return EntryKind.Missing;
}
pub fn get_page(self: Self, idx: IdxType) ?PhysicalAddress {
const entry = self.get_table()[idx];
if (bit_set(entry, PRESENT)) {
return PhysicalAddress.new(entry & mask);
}
return null;
}
pub fn get_entry(self: Self, idx: IdxType) EntryType {
return self.get_table()[idx];
}
pub fn set_entry(self: Self, idx: IdxType, entry: EntryType) void {
self.get_table()[idx] = entry;
}
pub fn init(pt: PhysicalAddress, base: ?VirtualAddress) PT {
return .{ .root = pt, .base = base };
}
fn walk(self: Self, comptime T: type, context: *T) void {
var i: PT.IdxType = 0;
while (true) : (i += 1) {
const page = self.get_page(i);
if (page) |entry| {
const virt = self.base.?.add(i * lib.KiB(4));
context.walk(virt, entry, PageKind.Page4K.size());
}
if (i == PT.MaxIndex) {
break;
}
}
}
pub inline fn get_slot(addr: VirtualAddress) IdxType {
const pt_index = (addr.value >> 12) & 0x1ff;
std.debug.assert(pt_index <= PT.MaxIndex);
return @intCast(PT.IdxType, pt_index);
}
};
pub const PageKind = enum {
Page4K,
Page2M,
Page1G,
pub fn size(self: @This()) usize {
return switch (self) {
.Page4K => lib.KiB(4),
.Page2M => lib.MiB(2),
.Page1G => lib.GiB(1),
};
}
};
pub const PD = struct {
root: PhysicalAddress,
base: ?VirtualAddress,
phys2virt: fn (PhysicalAddress) VirtualAddress = kernel.mm.directTranslate,
const EntryType = u64;
const IdxType = u9;
const MaxIndex = std.math.maxInt(IdxType);
const TableFormat = [512]EntryType;
pub const PRESENT = BIT(0);
pub const WRITABLE = BIT(1);
pub const USER = BIT(2);
pub const WRITE_THROUGH = BIT(3);
pub const CACHE_DISABLE = BIT(4);
pub const ACCESSED = BIT(5);
pub const DIRTY = BIT(6);
pub const PAGE_2M = BIT(7);
pub const GLOBAL = BIT(8);
pub const NO_EXECUTE = BIT(63);
const Self = @This();
pub const EntryKind = enum {
Missing,
Page2M,
PageTable,
};
pub fn to_2mb_pfn(entry: EntryType) u64 {
return (x86.get_phy_mask() >> 21) & (entry >> 21);
}
fn get_table(self: Self) *TableFormat {
return self.phys2virt(self.root).into_pointer(*TableFormat);
}
pub fn get_pt(self: Self, idx: IdxType) ?PT {
const entry = self.get_table()[idx];
if (bit_set(entry, PRESENT) and !bit_set(entry, PAGE_2M)) {
// present
const virt_base = self.base.?.add(idx * lib.MiB(2));
return PT.init(PhysicalAddress.new(entry & mask), virt_base);
}
return null;
}
pub fn get_pt_alloc(self: Self, allocator: *mm.FrameAllocator, idx: IdxType) !PT {
if (self.get_pt(idx) == null) {
const frame = try allocator.alloc_zero_frame();
const v = frame.value | PD.USER.v() | PD.WRITABLE.v() | PD.PRESENT.v();
self.set_entry(idx, v);
}
return self.get_pt(idx).?;
}
pub fn get_page_2m(self: Self, idx: IdxType) ?PhysicalAddress {
const entry = self.get_table()[idx];
if (bit_set(entry, PRESENT) and bit_set(entry, PAGE_2M)) {
// physical address mask - low 20 bits
const addr_bits = x86.get_phy_mask() ^ ((1 << 21) - 1);
return PhysicalAddress.new(entry & addr_bits);
}
return null;
}
pub fn get_entry(self: Self, idx: IdxType) EntryType {
return self.get_table()[idx];
}
pub fn get_entry_kind(self: Self, idx: IdxType) EntryKind {
const entry = self.get_table()[idx];
const is_present = bit_set(entry, PRESENT);
const is_2m = bit_set(entry, PAGE_2M);
if (is_present and is_2m) {
return EntryKind.Page2M;
} else if (is_present) {
return EntryKind.PageTable;
}
return EntryKind.Missing;
}
pub fn set_entry(self: Self, idx: IdxType, entry: EntryType) void {
self.get_table()[idx] = entry;
}
pub fn init(pd: PhysicalAddress, base: VirtualAddress) PD {
return .{ .root = pd, .base = base };
}
fn walk(self: Self, comptime T: type, context: *T) void {
var i: PD.IdxType = 0;
while (true) : (i += 1) {
switch (self.get_entry_kind(i)) {
.PageTable => {
const entry = self.get_pt(i).?;
entry.walk(T, context);
},
.Page2M => {
const entry = self.get_page_2m(i).?;
context.walk(self.base.?.add(i * lib.MiB(2)), entry, PageKind.Page2M.size());
},
else => {},
}
if (i == PD.MaxIndex) {
break;
}
}
}
pub fn get_slot(addr: VirtualAddress) IdxType {
const pd_index = (addr.value >> 21) & 0x1ff;
std.debug.assert(pd_index <= PD.MaxIndex);
return @intCast(PD.IdxType, pd_index);
}
};
pub const PDPT = struct {
root: PhysicalAddress,
base: ?VirtualAddress,
phys2virt: fn (PhysicalAddress) VirtualAddress = kernel.mm.directTranslate,
const IdxType = u9;
const EntryType = u64;
const MaxIndex = std.math.maxInt(IdxType);
const TableFormat = [MaxIndex + 1]EntryType;
pub const PRESENT = BIT(0);
pub const WRITABLE = BIT(1);
pub const USER = BIT(2);
pub const WRITE_THROUGH = BIT(3);
pub const CACHE_DISABLE = BIT(4);
pub const ACCESSED = BIT(5);
pub const DIRTY = BIT(6);
pub const PAGE_1G = BIT(7);
pub const GLOBAL = BIT(8);
pub const NO_EXECUTE = BIT(63);
const Self = @This();
pub const EntryKind = enum {
Missing,
PD,
Page1G,
};
pub fn get_entry_kind(self: Self, idx: IdxType) EntryKind {
const entry = self.get_table()[idx];
const is_present = bit_set(entry, PRESENT);
if (is_present and bit_set(entry, PAGE_1G)) {
return EntryKind.Page1G;
} else if (is_present) {
return EntryKind.PD;
}
return EntryKind.Missing;
}
fn get_table(self: Self) *TableFormat {
return self.phys2virt(self.root).into_pointer(*TableFormat);
}
fn get_entry(self: Self, idx: IdxType) EntryType {
return self.get_table()[idx];
}
pub fn set_entry(self: Self, idx: IdxType, entry: EntryType) void {
self.get_table()[idx] = entry;
}
pub fn get_pd(self: Self, idx: IdxType) ?PD {
const entry = self.get_entry(idx);
if (bit_set(entry, PRESENT) and !bit_set(entry, PAGE_1G)) {
// present
const virt_base = self.base.?.add(lib.GiB(1) * idx);
return PD.init(PhysicalAddress.new(entry & mask), virt_base);
}
return null;
}
pub fn get_pd_alloc(self: Self, allocator: *mm.FrameAllocator, idx: IdxType) !PD {
if (self.get_pd(idx) == null) {
const frame = try allocator.alloc_zero_frame();
const v = frame.value | PDPT.USER.v() | PDPT.WRITABLE.v() | PDPT.PRESENT.v();
self.set_entry(idx, v);
}
return self.get_pd(idx).?;
}
pub fn init(pdp: PhysicalAddress, base: ?VirtualAddress) PDPT {
return .{ .root = pdp, .base = base };
}
fn walk(self: Self, comptime T: type, context: *T) void {
var i: PDPT.IdxType = 0;
while (true) : (i += 1) {
const pd = self.get_pd(i);
if (pd) |entry| {
entry.walk(T, context);
}
if (i == PDPT.MaxIndex) {
break;
}
}
}
pub fn get_slot(addr: VirtualAddress) IdxType {
const pdpt_index = (addr.value >> 30) & 0x1ff;
std.debug.assert(pdpt_index <= PDPT.MaxIndex);
return @intCast(PDPT.IdxType, pdpt_index);
}
};
pub const PML4 = struct {
root: PhysicalAddress,
// Missing base implies 4 level paging scheme
base: ?VirtualAddress,
phys2virt: fn (PhysicalAddress) VirtualAddress = kernel.mm.directTranslate,
const IdxType = u9;
const EntryType = u64;
const MaxIndex = std.math.maxInt(IdxType);
const TableFormat = [MaxIndex + 1]EntryType;
const PRESENT = BIT(0);
const WRITABLE = BIT(1);
const USER = BIT(2);
const WRITE_THROUGH = BIT(3);
const CACHE_DISABLE = BIT(4);
const ACCESSED = BIT(5);
const NO_EXECUTE = BIT(63);
const Self = @This();
pub const EntryKind = enum {
Missing,
PDPT,
};
pub fn init(pml4: PhysicalAddress, base: ?VirtualAddress) PML4 {
return .{ .root = pml4, .base = base };
}
pub fn get_entry_kind(self: Self, idx: IdxType) EntryKind {
const entry = self.get_table()[idx];
const is_present = bit_set(entry, PRESENT);
if (is_present) {
return EntryKind.PDPT;
}
return EntryKind.Missing;
}
fn get_table(self: Self) *TableFormat {
return self.phys2virt(self.root).into_pointer(*TableFormat);
}
/// Some special handling for 48-bit paging
fn get_virt_base(self: Self, idx: IdxType) VirtualAddress {
const offset = idx * lib.GiB(512);
// Easy case, we know the base
if (self.base) |base| {
return base.add(offset);
}
// Compute high bits
if (bit_set(offset, BIT(47))) {
return VirtualAddress.new(0xffff000000000000).add(offset);
}
return VirtualAddress.new(offset);
}
pub fn get_pdpt(self: @This(), idx: IdxType) ?PDPT {
const entry = self.get_entry(idx);
if (bit_set(entry, PRESENT)) {
const virt_base = self.get_virt_base(idx);
return PDPT.init(PhysicalAddress.new(entry & mask), virt_base);
}
return null;
}
pub fn get_pdpt_alloc(self: @This(), allocator: *mm.FrameAllocator, idx: IdxType) !PDPT {
if (self.get_pdpt(idx) == null) {
const frame = try allocator.alloc_zero_frame();
const v = frame.value | PML4.USER.v() | PML4.WRITABLE.v() | PML4.PRESENT.v();
self.set_entry(idx, v);
}
return self.get_pdpt(idx).?;
}
pub fn get_entry(self: @This(), idx: IdxType) EntryType {
return self.get_table()[idx];
}
pub fn set_entry(self: Self, idx: IdxType, entry: EntryType) void {
self.get_table()[idx] = entry;
}
pub fn walk(self: Self, comptime T: type, context: *T) void {
var i: PML4.IdxType = 0;
while (true) : (i += 1) {
const pdp = self.get_pdpt(i);
if (pdp) |entry| {
entry.walk(T, context);
}
if (i == PML4.MaxIndex) {
break;
}
}
context.done();
}
pub fn get_slot(addr: VirtualAddress) IdxType {
const pml4_index_ = (addr.value >> 39) & 0x1ff;
std.debug.assert(pml4_index_ <= PML4.MaxIndex);
return @intCast(PML4.IdxType, pml4_index_);
}
}; | kernel/arch/x86/paging.zig |
const std = @import("std");
const string = []const u8;
const base32 = @import("./base32.zig");
const extras = @import("extras");
pub const Factory = struct {
epoch: i64,
rand: std.rand.Random,
pub fn init(epoch: i64, rand: std.rand.Random) Factory {
return Factory{
.epoch = epoch,
.rand = rand,
};
}
pub fn newULID(self: Factory) ULID {
const now = std.time.milliTimestamp();
return ULID{
.timestamp = std.math.cast(u48, now - self.epoch) catch @panic("time.milliTimestamp() is higher than 281474976710655"),
.randomnes = self.rand.int(u80),
};
}
};
/// 01AN4Z07BY 79KA1307SR9X4MV3
///
/// |----------| |----------------|
/// Timestamp Randomness
/// 48bits 80bits
pub const ULID = struct {
timestamp: u48,
randomnes: u80,
pub const BaseType = string;
usingnamespace extras.StringerJsonStringifyMixin(@This());
pub fn parse(alloc: std.mem.Allocator, value: BaseType) !ULID {
if (value.len != 26) return error.Ulid;
return ULID{
.timestamp = try std.math.cast(u48, try extras.sliceToInt(u50, u5, try base32.decode(alloc, value[0..10]))),
.randomnes = try extras.sliceToInt(u80, u5, try base32.decode(alloc, value[10..26])),
};
}
pub fn toString(self: ULID, alloc: std.mem.Allocator) !BaseType {
var res = try std.ArrayList(u8).initCapacity(alloc, 26);
defer res.deinit();
try res.writer().print("{}", .{self});
return res.toOwnedSlice();
}
pub const readField = parse;
pub const bindField = toString;
pub fn format(self: ULID, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
var buf: [26]u8 = undefined;
base32.formatInt(u48, self.timestamp, buf[0..10]);
base32.formatInt(u80, self.randomnes, buf[10..26]);
try writer.writeAll(&buf);
}
}; | ulid.zig |
const std = @import("std");
const Data = @import("../events/events.zig").Data;
const Event = @import("../events/events.zig").Event;
pub const Error = error{
BodyTooshort,
BodyTooLarge,
};
pub const ContentLengthReader = struct {
expected_length: usize,
read_bytes: usize = 0,
pub fn read(self: *ContentLengthReader, reader: anytype, buffer: []u8) !Event {
if (self.read_bytes == self.expected_length) {
return .EndOfMessage;
}
var count = try reader.read(buffer);
if (count == 0) {
return Error.BodyTooshort;
}
self.read_bytes += count;
if (self.read_bytes > self.expected_length) {
return Error.BodyTooLarge;
}
return Event{ .Data = Data{ .bytes = buffer[0..count] } };
}
};
const expect = std.testing.expect;
const expectEqualStrings = std.testing.expectEqualStrings;
const expectError = std.testing.expectError;
test "ContentLengthReader - Fail when the body is shorter than expected." {
const content = "";
var reader = std.io.fixedBufferStream(content).reader();
var body_reader = ContentLengthReader{ .expected_length = 14 };
var buffer: [32]u8 = undefined;
const failure = body_reader.read(reader, &buffer);
try expectError(error.BodyTooshort, failure);
}
test "ContentLengthReader - Read" {
const content = "Gotta go fast!";
var reader = std.io.fixedBufferStream(content).reader();
var body_reader = ContentLengthReader{ .expected_length = 14 };
var buffer: [32]u8 = undefined;
var event = try body_reader.read(reader, &buffer);
try expectEqualStrings(event.Data.bytes, "Gotta go fast!");
event = try body_reader.read(reader, &buffer);
try expect(event == .EndOfMessage);
}
test "ContentLengthReader - Read in several call" {
const content = "a" ** 32 ++ "b" ** 32 ++ "c" ** 32;
var reader = std.io.fixedBufferStream(content).reader();
var body_reader = ContentLengthReader{ .expected_length = 96 };
var buffer: [32]u8 = undefined;
var event = try body_reader.read(reader, &buffer);
try expectEqualStrings(event.Data.bytes, "a" ** 32);
event = try body_reader.read(reader, &buffer);
try expectEqualStrings(event.Data.bytes, "b" ** 32);
event = try body_reader.read(reader, &buffer);
try expectEqualStrings(event.Data.bytes, "c" ** 32);
event = try body_reader.read(reader, &buffer);
try expect(event == .EndOfMessage);
} | src/readers/content_length_reader.zig |
const std = @import("std");
const nacl = std.crypto.nacl;
const ed25519 = std.crypto.sign.Ed25519;
const allocator = std.heap.page_allocator;
var buffer_len: u32 = 0;
export fn wlen() u32 { return buffer_len; }
export fn wfree(ptr: u32, len: usize) void { allocator.free(@intToPtr([*]u8, ptr)[0..len]); }
export fn walloc(len: usize) u32 { return @ptrToInt((allocator.alloc(u8, len) catch return 0).ptr); }
export fn sign_verify(ptr: u32, len: usize, sptr: u32, kptr: u32) u8 {
const in = @intToPtr([*]u8, ptr)[0..len];
const key = @intToPtr([*]u8, kptr)[0..ed25519.public_length];
const sig = @intToPtr([*]u8, sptr)[0..ed25519.signature_length];
defer allocator.free(in);
defer allocator.free(sig);
defer allocator.free(key);
ed25519.verify(sig.*, in, key.*) catch return 0;
return 1;
}
export fn sign_sign(ptr: u32, len: usize, key: u32, noise: u32) u32 {
const in = @intToPtr([*]u8, ptr)[0..len];
const secret = @intToPtr([*]u8, key)[0..ed25519.secret_length];
defer allocator.free(in);
defer allocator.free(secret);
const pair = ed25519.KeyPair.fromSecretKey(secret.*);
const out = allocator.alloc(u8, ed25519.signature_length) catch return 0;
if (0 == noise) {
std.mem.copy(u8, (ed25519.sign(in, pair, null) catch return 1)[0..], out);
return @ptrToInt(out.ptr);
} else {
const n = @intToPtr([*]u8, noise)[0..ed25519.noise_length];
defer allocator.free(n);
std.mem.copy(u8, (ed25519.sign(in, pair, n.*) catch return 1)[0..], out);
return @ptrToInt(out.ptr);
}
}
export fn secretbox_seal(ptr: u32, len: usize, kptr: u32, nptr: u32) u32 {
const in = @intToPtr([*]u8, ptr)[0..len];
const key = @intToPtr([*]u8, kptr)[0..nacl.SecretBox.key_length];
const nonce = @intToPtr([*]u8, nptr)[0..nacl.SecretBox.nonce_length];
defer allocator.free(in);
defer allocator.free(key);
defer allocator.free(nonce);
errdefer allocator.free(in);
errdefer allocator.free(key);
errdefer allocator.free(nonce);
buffer_len = in.len + nacl.SecretBox.tag_length;
const out = allocator.alloc(u8, buffer_len) catch return 0;
nacl.SecretBox.seal(out, in, nonce.*, key.*);
return @ptrToInt(out.ptr);
}
export fn secretbox_open(ptr: u32, len: usize, kptr: u32, nptr: u32) u32 {
const in = @intToPtr([*]u8, ptr)[0..len];
const key = @intToPtr([*]u8, kptr)[0..nacl.SecretBox.key_length];
const nonce = @intToPtr([*]u8, nptr)[0..nacl.SecretBox.nonce_length];
defer allocator.free(in);
defer allocator.free(key);
defer allocator.free(nonce);
errdefer allocator.free(in);
errdefer allocator.free(key);
errdefer allocator.free(nonce);
buffer_len = in.len - nacl.SecretBox.tag_length;
const out = allocator.alloc(u8, buffer_len) catch return 0;
nacl.SecretBox.open(out, in, nonce.*, key.*) catch return 1;
return @ptrToInt(out.ptr);
} | src/nacl/nacl.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Str = []const u8;
const BitSet = std.DynamicBitSet;
const StrMap = std.StringHashMap;
const HashMap = std.HashMap;
const Map = std.AutoHashMap;
const PriorityQueue = std.PriorityQueue;
const assert = std.debug.assert;
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const print = std.debug.print;
const parseInt = std.fmt.parseInt;
const abs = std.math.absInt;
const OOM = error{OutOfMemory};
const fs = std.fs;
fn sort(comptime T: type, items: []T) void {
std.sort.sort(T, items, {}, comptime std.sort.asc(T));
}
fn println(x: Str) void {
print("{s}\n", .{x});
}
const header = @embedFile("./header2.txt");
var argBuffer: [1000 + std.fs.MAX_PATH_BYTES]u8 = undefined;
const fortuneFilename = "/fortunes-all.dat"; // TODO workaround for std.fs.cwd() not being able to run at compile time
comptime {
assert(header.len == 8);
}
const maxFortuneLen = std.mem.readIntNative(u32, header[0..4]);
const numFortunes = std.mem.readIntNative(u32, header[4..8]);
var fortuneBuffer: [maxFortuneLen]u8 = undefined;
pub fn main() !void {
const fortuneFullFilename = std.fs.path.dirname(@src().file).? ++ fortuneFilename;
const stdout = std.io.getStdOut().writer();
const allocator = std.heap.FixedBufferAllocator.init(&argBuffer).allocator();
var argsIt = std.process.args();
_ = try argsIt.next(allocator);
const first_ = try argsIt.next(allocator);
if (first_) |first| {
const fortuneNum = try parseInt(u32, first, 10);
if (fortuneNum >= numFortunes) {
println("Number exceeds num fortunes");
return error.InvalidArgument;
}
const fortuneFile = try fs.Dir.openFile(fs.cwd(), fortuneFullFilename, .{});
defer fortuneFile.close();
_ = try fortuneFile.pread(&fortuneBuffer, fortuneNum * maxFortuneLen);
// look for null byte in fortuneBuffer
const end = std.mem.indexOfScalar(u8, &fortuneBuffer, 0) orelse fortuneBuffer.len;
try stdout.writeAll("Your lucky number is ");
try stdout.writeAll(first);
try stdout.writeByte('\n');
try stdout.writeAll(fortuneBuffer[0..end]);
try stdout.writeByte('\n');
} else {
println("Please enter a number");
return error.NoArgument;
}
} | fortune.zig |
const GBA = @import("core.zig").GBA;
pub const Bitmap16 = struct {
pub fn line(x1: i32, y1: i32, x2: i32, y2: i32, color: u16, destinationBase: [*]volatile u16, rawPitch: i32) void {
var ii: i32 = 0;
var dx: i32 = 0;
var dy: i32 = 0;
var xstep: i32 = 0;
var ystep: i32 = 0;
var dd: i32 = 0;
var destinationPitch: i32 = 0;
destinationPitch = @divExact(rawPitch, 2);
var destination = @intToPtr([*]u16, @ptrToInt(destinationBase) + @intCast(usize, y1) * @intCast(usize, rawPitch) + @intCast(usize, x1) * 2);
// Normalization
if (x1 > x2) {
xstep = -1;
dx = x1 - x2;
} else {
xstep = 1;
dx = x2 - x1;
}
if (y1 > y2) {
ystep = -destinationPitch;
dy = y1 - y2;
} else {
ystep = destinationPitch;
dy = y2 - y1;
}
if (dy == 0) {
// Horizontal line case
ii = 0;
while (ii <= dx) : (ii += 1) {
destination[@bitCast(usize, ii * xstep)] = color;
}
} else if (dx == 0) {
// Vertical line case
ii = 0;
while (ii <= dy) : (ii += 1) {
destination[@bitCast(usize, ii * ystep)] = color;
}
} else if (dx >= dy) {
// Diagonal, slope <= 1
dd = 2 * dy - dx;
ii = 0;
var destinationIndex: i32 = 0;
while (ii <= dx) : (ii += 1) {
destination[@bitCast(usize, destinationIndex)] = color;
if (dd >= 0) {
dd -= 2 * dx;
destinationIndex += ystep;
}
dd += 2 * dy;
destinationIndex += xstep;
}
} else {
// Diagonal, slop > 1
dd = 2 * dx - dy;
ii = 0;
var destinationIndex: i32 = 0;
while (ii <= dy) : (ii += 1) {
destination[@bitCast(usize, destinationIndex)] = color;
if (dd >= 0) {
dd -= 2 * dy;
destinationIndex += xstep;
}
dd += 2 * dx;
destinationIndex += ystep;
}
}
}
pub fn rect(left: i32, top: i32, right: i32, bottom: i32, color: u16, destinationBase: [*]volatile u16, rawPitch: i32) void {
var ix: i32 = 0;
var iy: i32 = 0;
var width: i32 = right - left;
var height: i32 = bottom - top;
var destinationPitch: i32 = @divExact(rawPitch, 2);
var destination = @intToPtr([*]u16, @ptrToInt(destinationBase) + @intCast(usize, top) * @intCast(usize, rawPitch) + @intCast(usize, left) * 2);
iy = 0;
while(iy < height) : (iy += 1) {
var rectPitch:i32 = iy * destinationPitch;
ix = 0;
while (ix < width) : (ix += 1) {
destination[@bitCast(usize, rectPitch + ix)] = color;
}
}
}
pub fn frame(left: i32, top: i32, right: i32, bottom: i32, color: u16, destinationBase: [*]volatile u16, rawPitch: i32) void {
var actualRight:i32 = right - 1;
var actualBottom:i32 = bottom - 1;
line(left, top, actualRight, top, color, destinationBase, rawPitch);
line(left, actualBottom, actualRight, actualBottom, color, destinationBase, rawPitch);
line(left, top, left, actualBottom, color, destinationBase, rawPitch);
line(actualRight, top, actualRight, actualBottom, color, destinationBase, rawPitch);
}
}; | GBA/bitmap.zig |
const std = @import("std");
const warn = std.debug.warn;
const os = std.os;
pub const c = @cImport({
@cInclude("time.h");
@cInclude("curl/curl.h");
});
pub fn get_socket(host: [*:0]const u8, port: [*:0]const u8) !c_int {
var s: c_int = undefined;
var hints: os.addrinfo = undefined;
var res: *os.addrinfo = undefined;
defer std.c.freeaddrinfo(res);
const p = @ptrCast([*]u8, &hints);
std.mem.set(u8, p[0..@sizeOf(os.addrinfo)], 0);
hints.family = os.AF_UNSPEC;
hints.socktype = os.SOCK_STREAM;
hints.flags = std.c.AI_PASSIVE;
var rc = std.c.getaddrinfo(host, port, &hints, &res);
if (rc == std.c.EAI.FAIL) {
warn("getaddrinfo error: {}\n", .{std.c.gai_strerror(rc)});
return error.GetAddrError;
}
s = std.c.socket(@intCast(c_uint, res.family), @intCast(c_uint, res.socktype), @intCast(c_uint, res.protocol));
if (s < 0) {
warn("Couldn't get socket.\n", .{});
return error.SocketError;
}
if (std.c.connect(s, res.addr orelse return error.SocketErrorNoAddr, res.addrlen) < 0) {
warn("Couldn't connect.\n", .{});
return error.ConnectionError;
}
return s;
}
pub fn sck_send(s: c_int, data: [:0]const u8, size: usize) !usize {
var written: usize = 0;
while (written < size) {
const rc = std.c.send(s, data.ptr + written, size - written, 0);
if (rc <= 0)
return error.InvalidSend;
written += @intCast(usize, rc);
}
return written;
}
pub fn get_time() [*c]const c.tm {
var t = c.time(null);
return c.localtime(&t);
}
pub fn get_time_str(buf: []u8) usize {
var tm = get_time();
return c.strftime(@ptrCast([*c]u8, buf.ptr), buf.len, "%m-%y-%d %I:%M:%S", tm);
}
fn curl_write_fn(contents: *c_void, size: usize, nmemb: usize, userp: *align(@alignOf([]u8)) c_void) usize {
const bytesize = size * nmemb;
const contsp = @ptrCast([*]u8, contents);
var bufferp = @ptrCast(*std.Buffer, userp);
_ = bufferp.*.append(contsp[0..bytesize]) catch |e| {
std.debug.warn("{}\n", .{e});
return 0;
};
return bytesize;
}
pub fn curl_get(url: [:0]const u8, raw_headers: [][]const u8) !std.json.ValueTree {
// std.debug.warn("curl_get: url {}\n", .{url});
var res = c.curl_global_init(c.CURL_GLOBAL_ALL);
var curl = c.curl_easy_init() orelse return error.FailedInit;
defer {
c.curl_easy_cleanup(curl);
c.curl_global_cleanup();
}
var headers = @intToPtr([*]allowzero c.curl_slist, 0);
defer c.curl_slist_free_all(headers);
var mem = try std.Buffer.init(std.heap.c_allocator, "");
// defer mem.deinit();
for (raw_headers) |rh| {
var hdr_buf: [256]u8 = undefined;
const h = try std.fmt.bufPrint(&hdr_buf, "{s}\x00", .{rh});
headers = c.curl_slist_append(headers, h.ptr);
}
_ = c.curl_easy_setopt(curl, c.CURLoption.CURLOPT_URL, url.ptr);
_ = c.curl_easy_setopt(curl, c.CURLoption.CURLOPT_WRITEFUNCTION, curl_write_fn);
_ = c.curl_easy_setopt(curl, c.CURLoption.CURLOPT_WRITEDATA, &mem);
_ = c.curl_easy_setopt(curl, c.CURLoption.CURLOPT_CUSTOMREQUEST, "GET");
_ = c.curl_easy_setopt(curl, c.CURLoption.CURLOPT_HTTPHEADER, headers);
// curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "age=42&sex=male");
res = c.curl_easy_perform(curl);
// std.debug.warn("{} \n", .{mem.len});
// std.debug.warn("{} \n", .{mem.toSliceConst()});
var parser = std.json.Parser.init(std.heap.c_allocator, false);
defer parser.deinit();
var json = try parser.parse(mem.toSliceConst());
return json;
} | src/c.zig |
pub const segsize_t = u32;
pub const segaddr_t = u32;
pub const segflag_t = u8;
pub const segtype_t = u4;
/// Segment Descriptor and their structures.
pub const SegmentDescriptor = packed struct {
// const values
pub const CS_TYPE: segflag_t = 0x9A;
pub const DS_TYPE: segflag_t = 0x92;
// internal constants referring to 32- and
// 64- bit addressing types
const ADDR16B = 0x4;
const ADDR32B = 0xC;
// fields
size_lo: u16 = 0,
addr_lo: u24 = 0,
flags: segflag_t = 0,
segtype: segtype_t = ADDR16B,
size_hi: u4 = 0,
addr_hi: u8 = 0,
/// generates a segment descriptor struct based off of address,
/// size, and flags parameters.
pub fn new(addr_: segaddr_t, size_: segsize_t, flags_: segflag_t) SegmentDescriptor {
const addr_lo = @intCast(u24, addr_ & 0xFF_FFFF);
const addr_hi = @intCast(u8, addr_ >> 24);
var size_adj : segsize_t = undefined;
var segtype : segtype_t = undefined;
if (size_ < 0x1_0000) {
size_adj = size_;
segtype = ADDR16B;
} else if ((size_ & 0xFFF) != 0xFFF) {
size_adj = (size_ >> 12) - 1;
segtype = ADDR32B;
} else {
size_adj = size_ >> 12;
segtype = ADDR32B;
}
const size_lo = @intCast(u16, size_adj & 0xFFFF);
const size_hi = @intCast(u4, size_adj >> 16);
return SegmentDescriptor{
.size_lo = size_lo,
.addr_lo = addr_lo,
.flags = flags_,
.segtype = segtype,
.size_hi = size_hi,
.addr_hi = addr_hi
};
}
/// calculates the 32-bit value of the segment address, reassembling it
/// from the awkward struct presented by the system.
pub fn addr(self: *SegmentDescriptor) segaddr_t {
const addr_lo_32 = @intCast(segaddr_t, self.addr_lo);
const addr_hi_32 = @intCast(segaddr_t, self.addr_hi);
return (addr_hi_32 << 24) | addr_lo_32;
}
/// calculates the 32-bit value of the segment size, reassembling it
/// from the awkward struct presented by the system.
pub fn size(self: *SegmentDescriptor) segsize_t {
const size_lo_32 = @intCast(segsize_t, self.size_lo);
const size_hi_32 = @intCast(segsize_t, self.size_hi);
const size_all = (size_hi_32 << 16) | size_lo_32;
return switch (self.segtype) {
ADDR16B => size_all,
ADDR32B => _calc_32b_segaddr(size_all),
else => unreachable,
};
}
fn _calc_32b_segaddr(size_all: segsize_t) segsize_t {
// check the parity on this function
if ((size_all & 0x1) != 0) {
// if it's odd, bitshift on the incremented value
return (size_all + 1) << 12;
} else {
// if it's even, do a normal bitshift and append secret Fs.
return (size_all << 12) | 0xFFF;
}
}
};
// ////////////////////////////////////////////////////////////////////////
// TESTING
const assert = @import("std").debug.assert;
test "the new function places addr value as expected" {
// address segment is split into high and low.
var seg_1 = SegmentDescriptor.new(0x1234_5678, 0, 0);
assert(seg_1.addr_lo == 0x34_5678);
assert(seg_1.addr_hi == 0x12);
}
test "the new function places size value as expected" {
// segment size is split into high and low, for < 16 bit limit
// addressing
var seg_2 = SegmentDescriptor.new(0, 0x02345, 0);
assert(seg_2.size_lo == 0x2345);
assert(seg_2.size_hi == 0x0);
assert(seg_2.segtype == SegmentDescriptor.ADDR16B);
// segment size is split into high and low, for > 16 bit limit
// addressing
var seg_3 = SegmentDescriptor.new(0, 0x10000, 0);
assert(seg_3.size_lo == 0x000F);
assert(seg_3.size_hi == 0x0);
assert(seg_3.segtype == SegmentDescriptor.ADDR32B);
// segment size is split into high and low, for > 16 bit limit
// addressing with special tail flag
var seg_4 = SegmentDescriptor.new(0, 0x10FFF, 0);
assert(seg_4.size_lo == 0x0010);
assert(seg_4.size_hi == 0x0);
assert(seg_4.segtype == SegmentDescriptor.ADDR32B);
}
test "the addr function retrieves the address value as expected" {
var seg_addr = SegmentDescriptor{
.addr_lo = 0x345678,
.addr_hi = 0x12,
};
assert(seg_addr.addr() == 0x12345678);
}
test "the size function retrieves the size value as expected" {
// when the segment type is specifying that 16-bit addressing
// is used.
var seg_size1 = SegmentDescriptor{
.size_lo = 0x2345,
.size_hi = 1,
};
assert(seg_size1.size() == 0x12345);
// when the segment type is specifying that 32-bit addressing
// is used.
var seg_size2 = SegmentDescriptor{
.size_lo = 0x000F,
.size_hi = 0x0,
.segtype = SegmentDescriptor.ADDR32B,
};
assert(seg_size2.size() == 0x10000);
// when the segment type is specifying that 32-bit addressing
// is used.
var seg_size3 = SegmentDescriptor{
.size_lo = 0x0010,
.size_hi = 0x0,
.segtype = SegmentDescriptor.ADDR32B,
};
assert(seg_size3.size() == 0x10FFF);
} | kernel/segment_descriptor.zig |
const std = @import("std");
const strings = @import("../strings/strings.zig");
const warn = std.debug.warn;
pub const Builder = struct {
buf: *std.Buffer,
replacer: strings.StringReplacer,
choice_replacer: strings.StringReplacer,
a: *std.mem.Allocator,
current_tab_stop: usize,
pub fn init(a: *std.mem.Allocator, buf: *std.Buffer) !Builder {
return Builder{
.buf = buf,
.replacer = try strings.StringReplacer.init(
a,
[][]const u8{
[]const u8{0x5c}, []const u8{ 0x5c, 0x5c },
[]const u8{0x7d}, []const u8{ 0x5c, 0x7d },
[]const u8{0x24}, []const u8{ 0x5c, 0x24 },
},
),
.choice_replacer = try strings.StringReplacer.init(
a,
[][]const u8{
[]const u8{0x5c}, []const u8{ 0x5c, 0x5c },
[]const u8{0x7d}, []const u8{ 0x5c, 0x7d },
[]const u8{0x24}, []const u8{ 0x5c, 0x24 },
[]const u8{0x7c}, []const u8{ 0x5c, 0x7c },
[]const u8{0x2c}, []const u8{ 0x5c, 0x2c },
},
),
.a = a,
.current_tab_stop = 0,
};
}
pub fn writeChoice(self: *Builder, choices: []const []const u8) !void {
var stream = &std.io.BufferOutStream.init(self.buf).stream;
try stream.write("${");
try stream.print("{}|", self.nextTabStop());
var tmp = &try std.Buffer.init(self.a, "");
defer tmp.deinit();
for (choices) |choice, i| {
if (i != 0) {
try stream.writeByte(',');
}
try tmp.resize(0);
try (&self.choice_replacer).replace(choice, tmp);
try stream.write(tmp.toSlice());
}
try stream.write("|}");
}
fn nextTabStop(self: *Builder) usize {
self.current_tab_stop += 1;
return self.current_tab_stop;
}
fn writeText(self: *Builder, text: []const u8) !void {
var tmp = &try std.Buffer.init(self.a, "");
defer tmp.deinit();
try (&self.replacer).replace(text, tmp);
try self.buf.append(tmp.toSlice());
}
fn reset(self: *Builder) !void {
try self.buf.resize(0);
self.current_tab_stop = 0;
}
fn writePlaceholder(self: *Builder, cb: ?fn (*Builder) anyerror!void) !void {
var stream = &std.io.BufferOutStream.init(self.buf).stream;
try stream.write("${");
try stream.print("{}", self.nextTabStop());
if (cb) |f| {
try stream.writeByte(':');
try f(self);
}
try stream.writeByte('}');
}
pub fn toSliceConst(self: *Builder) []const u8 {
return self.buf.toSliceConst();
}
}; | src/lsp/snippet/snippet.zig |
const std = @import("std");
const Buffer = @import("../main.zig").Buffer;
const Rect = @import("../main.zig").Rect;
const Widget = @import("Widget.zig");
const TextStyle = @import("../style.zig").TextStyle;
const chars = @import("chars.zig");
const Self = @This();
widget: Widget = .{ .drawFn = draw, .sizeFn = size },
size: Rect = undefined,
title: ?[]const u8 = null,
title_style: TextStyle = .default,
pub fn init() Self {
return .{};
}
pub fn setSize(self: *Self, r: Rect) *Self {
self.size = r;
return self;
}
pub fn setTitle(self: *Self, title: []const u8, style: TextStyle) *Self {
self.title = title;
self.title_style = style;
return self;
}
pub fn draw(widget: *Widget, buf: *Buffer) void {
var self = @fieldParentPtr(Self, "widget", widget);
std.debug.assert(self.size.h + self.size.row < buf.size.height);
std.debug.assert(self.size.w + self.size.col < buf.size.width);
var row: usize = self.size.row;
var x: usize = self.size.col;
// borders
buf.getRef(x, row).*.value = chars.ULCorner;
buf.getRef(x, row).*.value = chars.ULCorner;
buf.getRef(x + self.size.w, row).*.value = chars.URCorner;
buf.getRef(x, self.size.h + self.size.row).*.value = chars.LLCorner;
buf.getRef(x + self.size.w, self.size.h + self.size.row).*.value = chars.LRCorner;
row += 1;
// vertical lines
while (row < self.size.h + self.size.row) : (row += 1) {
buf.getRef(x, row).*.value = chars.VLine;
buf.getRef(x + self.size.w, row).*.value = chars.VLine;
}
// horizontal
{
var col: usize = self.size.col + 1;
var y: usize = self.size.row;
while (col < self.size.w + self.size.col) : (col += 1) {
buf.getRef(col, y).*.value = chars.HLine;
buf.getRef(col, y + self.size.h).*.value = chars.HLine;
}
}
// draw title
if (self.title) |title| {
const start: usize = self.size.col + 1;
var col: usize = start;
while (col - start < title.len and col - start < self.size.w - 1) : (col += 1) {
var cell = buf.getRef(col, self.size.row);
cell.*.value = title[col - start];
cell.*.style = self.title_style;
}
}
}
pub fn size(widget: *Widget) Rect {
var self = @fieldParentPtr(Self, "widget", widget);
return self.size;
} | src/widget/Box.zig |
usingnamespace @import("bits.zig");
usingnamespace @import("fdman.zig");
usingnamespace @import("cwd.zig");
pub var errno: u32 = 0;
fn pspErrToErrno(code: u64) i32 {
if ((code & 0x80010000) == 0x80010000) {
errno = @truncate(u32, code & 0xFFFF);
return -1;
}
return @bitCast(i32, @truncate(u32, code));
}
pub fn getErrno(r: c_int) usize {
return errno;
}
usingnamespace @import("../include/pspiofilemgr.zig");
usingnamespace @import("../include/pspstdio.zig");
usingnamespace @import("../include/psprtc.zig");
pub fn read(fd: fd_t, ptr: [*]u8, len: usize) i32 {
if (!__psp_fdman_fdValid(fd)) {
errno = EBADF;
return -1;
}
switch (__psp_descriptormap[fd].?.ftype) {
.File, .Tty => {
return pspErrToErrno(@bitCast(u32, sceIoRead(__psp_descriptormap[fd].?.sce_descriptor, ptr, len)));
},
else => {
@panic("PIPES & SOCKETS ARE NOT IMPLEMENTED YET!");
},
}
errno = EBADF;
return -1;
errno = EBADF;
return -1;
}
pub fn write(fd: fd_t, ptr: [*]const u8, len: usize) i32 {
if (!__psp_fdman_fdValid(fd)) {
errno = EBADF;
return -1;
}
switch (__psp_descriptormap[fd].?.ftype) {
.File, .Tty => {
return pspErrToErrno(@bitCast(u32, sceIoWrite(__psp_descriptormap[fd].?.sce_descriptor, ptr, len)));
},
else => {
@panic("PIPES & SOCKETS ARE NOT IMPLEMENTED YET!");
},
}
errno = EBADF;
return -1;
}
pub fn __pspOsInit(arg: ?*c_void) void {
__psp_fdman_init();
__psp_init_cwd(arg);
}
usingnamespace @import("../include/pspthreadman.zig");
pub fn nanosleep(req: *const timespec, rem: ?*timespec) c_int {
_ = sceKernelDelayThread(@intCast(c_uint, 1000 * 1000 * req.tv_sec + @divTrunc(req.tv_nsec, 1000)));
return 0;
}
usingnamespace @import("../include/psputils.zig");
pub fn _times(t: *time_t) time_t {
return pspErrToErrno(sceKernelLibcTime(t));
}
pub fn flock(f: fd_t, op: c_int) c_int {
return 0;
}
const std = @import("std");
pub fn openat(dir: fd_t, path: [*:0]const u8, flags: u32, mode: u32) c_int {
if (dir != AT_FDCWD) {
@panic("Non-FDCWD Not Supported");
} else {
//Do stuff;
var scefd: c_int = 0;
var fd: c_int = 0;
var dest: [PATH_MAX + 1]u8 = undefined;
var stat = __psp_path_absolute(path, dest[0..], PATH_MAX);
if (stat < 0) {
errno = ENAMETOOLONG;
return -1;
}
scefd = sceIoOpen(dest[0..], @bitCast(c_int, flags), mode);
if (scefd >= 0) {
fd = __psp_fdman_get_new_descriptor();
if (fd != -1) {
__psp_descriptormap[@intCast(usize, fd)].?.sce_descriptor = scefd;
__psp_descriptormap[@intCast(usize, fd)].?.ftype = __psp_fdman_type.File;
__psp_descriptormap[@intCast(usize, fd)].?.flags = flags;
__psp_descriptormap[@intCast(usize, fd)].?.filename = dest[0..];
return fd;
} else {
_ = sceIoClose(scefd);
errno = ENOMEM;
return -1;
}
} else {
return pspErrToErrno(@bitCast(u32, scefd));
}
errno = EBADF;
return -1;
}
}
pub fn close(fd: fd_t) c_int {
var ret: c_int = 0;
if (!__psp_fdman_fdValid(fd)) {
errno = EBADF;
return -1;
}
switch (__psp_descriptormap[fd].?.ftype) {
.File, .Tty => {
if (__psp_descriptormap[fd].?.ref_count == 1) {
ret = pspErrToErrno(@bitCast(u32, sceIoClose(__psp_descriptormap[fd].?.sce_descriptor)));
}
__psp_fdman_release_descriptor(fd);
return ret;
},
else => {
@panic("PIPES & SOCKETS ARE NOT IMPLEMENTED YET!");
},
}
errno = EBADF;
return -1;
}
pub fn unlinkat(dir: fd_t, path: [*:0]const u8, flags: u32) c_int {
if (dir != AT_FDCWD) {
@panic("Non-FDCWD Not Supported");
}
var dest: [PATH_MAX + 1]u8 = undefined;
var stat = __psp_path_absolute(path, dest[0..], PATH_MAX);
if (stat < 0) {
errno = ENAMETOOLONG;
return -1;
}
var fdStat: SceIoStat = undefined;
_ = sceIoGetstat(dest[0..], &fdStat);
if (fdStat.st_mode & @enumToInt(IOAccessModes.FIO_S_IFDIR) != 0) {
return pspErrToErrno(@bitCast(u32, sceIoRmdir(dest[0..])));
} else {
return pspErrToErrno(@bitCast(u32, sceIoRemove(dest[0..])));
}
}
pub fn mkdirat(dir: fd_t, path: [*:0]const u8, mode: u32) c_int {
if (dir != AT_FDCWD) {
@panic("Non-FDCWD Not Supported");
}
var dest: [PATH_MAX + 1]u8 = undefined;
var stat = __psp_path_absolute(path, dest[0..], PATH_MAX);
if (stat < 0) {
errno = ENAMETOOLONG;
return -1;
}
return pspErrToErrno(@bitCast(u32, sceIoMkdir(dest[0..], mode)));
}
pub fn fstat(fd: fd_t, stat: *Stat) c_int {
var psp_stat: SceIoStat = undefined;
var dest: [PATH_MAX + 1]u8 = undefined;
var ret: i32 = 0;
var status = __psp_path_absolute(@ptrCast([*]const u8, &__psp_descriptormap[fd].?.filename.?), dest[0..], PATH_MAX);
if (status < 0) {
errno = ENAMETOOLONG;
return -1;
}
@memset(@ptrCast([*]u8, stat), 0, @sizeOf(Stat));
ret = sceIoGetstat(dest[0..], &psp_stat);
if (ret < 0) {
return pspErrToErrno(@bitCast(u32, ret));
}
stat.mode = @bitCast(u32, psp_stat.st_mode);
stat.st_attr = @as(u64, psp_stat.st_attr);
stat.size = @bitCast(u64, psp_stat.st_size);
stat.st_ctime = psp_stat.st_ctime;
stat.st_atime = psp_stat.st_atime;
stat.st_mtime = psp_stat.st_mtime;
stat.st_private = psp_stat.st_private;
return 0;
}
pub fn faccessat(dir: fd_t, path: [*:0]const u8, mode: u32, flags: u32) c_int {
if (dir != AT_FDCWD) {
@panic("Non-FDCWD Not Supported");
}
var dest: [PATH_MAX + 1]u8 = undefined;
var stat = __psp_path_absolute(path, dest[0..], PATH_MAX);
if (stat < 0) {
errno = ENAMETOOLONG;
return -1;
}
var fdStat: SceIoStat = undefined;
var v = sceIoGetstat(dest[0..], &fdStat);
if (v != 0) {
return pspErrToErrno(@bitCast(u32, v));
}
if (fdStat.st_mode & S_IFDIR != 0) {
return 0;
}
if (flags & W_OK == 0) {
return 0;
}
errno = EACCES;
return -1;
}
pub fn lseek(fd: fd_t, off: i64, whence: c_int) c_int {
if (!__psp_fdman_fdValid(fd)) {
errno = EBADF;
return -1;
}
switch (__psp_descriptormap[fd].?.ftype) {
.File => {
std.debug.warn("{}", .{whence});
//If you need to seek past 4GB, you have a real problem.
return pspErrToErrno(@bitCast(u32, sceIoLseek32(__psp_descriptormap[fd].?.sce_descriptor, @truncate(c_int, off), whence)));
},
else => {
errno = EBADF;
return -1;
},
}
}
pub fn isatty(fd: fd_t) c_int {
if (!__psp_fdman_fdValid(fd)) {
errno = EBADF;
return -1;
}
return @intCast(c_int, @boolToInt(__psp_fdman_fdType(fd, __psp_fdman_type.Tty)));
} | src/psp/os/system.zig |
const std = @import("std.zig");
const builtin = @import("builtin");
const math = std.math;
const print = std.debug.print;
pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
/// This should only be used in temporary test programs.
pub const allocator = allocator_instance.allocator();
pub var allocator_instance = std.heap.GeneralPurposeAllocator(.{}){};
pub const failing_allocator = failing_allocator_instance.allocator();
pub var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.allocator(), 0);
pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
/// TODO https://github.com/ziglang/zig/issues/5738
pub var log_level = std.log.Level.warn;
/// This is available to any test that wants to execute Zig in a child process.
/// It will be the same executable that is running `zig test`.
pub var zig_exe_path: []const u8 = undefined;
/// This function is intended to be used only in tests. It prints diagnostics to stderr
/// and then returns a test failure error when actual_error_union is not expected_error.
pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
if (actual_error_union) |actual_payload| {
std.debug.print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
return error.TestUnexpectedError;
} else |actual_error| {
if (expected_error != actual_error) {
std.debug.print("expected error.{s}, found error.{s}\n", .{
@errorName(expected_error),
@errorName(actual_error),
});
return error.TestExpectedError;
}
}
}
/// This function is intended to be used only in tests. When the two values are not
/// equal, prints diagnostics to stderr to show exactly how they are not equal,
/// then returns a test failure error.
/// `actual` is casted to the type of `expected`.
pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
switch (@typeInfo(@TypeOf(actual))) {
.NoReturn,
.BoundFn,
.Opaque,
.Frame,
.AnyFrame,
=> @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
.Undefined,
.Null,
.Void,
=> return,
.Type => {
if (actual != expected) {
std.debug.print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
return error.TestExpectedEqual;
}
},
.Bool,
.Int,
.Float,
.ComptimeFloat,
.ComptimeInt,
.EnumLiteral,
.Enum,
.Fn,
.ErrorSet,
=> {
if (actual != expected) {
std.debug.print("expected {}, found {}\n", .{ expected, actual });
return error.TestExpectedEqual;
}
},
.Pointer => |pointer| {
switch (pointer.size) {
.One, .Many, .C => {
if (actual != expected) {
std.debug.print("expected {*}, found {*}\n", .{ expected, actual });
return error.TestExpectedEqual;
}
},
.Slice => {
if (actual.ptr != expected.ptr) {
std.debug.print("expected slice ptr {*}, found {*}\n", .{ expected.ptr, actual.ptr });
return error.TestExpectedEqual;
}
if (actual.len != expected.len) {
std.debug.print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
return error.TestExpectedEqual;
}
},
}
},
.Array => |array| try expectEqualSlices(array.child, &expected, &actual),
.Vector => |info| {
var i: usize = 0;
while (i < info.len) : (i += 1) {
if (!std.meta.eql(expected[i], actual[i])) {
std.debug.print("index {} incorrect. expected {}, found {}\n", .{
i, expected[i], actual[i],
});
return error.TestExpectedEqual;
}
}
},
.Struct => |structType| {
inline for (structType.fields) |field| {
try expectEqual(@field(expected, field.name), @field(actual, field.name));
}
},
.Union => |union_info| {
if (union_info.tag_type == null) {
@compileError("Unable to compare untagged union values");
}
const Tag = std.meta.Tag(@TypeOf(expected));
const expectedTag = @as(Tag, expected);
const actualTag = @as(Tag, actual);
try expectEqual(expectedTag, actualTag);
// we only reach this loop if the tags are equal
inline for (std.meta.fields(@TypeOf(actual))) |fld| {
if (std.mem.eql(u8, fld.name, @tagName(actualTag))) {
try expectEqual(@field(expected, fld.name), @field(actual, fld.name));
return;
}
}
// we iterate over *all* union fields
// => we should never get here as the loop above is
// including all possible values.
unreachable;
},
.Optional => {
if (expected) |expected_payload| {
if (actual) |actual_payload| {
try expectEqual(expected_payload, actual_payload);
} else {
std.debug.print("expected {any}, found null\n", .{expected_payload});
return error.TestExpectedEqual;
}
} else {
if (actual) |actual_payload| {
std.debug.print("expected null, found {any}\n", .{actual_payload});
return error.TestExpectedEqual;
}
}
},
.ErrorUnion => {
if (expected) |expected_payload| {
if (actual) |actual_payload| {
try expectEqual(expected_payload, actual_payload);
} else |actual_err| {
std.debug.print("expected {any}, found {}\n", .{ expected_payload, actual_err });
return error.TestExpectedEqual;
}
} else |expected_err| {
if (actual) |actual_payload| {
std.debug.print("expected {}, found {any}\n", .{ expected_err, actual_payload });
return error.TestExpectedEqual;
} else |actual_err| {
try expectEqual(expected_err, actual_err);
}
}
},
}
}
test "expectEqual.union(enum)" {
const T = union(enum) {
a: i32,
b: f32,
};
const a10 = T{ .a = 10 };
try expectEqual(a10, a10);
}
/// This function is intended to be used only in tests. When the formatted result of the template
/// and its arguments does not equal the expected text, it prints diagnostics to stderr to show how
/// they are not equal, then returns an error.
pub fn expectFmt(expected: []const u8, comptime template: []const u8, args: anytype) !void {
const result = try std.fmt.allocPrint(allocator, template, args);
defer allocator.free(result);
if (std.mem.eql(u8, result, expected)) return;
print("\n====== expected this output: =========\n", .{});
print("{s}", .{expected});
print("\n======== instead found this: =========\n", .{});
print("{s}", .{result});
print("\n======================================\n", .{});
return error.TestExpectedFmt;
}
/// This function is intended to be used only in tests. When the actual value is
/// not approximately equal to the expected value, prints diagnostics to stderr
/// to show exactly how they are not equal, then returns a test failure error.
/// See `math.approxEqAbs` for more informations on the tolerance parameter.
/// The types must be floating point
pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
const T = @TypeOf(expected);
switch (@typeInfo(T)) {
.Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
std.debug.print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
return error.TestExpectedApproxEqAbs;
},
.ComptimeFloat => @compileError("Cannot approximately compare two comptime_float values"),
else => @compileError("Unable to compare non floating point values"),
}
}
test "expectApproxEqAbs" {
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
const pos_x: T = 12.0;
const pos_y: T = 12.06;
const neg_x: T = -12.0;
const neg_y: T = -12.06;
try expectApproxEqAbs(pos_x, pos_y, 0.1);
try expectApproxEqAbs(neg_x, neg_y, 0.1);
}
}
/// This function is intended to be used only in tests. When the actual value is
/// not approximately equal to the expected value, prints diagnostics to stderr
/// to show exactly how they are not equal, then returns a test failure error.
/// See `math.approxEqRel` for more informations on the tolerance parameter.
/// The types must be floating point
pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance: @TypeOf(expected)) !void {
const T = @TypeOf(expected);
switch (@typeInfo(T)) {
.Float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
std.debug.print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
return error.TestExpectedApproxEqRel;
},
.ComptimeFloat => @compileError("Cannot approximately compare two comptime_float values"),
else => @compileError("Unable to compare non floating point values"),
}
}
test "expectApproxEqRel" {
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
const eps_value = comptime math.epsilon(T);
const sqrt_eps_value = comptime math.sqrt(eps_value);
const pos_x: T = 12.0;
const pos_y: T = pos_x + 2 * eps_value;
const neg_x: T = -12.0;
const neg_y: T = neg_x - 2 * eps_value;
try expectApproxEqRel(pos_x, pos_y, sqrt_eps_value);
try expectApproxEqRel(neg_x, neg_y, sqrt_eps_value);
}
}
/// This function is intended to be used only in tests. When the two slices are not
/// equal, prints diagnostics to stderr to show exactly how they are not equal,
/// then returns a test failure error.
/// If your inputs are UTF-8 encoded strings, consider calling `expectEqualStrings` instead.
pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const T) !void {
// TODO better printing of the difference
// If the arrays are small enough we could print the whole thing
// If the child type is u8 and no weird bytes, we could print it as strings
// Even for the length difference, it would be useful to see the values of the slices probably.
if (expected.len != actual.len) {
std.debug.print("slice lengths differ. expected {d}, found {d}\n", .{ expected.len, actual.len });
return error.TestExpectedEqual;
}
var i: usize = 0;
while (i < expected.len) : (i += 1) {
if (!std.meta.eql(expected[i], actual[i])) {
std.debug.print("index {} incorrect. expected {any}, found {any}\n", .{ i, expected[i], actual[i] });
return error.TestExpectedEqual;
}
}
}
/// This function is intended to be used only in tests. Checks that two slices or two arrays are equal,
/// including that their sentinel (if any) are the same. Will error if given another type.
pub fn expectEqualSentinel(comptime T: type, comptime sentinel: T, expected: [:sentinel]const T, actual: [:sentinel]const T) !void {
try expectEqualSlices(T, expected, actual);
const expected_value_sentinel = blk: {
switch (@typeInfo(@TypeOf(expected))) {
.Pointer => {
break :blk expected[expected.len];
},
.Array => |array_info| {
const indexable_outside_of_bounds = @as([]const array_info.child, &expected);
break :blk indexable_outside_of_bounds[indexable_outside_of_bounds.len];
},
else => {},
}
};
const actual_value_sentinel = blk: {
switch (@typeInfo(@TypeOf(actual))) {
.Pointer => {
break :blk actual[actual.len];
},
.Array => |array_info| {
const indexable_outside_of_bounds = @as([]const array_info.child, &actual);
break :blk indexable_outside_of_bounds[indexable_outside_of_bounds.len];
},
else => {},
}
};
if (!std.meta.eql(sentinel, expected_value_sentinel)) {
std.debug.print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
return error.TestExpectedEqual;
}
if (!std.meta.eql(sentinel, actual_value_sentinel)) {
std.debug.print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
return error.TestExpectedEqual;
}
}
/// This function is intended to be used only in tests.
/// When `ok` is false, returns a test failure error.
pub fn expect(ok: bool) !void {
if (!ok) return error.TestUnexpectedResult;
}
pub const TmpDir = struct {
dir: std.fs.Dir,
parent_dir: std.fs.Dir,
sub_path: [sub_path_len]u8,
const random_bytes_count = 12;
const sub_path_len = std.fs.base64_encoder.calcSize(random_bytes_count);
pub fn cleanup(self: *TmpDir) void {
self.dir.close();
self.parent_dir.deleteTree(&self.sub_path) catch {};
self.parent_dir.close();
self.* = undefined;
}
};
fn getCwdOrWasiPreopen() std.fs.Dir {
if (builtin.os.tag == .wasi and !builtin.link_libc) {
var preopens = std.fs.wasi.PreopenList.init(allocator);
defer preopens.deinit();
preopens.populate() catch
@panic("unable to make tmp dir for testing: unable to populate preopens");
const preopen = preopens.find(std.fs.wasi.PreopenType{ .Dir = "." }) orelse
@panic("unable to make tmp dir for testing: didn't find '.' in the preopens");
return std.fs.Dir{ .fd = preopen.fd };
} else {
return std.fs.cwd();
}
}
pub fn tmpDir(opts: std.fs.Dir.OpenDirOptions) TmpDir {
var random_bytes: [TmpDir.random_bytes_count]u8 = undefined;
std.crypto.random.bytes(&random_bytes);
var sub_path: [TmpDir.sub_path_len]u8 = undefined;
_ = std.fs.base64_encoder.encode(&sub_path, &random_bytes);
var cwd = getCwdOrWasiPreopen();
var cache_dir = cwd.makeOpenPath("zig-cache", .{}) catch
@panic("unable to make tmp dir for testing: unable to make and open zig-cache dir");
defer cache_dir.close();
var parent_dir = cache_dir.makeOpenPath("tmp", .{}) catch
@panic("unable to make tmp dir for testing: unable to make and open zig-cache/tmp dir");
var dir = parent_dir.makeOpenPath(&sub_path, opts) catch
@panic("unable to make tmp dir for testing: unable to make and open the tmp dir");
return .{
.dir = dir,
.parent_dir = parent_dir,
.sub_path = sub_path,
};
}
test "expectEqual nested array" {
const a = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
const b = [2][2]f32{
[_]f32{ 1.0, 0.0 },
[_]f32{ 0.0, 1.0 },
};
try expectEqual(a, b);
}
test "expectEqual vector" {
var a = @splat(4, @as(u32, 4));
var b = @splat(4, @as(u32, 4));
try expectEqual(a, b);
}
pub fn expectEqualStrings(expected: []const u8, actual: []const u8) !void {
if (std.mem.indexOfDiff(u8, actual, expected)) |diff_index| {
print("\n====== expected this output: =========\n", .{});
printWithVisibleNewlines(expected);
print("\n======== instead found this: =========\n", .{});
printWithVisibleNewlines(actual);
print("\n======================================\n", .{});
var diff_line_number: usize = 1;
for (expected[0..diff_index]) |value| {
if (value == '\n') diff_line_number += 1;
}
print("First difference occurs on line {d}:\n", .{diff_line_number});
print("expected:\n", .{});
printIndicatorLine(expected, diff_index);
print("found:\n", .{});
printIndicatorLine(actual, diff_index);
return error.TestExpectedEqual;
}
}
pub fn expectStringStartsWith(actual: []const u8, expected_starts_with: []const u8) !void {
if (std.mem.startsWith(u8, actual, expected_starts_with))
return;
const shortened_actual = if (actual.len >= expected_starts_with.len)
actual[0..expected_starts_with.len]
else
actual;
print("\n====== expected to start with: =========\n", .{});
printWithVisibleNewlines(expected_starts_with);
print("\n====== instead ended with: ===========\n", .{});
printWithVisibleNewlines(shortened_actual);
print("\n========= full output: ==============\n", .{});
printWithVisibleNewlines(actual);
print("\n======================================\n", .{});
return error.TestExpectedStartsWith;
}
pub fn expectStringEndsWith(actual: []const u8, expected_ends_with: []const u8) !void {
if (std.mem.endsWith(u8, actual, expected_ends_with))
return;
const shortened_actual = if (actual.len >= expected_ends_with.len)
actual[(actual.len - expected_ends_with.len)..]
else
actual;
print("\n====== expected to end with: =========\n", .{});
printWithVisibleNewlines(expected_ends_with);
print("\n====== instead ended with: ===========\n", .{});
printWithVisibleNewlines(shortened_actual);
print("\n========= full output: ==============\n", .{});
printWithVisibleNewlines(actual);
print("\n======================================\n", .{});
return error.TestExpectedEndsWith;
}
fn printIndicatorLine(source: []const u8, indicator_index: usize) void {
const line_begin_index = if (std.mem.lastIndexOfScalar(u8, source[0..indicator_index], '\n')) |line_begin|
line_begin + 1
else
0;
const line_end_index = if (std.mem.indexOfScalar(u8, source[indicator_index..], '\n')) |line_end|
(indicator_index + line_end)
else
source.len;
printLine(source[line_begin_index..line_end_index]);
{
var i: usize = line_begin_index;
while (i < indicator_index) : (i += 1)
print(" ", .{});
}
print("^\n", .{});
}
fn printWithVisibleNewlines(source: []const u8) void {
var i: usize = 0;
while (std.mem.indexOfScalar(u8, source[i..], '\n')) |nl| : (i += nl + 1) {
printLine(source[i .. i + nl]);
}
print("{s}␃\n", .{source[i..]}); // End of Text symbol (ETX)
}
fn printLine(line: []const u8) void {
if (line.len != 0) switch (line[line.len - 1]) {
' ', '\t' => return print("{s}⏎\n", .{line}), // Carriage return symbol,
else => {},
};
print("{s}\n", .{line});
}
test {
try expectEqualStrings("foo", "foo");
}
/// Given a type, reference all the declarations inside, so that the semantic analyzer sees them.
pub fn refAllDecls(comptime T: type) void {
if (!builtin.is_test) return;
inline for (comptime std.meta.declarations(T)) |decl| {
if (decl.is_pub) _ = @field(T, decl.name);
}
} | lib/std/testing.zig |
const std = @import("std");
const hzzp = @import("hzzp");
const wz = @import("wz");
const Heartbeat = @import("Client/Heartbeat.zig");
const https = @import("https.zig");
const discord = @import("discord.zig");
const json = @import("json.zig");
const util = @import("util.zig");
const log = std.log.scoped(.zCord);
const default_agent = "zCord/0.0.1";
const Client = @This();
allocator: *std.mem.Allocator,
context: ?*c_void,
auth_token: []const u8,
user_agent: []const u8,
intents: discord.Gateway.Intents,
presence: discord.Gateway.Presence,
connect_info: ?ConnectInfo,
ssl_tunnel: ?*https.Tunnel,
wz: WzClient,
wz_buffer: [0x1000]u8,
write_mutex: std.Thread.Mutex,
heartbeat: Heartbeat,
const WzClient = wz.base.client.BaseClient(https.Tunnel.Client.Reader, https.Tunnel.Client.Writer);
pub const JsonElement = json.Stream(WzClient.PayloadReader).Element;
pub const ConnectInfo = struct {
heartbeat_interval_ms: u64,
seq: u32,
user_id: discord.Snowflake(.user),
session_id: util.Fixbuf(0x100),
};
pub fn create(args: struct {
allocator: *std.mem.Allocator,
auth_token: []const u8,
user_agent: []const u8 = default_agent,
context: ?*c_void = null,
intents: discord.Gateway.Intents = .{},
presence: discord.Gateway.Presence = .{},
heartbeat: Heartbeat.Strategy = Heartbeat.Strategy.default,
}) !*Client {
const result = try args.allocator.create(Client);
errdefer args.allocator.destroy(result);
result.allocator = args.allocator;
result.context = args.context;
result.auth_token = args.auth_token;
result.user_agent = args.user_agent;
result.intents = args.intents;
result.presence = args.presence;
result.connect_info = null;
result.ssl_tunnel = null;
result.write_mutex = .{};
result.heartbeat = try Heartbeat.init(result, args.heartbeat);
errdefer result.heartbeat.deinit();
return result;
}
pub fn destroy(self: *Client) void {
if (self.ssl_tunnel) |ssl_tunnel| {
ssl_tunnel.destroy();
}
self.heartbeat.deinit();
self.allocator.destroy(self);
}
pub fn ctx(self: *Client, comptime T: type) *T {
return @ptrCast(*T, @alignCast(@alignOf(T), self.context.?));
}
fn fetchGatewayHost(self: *Client, buffer: []u8) ![]const u8 {
var req = try self.sendRequest(self.allocator, .GET, "/api/v8/gateway/bot", null);
defer req.deinit();
switch (req.response_code.?) {
.success_ok => {},
.client_unauthorized => return error.AuthenticationFailed,
else => {
log.warn("Unknown response code: {}", .{req.response_code.?});
return error.UnknownGatewayResponse;
},
}
try req.completeHeaders();
var stream = json.stream(req.client.reader());
const root = try stream.root();
const match = (try root.objectMatchOne("url")) orelse return error.UnknownGatewayResponse;
const url = try match.value.stringBuffer(buffer);
if (std.mem.startsWith(u8, url, "wss://")) {
return url["wss://".len..];
} else {
log.warn("Unknown url: {s}", .{url});
return error.UnknownGatewayResponse;
}
}
fn connect(self: *Client) !ConnectInfo {
std.debug.assert(self.ssl_tunnel == null);
var buf: [0x100]u8 = undefined;
const host = try self.fetchGatewayHost(&buf);
self.ssl_tunnel = try https.Tunnel.create(.{
.allocator = self.allocator,
.host = host,
});
errdefer self.disconnect();
self.wz = wz.base.client.create(
&self.wz_buffer,
self.ssl_tunnel.?.client.reader(),
self.ssl_tunnel.?.client.writer(),
);
// Handshake
try self.wz.handshakeStart("/?v=6&encoding=json");
try self.wz.handshakeAddHeaderValue("Host", "gateway.discord.gg");
try self.wz.handshakeFinish();
if (try self.wz.next()) |event| {
std.debug.assert(event == .header);
}
var result: ConnectInfo = undefined;
var flush_error: WzClient.ReadNextError!void = {};
{
var stream = json.stream(self.wz.reader());
defer self.wz.flushReader() catch |err| {
flush_error = err;
};
errdefer |err| log.info("{}", .{stream.debugInfo()});
const root = try stream.root();
const paths = try json.path.match(null, root, struct {
@"op": u8,
@"d.heartbeat_interval": u32,
});
if (paths.@"op" != @enumToInt(discord.Gateway.Opcode.hello)) {
return error.MalformedHelloResponse;
}
result.heartbeat_interval_ms = paths.@"d.heartbeat_interval";
}
try flush_error;
if (result.heartbeat_interval_ms == 0) {
return error.MalformedHelloResponse;
}
if (self.connect_info) |old_info| {
try self.sendCommand(.{ .@"resume" = .{
.token = self.auth_token,
.seq = old_info.seq,
.session_id = old_info.session_id.slice(),
} });
result.seq = old_info.seq;
result.user_id = old_info.user_id;
result.session_id = old_info.session_id;
return result;
}
try self.sendCommand(.{ .identify = .{
.compress = false,
.intents = self.intents,
.token = self.auth_token,
.properties = .{
.@"$os" = @tagName(std.Target.current.os.tag),
.@"$browser" = self.user_agent,
.@"$device" = self.user_agent,
},
.presence = self.presence,
} });
if (try self.wz.next()) |event| {
if (event.header.opcode == .Close) {
try self.processCloseEvent();
}
}
{
var stream = json.stream(self.wz.reader());
defer self.wz.flushReader() catch |err| {
flush_error = err;
};
errdefer |err| log.info("{}", .{stream.debugInfo()});
const root = try stream.root();
const paths = try json.path.match(null, root, struct {
@"t": util.Fixbuf(0x100),
@"s": ?u32,
@"op": u8,
@"d.session_id": util.Fixbuf(0x100),
@"d.user.id": discord.Snowflake(.user),
});
if (!std.mem.eql(u8, paths.@"t".slice(), "READY")) {
return error.MalformedIdentify;
}
if (paths.@"op" != @enumToInt(discord.Gateway.Opcode.dispatch)) {
return error.MalformedIdentify;
}
if (paths.@"s") |seq| {
result.seq = seq;
}
result.user_id = paths.@"d.user.id";
result.session_id = paths.@"d.session_id";
}
try flush_error;
return result;
}
fn disconnect(self: *Client) void {
if (self.ssl_tunnel) |ssl_tunnel| {
ssl_tunnel.destroy();
self.ssl_tunnel = null;
}
}
pub fn ws(self: *Client, handler: anytype) !void {
var reconnect_wait: u64 = 1;
while (true) {
self.connect_info = self.connect() catch |err| switch (err) {
error.AuthenticationFailed,
error.DisallowedIntents,
error.CertificateVerificationFailed,
=> |e| return e,
else => {
log.info("Connect error: {s}", .{@errorName(err)});
std.time.sleep(reconnect_wait * std.time.ns_per_s);
reconnect_wait = std.math.min(reconnect_wait * 2, 30);
continue;
},
};
defer self.disconnect();
if (@hasDecl(handler, "handleConnect")) {
handler.handleConnect(self, self.connect_info.?);
}
reconnect_wait = 1;
self.heartbeat.send(.start);
defer self.heartbeat.send(.stop);
self.listen(handler) catch |err| switch (err) {
error.ConnectionReset => continue,
error.InvalidSession => {
self.connect_info = null;
continue;
},
else => |e| {
// TODO: convert this to inline switch once available
if (!util.errSetContains(WzClient.ReadNextError, e)) {
return e;
}
},
};
}
}
fn processCloseEvent(self: *Client) !void {
const event = (try self.wz.next()).?;
const code_num = std.mem.readIntBig(u16, event.chunk.data[0..2]);
const code = @intToEnum(discord.Gateway.CloseEventCode, code_num);
switch (code) {
_ => {
log.info("Websocket close frame - {d}: unknown code. Reconnecting...", .{code_num});
return error.ConnectionReset;
},
.NormalClosure,
.GoingAway,
.ProtocolError,
.NoStatusReceived,
.AbnormalClosure,
.PolicyViolation,
.InternalError,
.ServiceRestart,
.TryAgainLater,
.BadGateway,
.UnknownError,
.SessionTimedOut,
=> {
log.info("Websocket close frame - {d}: {s}. Reconnecting...", .{ @enumToInt(code), @tagName(code) });
return error.ConnectionReset;
},
// Most likely user error
.UnsupportedData => return error.UnsupportedData,
.InvalidFramePayloadData => return error.InvalidFramePayloadData,
.MessageTooBig => return error.MessageTooBig,
.AuthenticationFailed => return error.AuthenticationFailed,
.AlreadyAuthenticated => return error.AlreadyAuthenticated,
.DecodeError => return error.DecodeError,
.UnknownOpcode => return error.UnknownOpcode,
.RateLimited => return error.WoahNelly,
.DisallowedIntents => return error.DisallowedIntents,
// We don't support these yet
.InvalidSeq => unreachable,
.InvalidShard => unreachable,
.ShardingRequired => unreachable,
.InvalidApiVersion => unreachable,
// This library fucked up
.MissingExtension => unreachable,
.TlsHandshake => unreachable,
.NotAuthenticated => unreachable,
.InvalidIntents => unreachable,
}
}
fn listen(self: *Client, handler: anytype) !void {
while (try self.wz.next()) |event| {
switch (event.header.opcode) {
.Text => {
self.processChunks(self.wz.reader(), handler) catch |err| switch (err) {
error.ConnectionReset, error.InvalidSession => |e| return e,
else => {
log.warn("Process chunks failed: {s}", .{err});
},
};
try self.wz.flushReader();
},
.Ping, .Pong => {},
.Close => try self.processCloseEvent(),
.Binary => return error.WtfBinary,
else => return error.WtfWtf,
}
}
log.info("Websocket close frame - {{}}: no reason provided. Reconnecting...", .{});
return error.ConnectionReset;
}
fn processChunks(self: *Client, reader: anytype, handler: anytype) !void {
var stream = json.stream(reader);
errdefer |err| {
if (util.errSetContains(@TypeOf(stream).ParseError, err)) {
log.warn("{}", .{stream.debugInfo()});
}
}
var name_buf: [32]u8 = undefined;
var name: ?[]u8 = null;
var op: ?discord.Gateway.Opcode = null;
const root = try stream.root();
while (try root.objectMatch(enum { t, s, op, d })) |match| switch (match) {
.t => |el_type| {
name = try el_type.optionalStringBuffer(&name_buf);
},
.s => |el_seq| {
if (try el_seq.optionalNumber(u32)) |seq| {
self.connect_info.?.seq = seq;
}
},
.op => |el_op| {
op = try std.meta.intToEnum(discord.Gateway.Opcode, try el_op.number(u8));
},
.d => |el_data| {
switch (op orelse return error.DataBeforeOp) {
.dispatch => {
log.info("<< {d} -- {s}", .{ self.connect_info.?.seq, name });
try handler.handleDispatch(
self,
name orelse return error.DispatchWithoutName,
el_data,
);
},
.heartbeat_ack => self.heartbeat.send(.ack),
.invalid_session => {
log.info("Websocket invalid session. Reconnecting...", .{});
const resumable = el_data.boolean() catch false;
if (resumable) {
return error.ConnectionReset;
} else {
return error.InvalidSession;
}
},
else => {},
}
_ = try el_data.finalizeToken();
},
};
}
pub fn sendCommand(self: *Client, command: discord.Gateway.Command) !void {
const ssl_tunnel = self.ssl_tunnel orelse return error.NotConnected;
var buf: [0x1000]u8 = undefined;
const msg = try std.fmt.bufPrint(&buf, "{s}", .{json.format(command)});
const held = self.write_mutex.acquire();
defer held.release();
try self.wz.writeHeader(.{ .opcode = .Text, .length = msg.len });
try self.wz.writeChunk(msg);
}
pub fn sendRequest(self: *Client, allocator: *std.mem.Allocator, method: https.Request.Method, path: []const u8, body: anytype) !https.Request {
var req = try https.Request.init(.{
.allocator = allocator,
.host = "discord.com",
.method = method,
.path = path,
.user_agent = self.user_agent,
});
errdefer req.deinit();
try req.client.writeHeaderValue("Accept", "application/json");
try req.client.writeHeaderValue("Content-Type", "application/json");
try req.client.writeHeaderValue("Authorization", self.auth_token);
switch (@typeInfo(@TypeOf(body))) {
.Null => _ = try req.sendEmptyBody(),
.Optional => {
if (body == null) {
_ = try req.sendEmptyBody();
} else {
_ = try req.sendPrint("{}", .{json.format(body)});
}
},
else => _ = try req.sendPrint("{}", .{json.format(body)}),
}
return req;
}
test {
std.testing.refAllDecls(@This());
} | src/Client.zig |
const std = @import("std");
const err = std.log.err;
const debug = std.log.debug;
const machine = @import("machine.zig");
const sdl = @import("sdl.zig");
// Fonts taken from https://tobiasvl.github.io/blog/write-a-chip-8-emulator/
const Fonts = [_]u8{
0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
0x20, 0x60, 0x20, 0x20, 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
};
pub const log_level: std.log.Level = .info;
pub fn main() !void {
var mem: [machine.MEM_SIZE]u8 = std.mem.zeroes([machine.MEM_SIZE]u8);
std.mem.copy(u8, mem[0..80], Fonts[0..80]);
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
var allocator = arena.allocator();
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
if (args.len != 2) {
err("Usage: {s} ROM_FILE", .{args[0]});
return;
}
const rom = args[1];
var file = try std.fs.cwd().openFile(rom, .{});
defer file.close();
const len = try file.readAll(mem[0x200..]);
debug("Read ROM with {} bytes", .{len});
var gui = try sdl.Sdl.init();
var chip8 = machine.Machine.init();
while (true) {
if (chip8.cpu_state == .Running) {
debug("Executing instruction", .{});
const cost = chip8.fetchAndExec(&mem) catch break;
std.time.sleep(cost * 1000);
} else {
// Take a nap for 16ms
std.time.sleep(16 * 1000 * 1000);
}
gui.updateScreen(chip8.getScreen());
if (chip8.updateTimers()) {
gui.playBeep();
}
while (true) {
var event = gui.getEvent();
switch (event.kind) {
.None => break,
.Quit => return,
.KeyUp => chip8.updateKey(@intCast(u8, event.data), false),
.KeyDown => chip8.updateKey(@intCast(u8, event.data), true),
}
}
chip8.dumpState();
}
} | src/main.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const builtin = @import("builtin");
const glfw = @import("glfw");
const gpu = @import("gpu");
const platform = @import("platform.zig");
const structs = @import("structs.zig");
const enums = @import("enums.zig");
const Timer = @import("Timer.zig");
const Engine = @This();
allocator: Allocator,
options: structs.Options,
/// The amount of time (in seconds) that has passed since the last frame was rendered.
///
/// For example, if you are animating a cube which should rotate 360 degrees every second,
/// instead of writing (360.0 / 60.0) and assuming the frame rate is 60hz, write
/// (360.0 * engine.delta_time)
delta_time: f32 = 0,
delta_time_ns: u64 = 0,
timer: Timer,
device: gpu.Device,
backend_type: gpu.Adapter.BackendType,
swap_chain: ?gpu.SwapChain,
swap_chain_format: gpu.Texture.Format,
surface: ?gpu.Surface,
current_desc: gpu.SwapChain.Descriptor,
target_desc: gpu.SwapChain.Descriptor,
internal: platform.Type,
pub fn init(allocator: std.mem.Allocator) !Engine {
var engine: Engine = undefined;
engine.allocator = allocator;
engine.options = structs.Options{};
engine.timer = try Timer.start();
engine.internal = try platform.Type.init(allocator, &engine);
return engine;
}
/// Set runtime options for application, like title, window size etc.
///
/// See mach.Options for details
pub fn setOptions(engine: *Engine, options: structs.Options) !void {
try engine.internal.setOptions(options);
engine.options = options;
}
pub fn setShouldClose(engine: *Engine, value: bool) void {
engine.internal.setShouldClose(value);
}
// Returns the framebuffer size, in subpixel units.
//
// e.g. returns 1280x960 on macOS for a window that is 640x480
pub fn getFramebufferSize(engine: *Engine) structs.Size {
return engine.internal.getFramebufferSize();
}
// Returns the widow size, in pixel units.
//
// e.g. returns 1280x960 on macOS for a window that is 640x480
pub fn getWindowSize(engine: *Engine) structs.Size {
return engine.internal.getWindowSize();
}
pub fn pollEvent(engine: *Engine) ?structs.Event {
return engine.internal.pollEvent();
} | src/Engine.zig |
const std = @import("std");
const gpa = std.heap.c_allocator;
const zfetch = @import("zfetch");
const json = @import("json");
const range = @import("range").range;
const u = @import("./../../util/index.zig");
const zpm = @import("./../zpm.zig");
//
//
pub fn execute(args: [][]u8) !void {
_ = args;
const out = std.io.getStdOut().writer();
const url = try std.mem.join(gpa, "/", &.{ zpm.server_root, "packages" });
const val = try zpm.server_fetch(url);
const arr = &std.ArrayList(zpm.Package).init(gpa);
defer arr.deinit();
for (val.Array) |item| {
if (item.get("root_file")) |_| {} else {
continue;
}
try arr.append(zpm.Package{
.name = item.get("name").?.String,
.author = item.get("author").?.String,
.description = item.get("description").?.String,
.tags = &.{},
.git = "",
.root_file = "",
});
}
const list = arr.items;
const name_col_width = blk: {
var w: usize = 4;
for (list) |pkg| {
const len = pkg.name.len;
if (len > w) {
w = len;
}
}
break :blk w + 2;
};
const author_col_width = blk: {
var w: usize = 6;
for (list) |pkg| {
const len = pkg.author.len;
if (len > w) {
w = len;
}
}
break :blk w + 2;
};
try out.writeAll("NAME");
try print_c_n(out, ' ', name_col_width - 4);
try out.writeAll("AUTHOR");
try print_c_n(out, ' ', author_col_width - 6);
try out.writeAll("DESCRIPTION\n");
for (list) |pkg| {
try out.writeAll(pkg.name);
try print_c_n(out, ' ', name_col_width - pkg.name.len);
try out.writeAll(pkg.author);
try print_c_n(out, ' ', author_col_width - pkg.author.len);
try out.writeAll(pkg.description);
try out.writeAll("\n");
}
}
fn print_c_n(out: anytype, c: u8, n: usize) !void {
for (range(n)) |_| {
try out.writeAll(&.{c});
}
} | src/cmd/zpm/search.zig |
pub const MCAST_CLIENT_ID_LEN = @as(u32, 17);
pub const MCAST_API_CURRENT_VERSION = @as(i32, 1);
pub const MCAST_API_VERSION_0 = @as(i32, 0);
pub const MCAST_API_VERSION_1 = @as(i32, 1);
//--------------------------------------------------------------------------------
// Section: Types (6)
//--------------------------------------------------------------------------------
pub const IPNG_ADDRESS = extern union {
IpAddrV4: u32,
IpAddrV6: [16]u8,
};
pub const MCAST_CLIENT_UID = extern struct {
ClientUID: ?*u8,
ClientUIDLength: u32,
};
pub const MCAST_SCOPE_CTX = extern struct {
ScopeID: IPNG_ADDRESS,
Interface: IPNG_ADDRESS,
ServerID: IPNG_ADDRESS,
};
pub const MCAST_SCOPE_ENTRY = extern struct {
ScopeCtx: MCAST_SCOPE_CTX,
LastAddr: IPNG_ADDRESS,
TTL: u32,
ScopeDesc: UNICODE_STRING,
};
pub const MCAST_LEASE_REQUEST = extern struct {
LeaseStartTime: i32,
MaxLeaseStartTime: i32,
LeaseDuration: u32,
MinLeaseDuration: u32,
ServerAddress: IPNG_ADDRESS,
MinAddrCount: u16,
AddrCount: u16,
pAddrBuf: ?*u8,
};
pub const MCAST_LEASE_RESPONSE = extern struct {
LeaseStartTime: i32,
LeaseEndTime: i32,
ServerAddress: IPNG_ADDRESS,
AddrCount: u16,
pAddrBuf: ?*u8,
};
//--------------------------------------------------------------------------------
// Section: Functions (7)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastApiStartup(
Version: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastApiCleanup(
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastGenUID(
pRequestID: ?*MCAST_CLIENT_UID,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastEnumerateScopes(
AddrFamily: u16,
ReQuery: BOOL,
pScopeList: ?*MCAST_SCOPE_ENTRY,
pScopeLen: ?*u32,
pScopeCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastRequestAddress(
AddrFamily: u16,
pRequestID: ?*MCAST_CLIENT_UID,
pScopeCtx: ?*MCAST_SCOPE_CTX,
pAddrRequest: ?*MCAST_LEASE_REQUEST,
pAddrResponse: ?*MCAST_LEASE_RESPONSE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastRenewAddress(
AddrFamily: u16,
pRequestID: ?*MCAST_CLIENT_UID,
pRenewRequest: ?*MCAST_LEASE_REQUEST,
pRenewResponse: ?*MCAST_LEASE_RESPONSE,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.0'
pub extern "dhcpcsvc" fn McastReleaseAddress(
AddrFamily: u16,
pRequestID: ?*MCAST_CLIENT_UID,
pReleaseRequest: ?*MCAST_LEASE_REQUEST,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// 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 (2)
//--------------------------------------------------------------------------------
const BOOL = @import("../foundation.zig").BOOL;
const UNICODE_STRING = @import("../foundation.zig").UNICODE_STRING;
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/network_management/multicast.zig |
pub const D2D1_DEFAULT_FLATTENING_TOLERANCE = @as(f32, 2.5e-01);
pub const CLSID_D2D12DAffineTransform = Guid.initString("6aa97485-6354-4cfc-908c-e4a74f62c96c");
pub const CLSID_D2D13DPerspectiveTransform = Guid.initString("c2844d0b-3d86-46e7-85ba-526c9240f3fb");
pub const CLSID_D2D13DTransform = Guid.initString("e8467b04-ec61-4b8a-b5de-d4d73debea5a");
pub const CLSID_D2D1ArithmeticComposite = Guid.initString("fc151437-049a-4784-a24a-f1c4daf20987");
pub const CLSID_D2D1Atlas = Guid.initString("913e2be4-fdcf-4fe2-a5f0-2454f14ff408");
pub const CLSID_D2D1BitmapSource = Guid.initString("5fb6c24d-c6dd-4231-9404-50f4d5c3252d");
pub const CLSID_D2D1Blend = Guid.initString("81c5b77b-13f8-4cdd-ad20-c890547ac65d");
pub const CLSID_D2D1Border = Guid.initString("2a2d49c0-4acf-43c7-8c6a-7c4a27874d27");
pub const CLSID_D2D1Brightness = Guid.initString("8cea8d1e-77b0-4986-b3b9-2f0c0eae7887");
pub const CLSID_D2D1ColorManagement = Guid.initString("1a28524c-fdd6-4aa4-ae8f-837eb8267b37");
pub const CLSID_D2D1ColorMatrix = Guid.initString("921f03d6-641c-47df-852d-b4bb6153ae11");
pub const CLSID_D2D1Composite = Guid.initString("48fc9f51-f6ac-48f1-8b58-3b28ac46f76d");
pub const CLSID_D2D1ConvolveMatrix = Guid.initString("407f8c08-5533-4331-a341-23cc3877843e");
pub const CLSID_D2D1Crop = Guid.initString("e23f7110-0e9a-4324-af47-6a2c0c46f35b");
pub const CLSID_D2D1DirectionalBlur = Guid.initString("174319a6-58e9-49b2-bb63-caf2c811a3db");
pub const CLSID_D2D1DiscreteTransfer = Guid.initString("90866fcd-488e-454b-af06-e5041b66c36c");
pub const CLSID_D2D1DisplacementMap = Guid.initString("edc48364-0417-4111-9450-43845fa9f890");
pub const CLSID_D2D1DistantDiffuse = Guid.initString("3e7efd62-a32d-46d4-a83c-5278889ac954");
pub const CLSID_D2D1DistantSpecular = Guid.initString("428c1ee5-77b8-4450-8ab5-72219c21abda");
pub const CLSID_D2D1DpiCompensation = Guid.initString("6c26c5c7-34e0-46fc-9cfd-e5823706e228");
pub const CLSID_D2D1Flood = Guid.initString("61c23c20-ae69-4d8e-94cf-50078df638f2");
pub const CLSID_D2D1GammaTransfer = Guid.initString("409444c4-c419-41a0-b0c1-8cd0c0a18e42");
pub const CLSID_D2D1GaussianBlur = Guid.initString("1feb6d69-2fe6-4ac9-8c58-1d7f93e7a6a5");
pub const CLSID_D2D1Scale = Guid.initString("9daf9369-3846-4d0e-a44e-0c607934a5d7");
pub const CLSID_D2D1Histogram = Guid.initString("881db7d0-f7ee-4d4d-a6d2-4697acc66ee8");
pub const CLSID_D2D1HueRotation = Guid.initString("0f4458ec-4b32-491b-9e85-bd73f44d3eb6");
pub const CLSID_D2D1LinearTransfer = Guid.initString("ad47c8fd-63ef-4acc-9b51-67979c036c06");
pub const CLSID_D2D1LuminanceToAlpha = Guid.initString("41251ab7-0beb-46f8-9da7-59e93fcce5de");
pub const CLSID_D2D1Morphology = Guid.initString("eae6c40d-626a-4c2d-bfcb-391001abe202");
pub const CLSID_D2D1OpacityMetadata = Guid.initString("6c53006a-4450-4199-aa5b-ad1656fece5e");
pub const CLSID_D2D1PointDiffuse = Guid.initString("b9e303c3-c08c-4f91-8b7b-38656bc48c20");
pub const CLSID_D2D1PointSpecular = Guid.initString("09c3ca26-3ae2-4f09-9ebc-ed3865d53f22");
pub const CLSID_D2D1Premultiply = Guid.initString("06eab419-deed-4018-80d2-3e1d471adeb2");
pub const CLSID_D2D1Saturation = Guid.initString("5cb2d9cf-327d-459f-a0ce-40c0b2086bf7");
pub const CLSID_D2D1Shadow = Guid.initString("c67ea361-1863-4e69-89db-695d3e9a5b6b");
pub const CLSID_D2D1SpotDiffuse = Guid.initString("818a1105-7932-44f4-aa86-08ae7b2f2c93");
pub const CLSID_D2D1SpotSpecular = Guid.initString("edae421e-7654-4a37-9db8-71acc1beb3c1");
pub const CLSID_D2D1TableTransfer = Guid.initString("5bf818c3-5e43-48cb-b631-868396d6a1d4");
pub const CLSID_D2D1Tile = Guid.initString("b0784138-3b76-4bc5-b13b-0fa2ad02659f");
pub const CLSID_D2D1Turbulence = Guid.initString("cf2bb6ae-889a-4ad7-ba29-a2fd732c9fc9");
pub const CLSID_D2D1UnPremultiply = Guid.initString("fb9ac489-ad8d-41ed-9999-bb6347d110f7");
pub const CLSID_D2D1YCbCr = Guid.initString("99503cc1-66c7-45c9-a875-8ad8a7914401");
pub const CLSID_D2D1Contrast = Guid.initString("b648a78a-0ed5-4f80-a94a-8e825aca6b77");
pub const CLSID_D2D1RgbToHue = Guid.initString("23f3e5ec-91e8-4d3d-ad0a-afadc1004aa1");
pub const CLSID_D2D1HueToRgb = Guid.initString("7b78a6bd-0141-4def-8a52-6356ee0cbdd5");
pub const CLSID_D2D1ChromaKey = Guid.initString("74c01f5b-2a0d-408c-88e2-c7a3c7197742");
pub const CLSID_D2D1Emboss = Guid.initString("b1c5eb2b-0348-43f0-8107-4957cacba2ae");
pub const CLSID_D2D1Exposure = Guid.initString("b56c8cfa-f634-41ee-bee0-ffa617106004");
pub const CLSID_D2D1Grayscale = Guid.initString("36dde0eb-3725-42e0-836d-52fb20aee644");
pub const CLSID_D2D1Invert = Guid.initString("e0c3784d-cb39-4e84-b6fd-6b72f0810263");
pub const CLSID_D2D1Posterize = Guid.initString("2188945e-33a3-4366-b7bc-086bd02d0884");
pub const CLSID_D2D1Sepia = Guid.initString("3a1af410-5f1d-4dbe-84df-915da79b7153");
pub const CLSID_D2D1Sharpen = Guid.initString("c9b887cb-c5ff-4dc5-9779-273dcf417c7d");
pub const CLSID_D2D1Straighten = Guid.initString("4da47b12-79a3-4fb0-8237-bbc3b2a4de08");
pub const CLSID_D2D1TemperatureTint = Guid.initString("89176087-8af9-4a08-aeb1-895f38db1766");
pub const CLSID_D2D1Vignette = Guid.initString("c00c40be-5e67-4ca3-95b4-f4b02c115135");
pub const CLSID_D2D1EdgeDetection = Guid.initString("eff583ca-cb07-4aa9-ac5d-2cc44c76460f");
pub const CLSID_D2D1HighlightsShadows = Guid.initString("cadc8384-323f-4c7e-a361-2e2b24df6ee4");
pub const CLSID_D2D1LookupTable3D = Guid.initString("349e0eda-0088-4a79-9ca3-c7e300202020");
pub const CLSID_D2D1Opacity = Guid.initString("811d79a4-de28-4454-8094-c64685f8bd4c");
pub const CLSID_D2D1AlphaMask = Guid.initString("c80ecff0-3fd5-4f05-8328-c5d1724b4f0a");
pub const CLSID_D2D1CrossFade = Guid.initString("12f575e8-4db1-485f-9a84-03a07dd3829f");
pub const CLSID_D2D1Tint = Guid.initString("36312b17-f7dd-4014-915d-ffca768cf211");
pub const D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL = @as(f32, 80);
pub const CLSID_D2D1WhiteLevelAdjustment = Guid.initString("44a1cadb-6cdd-4818-8ff4-26c1cfe95bdb");
pub const CLSID_D2D1HdrToneMap = Guid.initString("7b0b748d-4610-4486-a90c-999d9a2e2b11");
pub const D2D1_APPEND_ALIGNED_ELEMENT = @as(u32, 4294967295);
pub const FACILITY_D2D = @as(u32, 2201);
//--------------------------------------------------------------------------------
// Section: Types (330)
//--------------------------------------------------------------------------------
pub const D2D1_INTERPOLATION_MODE_DEFINITION = enum(i32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FANT = 6,
MIPMAP_LINEAR = 7,
};
pub const D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION.NEAREST_NEIGHBOR;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION.LINEAR;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION.CUBIC;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION.MULTI_SAMPLE_LINEAR;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC = D2D1_INTERPOLATION_MODE_DEFINITION.ANISOTROPIC;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION.HIGH_QUALITY_CUBIC;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_FANT = D2D1_INTERPOLATION_MODE_DEFINITION.FANT;
pub const D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION.MIPMAP_LINEAR;
pub const D2D1_GAMMA = enum(u32) {
@"2_2" = 0,
@"1_0" = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GAMMA_2_2 = D2D1_GAMMA.@"2_2";
pub const D2D1_GAMMA_1_0 = D2D1_GAMMA.@"1_0";
pub const D2D1_GAMMA_FORCE_DWORD = D2D1_GAMMA.FORCE_DWORD;
pub const D2D1_OPACITY_MASK_CONTENT = enum(u32) {
GRAPHICS = 0,
TEXT_NATURAL = 1,
TEXT_GDI_COMPATIBLE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_OPACITY_MASK_CONTENT_GRAPHICS = D2D1_OPACITY_MASK_CONTENT.GRAPHICS;
pub const D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = D2D1_OPACITY_MASK_CONTENT.TEXT_NATURAL;
pub const D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = D2D1_OPACITY_MASK_CONTENT.TEXT_GDI_COMPATIBLE;
pub const D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD = D2D1_OPACITY_MASK_CONTENT.FORCE_DWORD;
pub const D2D1_EXTEND_MODE = enum(u32) {
CLAMP = 0,
WRAP = 1,
MIRROR = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_EXTEND_MODE_CLAMP = D2D1_EXTEND_MODE.CLAMP;
pub const D2D1_EXTEND_MODE_WRAP = D2D1_EXTEND_MODE.WRAP;
pub const D2D1_EXTEND_MODE_MIRROR = D2D1_EXTEND_MODE.MIRROR;
pub const D2D1_EXTEND_MODE_FORCE_DWORD = D2D1_EXTEND_MODE.FORCE_DWORD;
pub const D2D1_ANTIALIAS_MODE = enum(u32) {
PER_PRIMITIVE = 0,
ALIASED = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = D2D1_ANTIALIAS_MODE.PER_PRIMITIVE;
pub const D2D1_ANTIALIAS_MODE_ALIASED = D2D1_ANTIALIAS_MODE.ALIASED;
pub const D2D1_ANTIALIAS_MODE_FORCE_DWORD = D2D1_ANTIALIAS_MODE.FORCE_DWORD;
pub const D2D1_TEXT_ANTIALIAS_MODE = enum(u32) {
DEFAULT = 0,
CLEARTYPE = 1,
GRAYSCALE = 2,
ALIASED = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = D2D1_TEXT_ANTIALIAS_MODE.DEFAULT;
pub const D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = D2D1_TEXT_ANTIALIAS_MODE.CLEARTYPE;
pub const D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = D2D1_TEXT_ANTIALIAS_MODE.GRAYSCALE;
pub const D2D1_TEXT_ANTIALIAS_MODE_ALIASED = D2D1_TEXT_ANTIALIAS_MODE.ALIASED;
pub const D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD = D2D1_TEXT_ANTIALIAS_MODE.FORCE_DWORD;
pub const D2D1_BITMAP_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_BITMAP_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = D2D1_BITMAP_INTERPOLATION_MODE.LINEAR;
pub const D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD = D2D1_BITMAP_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_DRAW_TEXT_OPTIONS = enum(u32) {
NO_SNAP = 1,
CLIP = 2,
ENABLE_COLOR_FONT = 4,
DISABLE_COLOR_BITMAP_SNAPPING = 8,
NONE = 0,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NO_SNAP: u1 = 0,
CLIP: u1 = 0,
ENABLE_COLOR_FONT: u1 = 0,
DISABLE_COLOR_BITMAP_SNAPPING: u1 = 0,
NONE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_DRAW_TEXT_OPTIONS {
return @intToEnum(D2D1_DRAW_TEXT_OPTIONS,
(if (o.NO_SNAP == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.NO_SNAP) else 0)
| (if (o.CLIP == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.CLIP) else 0)
| (if (o.ENABLE_COLOR_FONT == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.ENABLE_COLOR_FONT) else 0)
| (if (o.DISABLE_COLOR_BITMAP_SNAPPING == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.DISABLE_COLOR_BITMAP_SNAPPING) else 0)
| (if (o.NONE == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.NONE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_DRAW_TEXT_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = D2D1_DRAW_TEXT_OPTIONS.NO_SNAP;
pub const D2D1_DRAW_TEXT_OPTIONS_CLIP = D2D1_DRAW_TEXT_OPTIONS.CLIP;
pub const D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT = D2D1_DRAW_TEXT_OPTIONS.ENABLE_COLOR_FONT;
pub const D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING = D2D1_DRAW_TEXT_OPTIONS.DISABLE_COLOR_BITMAP_SNAPPING;
pub const D2D1_DRAW_TEXT_OPTIONS_NONE = D2D1_DRAW_TEXT_OPTIONS.NONE;
pub const D2D1_DRAW_TEXT_OPTIONS_FORCE_DWORD = D2D1_DRAW_TEXT_OPTIONS.FORCE_DWORD;
pub const D2D1_BITMAP_PROPERTIES = extern struct {
pixelFormat: D2D1_PIXEL_FORMAT,
dpiX: f32,
dpiY: f32,
};
pub const D2D1_GRADIENT_STOP = extern struct {
position: f32,
color: D2D1_COLOR_F,
};
pub const D2D1_BRUSH_PROPERTIES = extern struct {
opacity: f32,
transform: D2D_MATRIX_3X2_F,
};
pub const D2D1_BITMAP_BRUSH_PROPERTIES = extern struct {
extendModeX: D2D1_EXTEND_MODE,
extendModeY: D2D1_EXTEND_MODE,
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
};
pub const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES = extern struct {
startPoint: D2D_POINT_2F,
endPoint: D2D_POINT_2F,
};
pub const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES = extern struct {
center: D2D_POINT_2F,
gradientOriginOffset: D2D_POINT_2F,
radiusX: f32,
radiusY: f32,
};
pub const D2D1_ARC_SIZE = enum(u32) {
SMALL = 0,
LARGE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_ARC_SIZE_SMALL = D2D1_ARC_SIZE.SMALL;
pub const D2D1_ARC_SIZE_LARGE = D2D1_ARC_SIZE.LARGE;
pub const D2D1_ARC_SIZE_FORCE_DWORD = D2D1_ARC_SIZE.FORCE_DWORD;
pub const D2D1_CAP_STYLE = enum(u32) {
FLAT = 0,
SQUARE = 1,
ROUND = 2,
TRIANGLE = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CAP_STYLE_FLAT = D2D1_CAP_STYLE.FLAT;
pub const D2D1_CAP_STYLE_SQUARE = D2D1_CAP_STYLE.SQUARE;
pub const D2D1_CAP_STYLE_ROUND = D2D1_CAP_STYLE.ROUND;
pub const D2D1_CAP_STYLE_TRIANGLE = D2D1_CAP_STYLE.TRIANGLE;
pub const D2D1_CAP_STYLE_FORCE_DWORD = D2D1_CAP_STYLE.FORCE_DWORD;
pub const D2D1_DASH_STYLE = enum(u32) {
SOLID = 0,
DASH = 1,
DOT = 2,
DASH_DOT = 3,
DASH_DOT_DOT = 4,
CUSTOM = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DASH_STYLE_SOLID = D2D1_DASH_STYLE.SOLID;
pub const D2D1_DASH_STYLE_DASH = D2D1_DASH_STYLE.DASH;
pub const D2D1_DASH_STYLE_DOT = D2D1_DASH_STYLE.DOT;
pub const D2D1_DASH_STYLE_DASH_DOT = D2D1_DASH_STYLE.DASH_DOT;
pub const D2D1_DASH_STYLE_DASH_DOT_DOT = D2D1_DASH_STYLE.DASH_DOT_DOT;
pub const D2D1_DASH_STYLE_CUSTOM = D2D1_DASH_STYLE.CUSTOM;
pub const D2D1_DASH_STYLE_FORCE_DWORD = D2D1_DASH_STYLE.FORCE_DWORD;
pub const D2D1_LINE_JOIN = enum(u32) {
MITER = 0,
BEVEL = 1,
ROUND = 2,
MITER_OR_BEVEL = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_LINE_JOIN_MITER = D2D1_LINE_JOIN.MITER;
pub const D2D1_LINE_JOIN_BEVEL = D2D1_LINE_JOIN.BEVEL;
pub const D2D1_LINE_JOIN_ROUND = D2D1_LINE_JOIN.ROUND;
pub const D2D1_LINE_JOIN_MITER_OR_BEVEL = D2D1_LINE_JOIN.MITER_OR_BEVEL;
pub const D2D1_LINE_JOIN_FORCE_DWORD = D2D1_LINE_JOIN.FORCE_DWORD;
pub const D2D1_COMBINE_MODE = enum(u32) {
UNION = 0,
INTERSECT = 1,
XOR = 2,
EXCLUDE = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COMBINE_MODE_UNION = D2D1_COMBINE_MODE.UNION;
pub const D2D1_COMBINE_MODE_INTERSECT = D2D1_COMBINE_MODE.INTERSECT;
pub const D2D1_COMBINE_MODE_XOR = D2D1_COMBINE_MODE.XOR;
pub const D2D1_COMBINE_MODE_EXCLUDE = D2D1_COMBINE_MODE.EXCLUDE;
pub const D2D1_COMBINE_MODE_FORCE_DWORD = D2D1_COMBINE_MODE.FORCE_DWORD;
pub const D2D1_GEOMETRY_RELATION = enum(u32) {
UNKNOWN = 0,
DISJOINT = 1,
IS_CONTAINED = 2,
CONTAINS = 3,
OVERLAP = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GEOMETRY_RELATION_UNKNOWN = D2D1_GEOMETRY_RELATION.UNKNOWN;
pub const D2D1_GEOMETRY_RELATION_DISJOINT = D2D1_GEOMETRY_RELATION.DISJOINT;
pub const D2D1_GEOMETRY_RELATION_IS_CONTAINED = D2D1_GEOMETRY_RELATION.IS_CONTAINED;
pub const D2D1_GEOMETRY_RELATION_CONTAINS = D2D1_GEOMETRY_RELATION.CONTAINS;
pub const D2D1_GEOMETRY_RELATION_OVERLAP = D2D1_GEOMETRY_RELATION.OVERLAP;
pub const D2D1_GEOMETRY_RELATION_FORCE_DWORD = D2D1_GEOMETRY_RELATION.FORCE_DWORD;
pub const D2D1_GEOMETRY_SIMPLIFICATION_OPTION = enum(u32) {
CUBICS_AND_LINES = 0,
LINES = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES = D2D1_GEOMETRY_SIMPLIFICATION_OPTION.CUBICS_AND_LINES;
pub const D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES = D2D1_GEOMETRY_SIMPLIFICATION_OPTION.LINES;
pub const D2D1_GEOMETRY_SIMPLIFICATION_OPTION_FORCE_DWORD = D2D1_GEOMETRY_SIMPLIFICATION_OPTION.FORCE_DWORD;
pub const D2D1_TRIANGLE = extern struct {
point1: D2D_POINT_2F,
point2: D2D_POINT_2F,
point3: D2D_POINT_2F,
};
pub const D2D1_SWEEP_DIRECTION = enum(u32) {
COUNTER_CLOCKWISE = 0,
CLOCKWISE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE = D2D1_SWEEP_DIRECTION.COUNTER_CLOCKWISE;
pub const D2D1_SWEEP_DIRECTION_CLOCKWISE = D2D1_SWEEP_DIRECTION.CLOCKWISE;
pub const D2D1_SWEEP_DIRECTION_FORCE_DWORD = D2D1_SWEEP_DIRECTION.FORCE_DWORD;
pub const D2D1_ARC_SEGMENT = extern struct {
point: D2D_POINT_2F,
size: D2D_SIZE_F,
rotationAngle: f32,
sweepDirection: D2D1_SWEEP_DIRECTION,
arcSize: D2D1_ARC_SIZE,
};
pub const D2D1_QUADRATIC_BEZIER_SEGMENT = extern struct {
point1: D2D_POINT_2F,
point2: D2D_POINT_2F,
};
pub const D2D1_ELLIPSE = extern struct {
point: D2D_POINT_2F,
radiusX: f32,
radiusY: f32,
};
pub const D2D1_ROUNDED_RECT = extern struct {
rect: D2D_RECT_F,
radiusX: f32,
radiusY: f32,
};
pub const D2D1_STROKE_STYLE_PROPERTIES = extern struct {
startCap: D2D1_CAP_STYLE,
endCap: D2D1_CAP_STYLE,
dashCap: D2D1_CAP_STYLE,
lineJoin: D2D1_LINE_JOIN,
miterLimit: f32,
dashStyle: D2D1_DASH_STYLE,
dashOffset: f32,
};
pub const D2D1_LAYER_OPTIONS = enum(u32) {
NONE = 0,
INITIALIZE_FOR_CLEARTYPE = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
INITIALIZE_FOR_CLEARTYPE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_LAYER_OPTIONS {
return @intToEnum(D2D1_LAYER_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_LAYER_OPTIONS.NONE) else 0)
| (if (o.INITIALIZE_FOR_CLEARTYPE == 1) @enumToInt(D2D1_LAYER_OPTIONS.INITIALIZE_FOR_CLEARTYPE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_LAYER_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_LAYER_OPTIONS_NONE = D2D1_LAYER_OPTIONS.NONE;
pub const D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = D2D1_LAYER_OPTIONS.INITIALIZE_FOR_CLEARTYPE;
pub const D2D1_LAYER_OPTIONS_FORCE_DWORD = D2D1_LAYER_OPTIONS.FORCE_DWORD;
pub const D2D1_LAYER_PARAMETERS = extern struct {
contentBounds: D2D_RECT_F,
geometricMask: ?*ID2D1Geometry,
maskAntialiasMode: D2D1_ANTIALIAS_MODE,
maskTransform: D2D_MATRIX_3X2_F,
opacity: f32,
opacityBrush: ?*ID2D1Brush,
layerOptions: D2D1_LAYER_OPTIONS,
};
pub const D2D1_WINDOW_STATE = enum(u32) {
NONE = 0,
OCCLUDED = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
OCCLUDED: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_WINDOW_STATE {
return @intToEnum(D2D1_WINDOW_STATE,
(if (o.NONE == 1) @enumToInt(D2D1_WINDOW_STATE.NONE) else 0)
| (if (o.OCCLUDED == 1) @enumToInt(D2D1_WINDOW_STATE.OCCLUDED) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_WINDOW_STATE.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_WINDOW_STATE_NONE = D2D1_WINDOW_STATE.NONE;
pub const D2D1_WINDOW_STATE_OCCLUDED = D2D1_WINDOW_STATE.OCCLUDED;
pub const D2D1_WINDOW_STATE_FORCE_DWORD = D2D1_WINDOW_STATE.FORCE_DWORD;
pub const D2D1_RENDER_TARGET_TYPE = enum(u32) {
DEFAULT = 0,
SOFTWARE = 1,
HARDWARE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_RENDER_TARGET_TYPE_DEFAULT = D2D1_RENDER_TARGET_TYPE.DEFAULT;
pub const D2D1_RENDER_TARGET_TYPE_SOFTWARE = D2D1_RENDER_TARGET_TYPE.SOFTWARE;
pub const D2D1_RENDER_TARGET_TYPE_HARDWARE = D2D1_RENDER_TARGET_TYPE.HARDWARE;
pub const D2D1_RENDER_TARGET_TYPE_FORCE_DWORD = D2D1_RENDER_TARGET_TYPE.FORCE_DWORD;
pub const D2D1_FEATURE_LEVEL = enum(u32) {
DEFAULT = 0,
@"9" = 37120,
@"10" = 40960,
FORCE_DWORD = 4294967295,
};
pub const D2D1_FEATURE_LEVEL_DEFAULT = D2D1_FEATURE_LEVEL.DEFAULT;
pub const D2D1_FEATURE_LEVEL_9 = D2D1_FEATURE_LEVEL.@"9";
pub const D2D1_FEATURE_LEVEL_10 = D2D1_FEATURE_LEVEL.@"10";
pub const D2D1_FEATURE_LEVEL_FORCE_DWORD = D2D1_FEATURE_LEVEL.FORCE_DWORD;
pub const D2D1_RENDER_TARGET_USAGE = enum(u32) {
NONE = 0,
FORCE_BITMAP_REMOTING = 1,
GDI_COMPATIBLE = 2,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
FORCE_BITMAP_REMOTING: u1 = 0,
GDI_COMPATIBLE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_RENDER_TARGET_USAGE {
return @intToEnum(D2D1_RENDER_TARGET_USAGE,
(if (o.NONE == 1) @enumToInt(D2D1_RENDER_TARGET_USAGE.NONE) else 0)
| (if (o.FORCE_BITMAP_REMOTING == 1) @enumToInt(D2D1_RENDER_TARGET_USAGE.FORCE_BITMAP_REMOTING) else 0)
| (if (o.GDI_COMPATIBLE == 1) @enumToInt(D2D1_RENDER_TARGET_USAGE.GDI_COMPATIBLE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_RENDER_TARGET_USAGE.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_RENDER_TARGET_USAGE_NONE = D2D1_RENDER_TARGET_USAGE.NONE;
pub const D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING = D2D1_RENDER_TARGET_USAGE.FORCE_BITMAP_REMOTING;
pub const D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE = D2D1_RENDER_TARGET_USAGE.GDI_COMPATIBLE;
pub const D2D1_RENDER_TARGET_USAGE_FORCE_DWORD = D2D1_RENDER_TARGET_USAGE.FORCE_DWORD;
pub const D2D1_PRESENT_OPTIONS = enum(u32) {
NONE = 0,
RETAIN_CONTENTS = 1,
IMMEDIATELY = 2,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
RETAIN_CONTENTS: u1 = 0,
IMMEDIATELY: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_PRESENT_OPTIONS {
return @intToEnum(D2D1_PRESENT_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_PRESENT_OPTIONS.NONE) else 0)
| (if (o.RETAIN_CONTENTS == 1) @enumToInt(D2D1_PRESENT_OPTIONS.RETAIN_CONTENTS) else 0)
| (if (o.IMMEDIATELY == 1) @enumToInt(D2D1_PRESENT_OPTIONS.IMMEDIATELY) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_PRESENT_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_PRESENT_OPTIONS_NONE = D2D1_PRESENT_OPTIONS.NONE;
pub const D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = D2D1_PRESENT_OPTIONS.RETAIN_CONTENTS;
pub const D2D1_PRESENT_OPTIONS_IMMEDIATELY = D2D1_PRESENT_OPTIONS.IMMEDIATELY;
pub const D2D1_PRESENT_OPTIONS_FORCE_DWORD = D2D1_PRESENT_OPTIONS.FORCE_DWORD;
pub const D2D1_RENDER_TARGET_PROPERTIES = extern struct {
type: D2D1_RENDER_TARGET_TYPE,
pixelFormat: D2D1_PIXEL_FORMAT,
dpiX: f32,
dpiY: f32,
usage: D2D1_RENDER_TARGET_USAGE,
minLevel: D2D1_FEATURE_LEVEL,
};
pub const D2D1_HWND_RENDER_TARGET_PROPERTIES = extern struct {
hwnd: ?HWND,
pixelSize: D2D_SIZE_U,
presentOptions: D2D1_PRESENT_OPTIONS,
};
pub const D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS = enum(u32) {
NONE = 0,
GDI_COMPATIBLE = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
GDI_COMPATIBLE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS {
return @intToEnum(D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.NONE) else 0)
| (if (o.GDI_COMPATIBLE == 1) @enumToInt(D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.GDI_COMPATIBLE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE = D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.NONE;
pub const D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE = D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.GDI_COMPATIBLE;
pub const D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_FORCE_DWORD = D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS.FORCE_DWORD;
pub const D2D1_DRAWING_STATE_DESCRIPTION = extern struct {
antialiasMode: D2D1_ANTIALIAS_MODE,
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
tag1: u64,
tag2: u64,
transform: D2D_MATRIX_3X2_F,
};
pub const D2D1_DC_INITIALIZE_MODE = enum(u32) {
COPY = 0,
CLEAR = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DC_INITIALIZE_MODE_COPY = D2D1_DC_INITIALIZE_MODE.COPY;
pub const D2D1_DC_INITIALIZE_MODE_CLEAR = D2D1_DC_INITIALIZE_MODE.CLEAR;
pub const D2D1_DC_INITIALIZE_MODE_FORCE_DWORD = D2D1_DC_INITIALIZE_MODE.FORCE_DWORD;
pub const D2D1_DEBUG_LEVEL = enum(u32) {
NONE = 0,
ERROR = 1,
WARNING = 2,
INFORMATION = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DEBUG_LEVEL_NONE = D2D1_DEBUG_LEVEL.NONE;
pub const D2D1_DEBUG_LEVEL_ERROR = D2D1_DEBUG_LEVEL.ERROR;
pub const D2D1_DEBUG_LEVEL_WARNING = D2D1_DEBUG_LEVEL.WARNING;
pub const D2D1_DEBUG_LEVEL_INFORMATION = D2D1_DEBUG_LEVEL.INFORMATION;
pub const D2D1_DEBUG_LEVEL_FORCE_DWORD = D2D1_DEBUG_LEVEL.FORCE_DWORD;
pub const D2D1_FACTORY_TYPE = enum(u32) {
SINGLE_THREADED = 0,
MULTI_THREADED = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_FACTORY_TYPE_SINGLE_THREADED = D2D1_FACTORY_TYPE.SINGLE_THREADED;
pub const D2D1_FACTORY_TYPE_MULTI_THREADED = D2D1_FACTORY_TYPE.MULTI_THREADED;
pub const D2D1_FACTORY_TYPE_FORCE_DWORD = D2D1_FACTORY_TYPE.FORCE_DWORD;
pub const D2D1_FACTORY_OPTIONS = extern struct {
debugLevel: D2D1_DEBUG_LEVEL,
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Resource_Value = @import("../zig.zig").Guid.initString("2cd90691-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1Resource = &IID_ID2D1Resource_Value;
pub const ID2D1Resource = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetFactory: fn(
self: *const ID2D1Resource,
factory: ?*?*ID2D1Factory,
) callconv(@import("std").os.windows.WINAPI) void,
};
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 ID2D1Resource_GetFactory(self: *const T, factory: ?*?*ID2D1Factory) callconv(.Inline) void {
return @ptrCast(*const ID2D1Resource.VTable, self.vtable).GetFactory(@ptrCast(*const ID2D1Resource, self), factory);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Image_Value = @import("../zig.zig").Guid.initString("65019f75-8da2-497c-b32c-dfa34e48ede6");
pub const IID_ID2D1Image = &IID_ID2D1Image_Value;
pub const ID2D1Image = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Bitmap_Value = @import("../zig.zig").Guid.initString("a2296057-ea42-4099-983b-539fb6505426");
pub const IID_ID2D1Bitmap = &IID_ID2D1Bitmap_Value;
pub const ID2D1Bitmap = extern struct {
pub const VTable = extern struct {
base: ID2D1Image.VTable,
GetSize: fn(
self: *const ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_F,
GetPixelSize: fn(
self: *const ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_U,
GetPixelFormat: fn(
self: *const ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) D2D1_PIXEL_FORMAT,
GetDpi: fn(
self: *const ID2D1Bitmap,
dpiX: ?*f32,
dpiY: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void,
CopyFromBitmap: fn(
self: *const ID2D1Bitmap,
destPoint: ?*const D2D_POINT_2U,
bitmap: ?*ID2D1Bitmap,
srcRect: ?*const D2D_RECT_U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CopyFromRenderTarget: fn(
self: *const ID2D1Bitmap,
destPoint: ?*const D2D_POINT_2U,
renderTarget: ?*ID2D1RenderTarget,
srcRect: ?*const D2D_RECT_U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CopyFromMemory: fn(
self: *const ID2D1Bitmap,
dstRect: ?*const D2D_RECT_U,
srcData: ?*const anyopaque,
pitch: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Image.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_GetSize(self: *const T) callconv(.Inline) D2D_SIZE_F {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).GetSize(@ptrCast(*const ID2D1Bitmap, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_GetPixelSize(self: *const T) callconv(.Inline) D2D_SIZE_U {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).GetPixelSize(@ptrCast(*const ID2D1Bitmap, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_GetPixelFormat(self: *const T) callconv(.Inline) D2D1_PIXEL_FORMAT {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).GetPixelFormat(@ptrCast(*const ID2D1Bitmap, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_GetDpi(self: *const T, dpiX: ?*f32, dpiY: ?*f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).GetDpi(@ptrCast(*const ID2D1Bitmap, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_CopyFromBitmap(self: *const T, destPoint: ?*const D2D_POINT_2U, bitmap: ?*ID2D1Bitmap, srcRect: ?*const D2D_RECT_U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).CopyFromBitmap(@ptrCast(*const ID2D1Bitmap, self), destPoint, bitmap, srcRect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_CopyFromRenderTarget(self: *const T, destPoint: ?*const D2D_POINT_2U, renderTarget: ?*ID2D1RenderTarget, srcRect: ?*const D2D_RECT_U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).CopyFromRenderTarget(@ptrCast(*const ID2D1Bitmap, self), destPoint, renderTarget, srcRect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap_CopyFromMemory(self: *const T, dstRect: ?*const D2D_RECT_U, srcData: ?*const anyopaque, pitch: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap.VTable, self.vtable).CopyFromMemory(@ptrCast(*const ID2D1Bitmap, self), dstRect, srcData, pitch);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1GradientStopCollection_Value = @import("../zig.zig").Guid.initString("2cd906a7-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1GradientStopCollection = &IID_ID2D1GradientStopCollection_Value;
pub const ID2D1GradientStopCollection = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetGradientStopCount: fn(
self: *const ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) u32,
GetGradientStops: fn(
self: *const ID2D1GradientStopCollection,
gradientStops: [*]D2D1_GRADIENT_STOP,
gradientStopsCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
GetColorInterpolationGamma: fn(
self: *const ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) D2D1_GAMMA,
GetExtendMode: fn(
self: *const ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection_GetGradientStopCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1GradientStopCollection.VTable, self.vtable).GetGradientStopCount(@ptrCast(*const ID2D1GradientStopCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection_GetGradientStops(self: *const T, gradientStops: [*]D2D1_GRADIENT_STOP, gradientStopsCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1GradientStopCollection.VTable, self.vtable).GetGradientStops(@ptrCast(*const ID2D1GradientStopCollection, self), gradientStops, gradientStopsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection_GetColorInterpolationGamma(self: *const T) callconv(.Inline) D2D1_GAMMA {
return @ptrCast(*const ID2D1GradientStopCollection.VTable, self.vtable).GetColorInterpolationGamma(@ptrCast(*const ID2D1GradientStopCollection, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection_GetExtendMode(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1GradientStopCollection.VTable, self.vtable).GetExtendMode(@ptrCast(*const ID2D1GradientStopCollection, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Brush_Value = @import("../zig.zig").Guid.initString("2cd906a8-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1Brush = &IID_ID2D1Brush_Value;
pub const ID2D1Brush = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
SetOpacity: fn(
self: *const ID2D1Brush,
opacity: f32,
) callconv(@import("std").os.windows.WINAPI) void,
SetTransform: fn(
self: *const ID2D1Brush,
transform: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
GetOpacity: fn(
self: *const ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) f32,
GetTransform: fn(
self: *const ID2D1Brush,
transform: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Brush_SetOpacity(self: *const T, opacity: f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1Brush.VTable, self.vtable).SetOpacity(@ptrCast(*const ID2D1Brush, self), opacity);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Brush_SetTransform(self: *const T, transform: ?*const D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1Brush.VTable, self.vtable).SetTransform(@ptrCast(*const ID2D1Brush, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Brush_GetOpacity(self: *const T) callconv(.Inline) f32 {
return @ptrCast(*const ID2D1Brush.VTable, self.vtable).GetOpacity(@ptrCast(*const ID2D1Brush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Brush_GetTransform(self: *const T, transform: ?*D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1Brush.VTable, self.vtable).GetTransform(@ptrCast(*const ID2D1Brush, self), transform);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1BitmapBrush_Value = @import("../zig.zig").Guid.initString("2cd906aa-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1BitmapBrush = &IID_ID2D1BitmapBrush_Value;
pub const ID2D1BitmapBrush = extern struct {
pub const VTable = extern struct {
base: ID2D1Brush.VTable,
SetExtendModeX: fn(
self: *const ID2D1BitmapBrush,
extendModeX: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetExtendModeY: fn(
self: *const ID2D1BitmapBrush,
extendModeY: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetInterpolationMode: fn(
self: *const ID2D1BitmapBrush,
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetBitmap: fn(
self: *const ID2D1BitmapBrush,
bitmap: ?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) void,
GetExtendModeX: fn(
self: *const ID2D1BitmapBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
GetExtendModeY: fn(
self: *const ID2D1BitmapBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
GetInterpolationMode: fn(
self: *const ID2D1BitmapBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_BITMAP_INTERPOLATION_MODE,
GetBitmap: fn(
self: *const ID2D1BitmapBrush,
bitmap: ?*?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Brush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_SetExtendModeX(self: *const T, extendModeX: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).SetExtendModeX(@ptrCast(*const ID2D1BitmapBrush, self), extendModeX);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_SetExtendModeY(self: *const T, extendModeY: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).SetExtendModeY(@ptrCast(*const ID2D1BitmapBrush, self), extendModeY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_SetInterpolationMode(self: *const T, interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).SetInterpolationMode(@ptrCast(*const ID2D1BitmapBrush, self), interpolationMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_SetBitmap(self: *const T, bitmap: ?*ID2D1Bitmap) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).SetBitmap(@ptrCast(*const ID2D1BitmapBrush, self), bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_GetExtendModeX(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).GetExtendModeX(@ptrCast(*const ID2D1BitmapBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_GetExtendModeY(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).GetExtendModeY(@ptrCast(*const ID2D1BitmapBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_GetInterpolationMode(self: *const T) callconv(.Inline) D2D1_BITMAP_INTERPOLATION_MODE {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).GetInterpolationMode(@ptrCast(*const ID2D1BitmapBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush_GetBitmap(self: *const T, bitmap: ?*?*ID2D1Bitmap) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush.VTable, self.vtable).GetBitmap(@ptrCast(*const ID2D1BitmapBrush, self), bitmap);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1SolidColorBrush_Value = @import("../zig.zig").Guid.initString("2cd906a9-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1SolidColorBrush = &IID_ID2D1SolidColorBrush_Value;
pub const ID2D1SolidColorBrush = extern struct {
pub const VTable = extern struct {
base: ID2D1Brush.VTable,
SetColor: fn(
self: *const ID2D1SolidColorBrush,
color: ?*const D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) void,
GetColor: fn(
self: *const ID2D1SolidColorBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_F,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Brush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SolidColorBrush_SetColor(self: *const T, color: ?*const D2D1_COLOR_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1SolidColorBrush.VTable, self.vtable).SetColor(@ptrCast(*const ID2D1SolidColorBrush, self), color);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SolidColorBrush_GetColor(self: *const T) callconv(.Inline) D2D1_COLOR_F {
return @ptrCast(*const ID2D1SolidColorBrush.VTable, self.vtable).GetColor(@ptrCast(*const ID2D1SolidColorBrush, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1LinearGradientBrush_Value = @import("../zig.zig").Guid.initString("2cd906ab-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1LinearGradientBrush = &IID_ID2D1LinearGradientBrush_Value;
pub const ID2D1LinearGradientBrush = extern struct {
pub const VTable = extern struct {
base: ID2D1Brush.VTable,
SetStartPoint: fn(
self: *const ID2D1LinearGradientBrush,
startPoint: D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
SetEndPoint: fn(
self: *const ID2D1LinearGradientBrush,
endPoint: D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
GetStartPoint: fn(
self: *const ID2D1LinearGradientBrush,
) callconv(@import("std").os.windows.WINAPI) D2D_POINT_2F,
GetEndPoint: fn(
self: *const ID2D1LinearGradientBrush,
) callconv(@import("std").os.windows.WINAPI) D2D_POINT_2F,
GetGradientStopCollection: fn(
self: *const ID2D1LinearGradientBrush,
gradientStopCollection: ?*?*ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Brush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1LinearGradientBrush_SetStartPoint(self: *const T, startPoint: D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1LinearGradientBrush.VTable, self.vtable).SetStartPoint(@ptrCast(*const ID2D1LinearGradientBrush, self), startPoint);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1LinearGradientBrush_SetEndPoint(self: *const T, endPoint: D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1LinearGradientBrush.VTable, self.vtable).SetEndPoint(@ptrCast(*const ID2D1LinearGradientBrush, self), endPoint);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1LinearGradientBrush_GetStartPoint(self: *const T) callconv(.Inline) D2D_POINT_2F {
return @ptrCast(*const ID2D1LinearGradientBrush.VTable, self.vtable).GetStartPoint(@ptrCast(*const ID2D1LinearGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1LinearGradientBrush_GetEndPoint(self: *const T) callconv(.Inline) D2D_POINT_2F {
return @ptrCast(*const ID2D1LinearGradientBrush.VTable, self.vtable).GetEndPoint(@ptrCast(*const ID2D1LinearGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1LinearGradientBrush_GetGradientStopCollection(self: *const T, gradientStopCollection: ?*?*ID2D1GradientStopCollection) callconv(.Inline) void {
return @ptrCast(*const ID2D1LinearGradientBrush.VTable, self.vtable).GetGradientStopCollection(@ptrCast(*const ID2D1LinearGradientBrush, self), gradientStopCollection);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1RadialGradientBrush_Value = @import("../zig.zig").Guid.initString("2cd906ac-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1RadialGradientBrush = &IID_ID2D1RadialGradientBrush_Value;
pub const ID2D1RadialGradientBrush = extern struct {
pub const VTable = extern struct {
base: ID2D1Brush.VTable,
SetCenter: fn(
self: *const ID2D1RadialGradientBrush,
center: D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
SetGradientOriginOffset: fn(
self: *const ID2D1RadialGradientBrush,
gradientOriginOffset: D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
SetRadiusX: fn(
self: *const ID2D1RadialGradientBrush,
radiusX: f32,
) callconv(@import("std").os.windows.WINAPI) void,
SetRadiusY: fn(
self: *const ID2D1RadialGradientBrush,
radiusY: f32,
) callconv(@import("std").os.windows.WINAPI) void,
GetCenter: fn(
self: *const ID2D1RadialGradientBrush,
) callconv(@import("std").os.windows.WINAPI) D2D_POINT_2F,
GetGradientOriginOffset: fn(
self: *const ID2D1RadialGradientBrush,
) callconv(@import("std").os.windows.WINAPI) D2D_POINT_2F,
GetRadiusX: fn(
self: *const ID2D1RadialGradientBrush,
) callconv(@import("std").os.windows.WINAPI) f32,
GetRadiusY: fn(
self: *const ID2D1RadialGradientBrush,
) callconv(@import("std").os.windows.WINAPI) f32,
GetGradientStopCollection: fn(
self: *const ID2D1RadialGradientBrush,
gradientStopCollection: ?*?*ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Brush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_SetCenter(self: *const T, center: D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).SetCenter(@ptrCast(*const ID2D1RadialGradientBrush, self), center);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_SetGradientOriginOffset(self: *const T, gradientOriginOffset: D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).SetGradientOriginOffset(@ptrCast(*const ID2D1RadialGradientBrush, self), gradientOriginOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_SetRadiusX(self: *const T, radiusX: f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).SetRadiusX(@ptrCast(*const ID2D1RadialGradientBrush, self), radiusX);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_SetRadiusY(self: *const T, radiusY: f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).SetRadiusY(@ptrCast(*const ID2D1RadialGradientBrush, self), radiusY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_GetCenter(self: *const T) callconv(.Inline) D2D_POINT_2F {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).GetCenter(@ptrCast(*const ID2D1RadialGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_GetGradientOriginOffset(self: *const T) callconv(.Inline) D2D_POINT_2F {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).GetGradientOriginOffset(@ptrCast(*const ID2D1RadialGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_GetRadiusX(self: *const T) callconv(.Inline) f32 {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).GetRadiusX(@ptrCast(*const ID2D1RadialGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_GetRadiusY(self: *const T) callconv(.Inline) f32 {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).GetRadiusY(@ptrCast(*const ID2D1RadialGradientBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RadialGradientBrush_GetGradientStopCollection(self: *const T, gradientStopCollection: ?*?*ID2D1GradientStopCollection) callconv(.Inline) void {
return @ptrCast(*const ID2D1RadialGradientBrush.VTable, self.vtable).GetGradientStopCollection(@ptrCast(*const ID2D1RadialGradientBrush, self), gradientStopCollection);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1StrokeStyle_Value = @import("../zig.zig").Guid.initString("2cd9069d-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1StrokeStyle = &IID_ID2D1StrokeStyle_Value;
pub const ID2D1StrokeStyle = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetStartCap: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_CAP_STYLE,
GetEndCap: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_CAP_STYLE,
GetDashCap: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_CAP_STYLE,
GetMiterLimit: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) f32,
GetLineJoin: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_LINE_JOIN,
GetDashOffset: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) f32,
GetDashStyle: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_DASH_STYLE,
GetDashesCount: fn(
self: *const ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) u32,
GetDashes: fn(
self: *const ID2D1StrokeStyle,
dashes: [*]f32,
dashesCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetStartCap(self: *const T) callconv(.Inline) D2D1_CAP_STYLE {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetStartCap(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetEndCap(self: *const T) callconv(.Inline) D2D1_CAP_STYLE {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetEndCap(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetDashCap(self: *const T) callconv(.Inline) D2D1_CAP_STYLE {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetDashCap(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetMiterLimit(self: *const T) callconv(.Inline) f32 {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetMiterLimit(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetLineJoin(self: *const T) callconv(.Inline) D2D1_LINE_JOIN {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetLineJoin(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetDashOffset(self: *const T) callconv(.Inline) f32 {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetDashOffset(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetDashStyle(self: *const T) callconv(.Inline) D2D1_DASH_STYLE {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetDashStyle(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetDashesCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetDashesCount(@ptrCast(*const ID2D1StrokeStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle_GetDashes(self: *const T, dashes: [*]f32, dashesCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1StrokeStyle.VTable, self.vtable).GetDashes(@ptrCast(*const ID2D1StrokeStyle, self), dashes, dashesCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Geometry_Value = @import("../zig.zig").Guid.initString("2cd906a1-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1Geometry = &IID_ID2D1Geometry_Value;
pub const ID2D1Geometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetBounds: fn(
self: *const ID2D1Geometry,
worldTransform: ?*const D2D_MATRIX_3X2_F,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetWidenedBounds: fn(
self: *const ID2D1Geometry,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
StrokeContainsPoint: fn(
self: *const ID2D1Geometry,
point: D2D_POINT_2F,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
contains: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillContainsPoint: fn(
self: *const ID2D1Geometry,
point: D2D_POINT_2F,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
contains: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CompareWithGeometry: fn(
self: *const ID2D1Geometry,
inputGeometry: ?*ID2D1Geometry,
inputGeometryTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
relation: ?*D2D1_GEOMETRY_RELATION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Simplify: fn(
self: *const ID2D1Geometry,
simplificationOption: D2D1_GEOMETRY_SIMPLIFICATION_OPTION,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
geometrySink: ?*ID2D1SimplifiedGeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Tessellate: fn(
self: *const ID2D1Geometry,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
tessellationSink: ?*ID2D1TessellationSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CombineWithGeometry: fn(
self: *const ID2D1Geometry,
inputGeometry: ?*ID2D1Geometry,
combineMode: D2D1_COMBINE_MODE,
inputGeometryTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
geometrySink: ?*ID2D1SimplifiedGeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Outline: fn(
self: *const ID2D1Geometry,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
geometrySink: ?*ID2D1SimplifiedGeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ComputeArea: fn(
self: *const ID2D1Geometry,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
area: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ComputeLength: fn(
self: *const ID2D1Geometry,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
length: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ComputePointAtLength: fn(
self: *const ID2D1Geometry,
length: f32,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
point: ?*D2D_POINT_2F,
unitTangentVector: ?*D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Widen: fn(
self: *const ID2D1Geometry,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
geometrySink: ?*ID2D1SimplifiedGeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_GetBounds(self: *const T, worldTransform: ?*const D2D_MATRIX_3X2_F, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).GetBounds(@ptrCast(*const ID2D1Geometry, self), worldTransform, bounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_GetWidenedBounds(self: *const T, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).GetWidenedBounds(@ptrCast(*const ID2D1Geometry, self), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, bounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_StrokeContainsPoint(self: *const T, point: D2D_POINT_2F, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, contains: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).StrokeContainsPoint(@ptrCast(*const ID2D1Geometry, self), point, strokeWidth, strokeStyle, worldTransform, flatteningTolerance, contains);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_FillContainsPoint(self: *const T, point: D2D_POINT_2F, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, contains: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).FillContainsPoint(@ptrCast(*const ID2D1Geometry, self), point, worldTransform, flatteningTolerance, contains);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_CompareWithGeometry(self: *const T, inputGeometry: ?*ID2D1Geometry, inputGeometryTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, relation: ?*D2D1_GEOMETRY_RELATION) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).CompareWithGeometry(@ptrCast(*const ID2D1Geometry, self), inputGeometry, inputGeometryTransform, flatteningTolerance, relation);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_Simplify(self: *const T, simplificationOption: D2D1_GEOMETRY_SIMPLIFICATION_OPTION, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, geometrySink: ?*ID2D1SimplifiedGeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).Simplify(@ptrCast(*const ID2D1Geometry, self), simplificationOption, worldTransform, flatteningTolerance, geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_Tessellate(self: *const T, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, tessellationSink: ?*ID2D1TessellationSink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).Tessellate(@ptrCast(*const ID2D1Geometry, self), worldTransform, flatteningTolerance, tessellationSink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_CombineWithGeometry(self: *const T, inputGeometry: ?*ID2D1Geometry, combineMode: D2D1_COMBINE_MODE, inputGeometryTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, geometrySink: ?*ID2D1SimplifiedGeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).CombineWithGeometry(@ptrCast(*const ID2D1Geometry, self), inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_Outline(self: *const T, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, geometrySink: ?*ID2D1SimplifiedGeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).Outline(@ptrCast(*const ID2D1Geometry, self), worldTransform, flatteningTolerance, geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_ComputeArea(self: *const T, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, area: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).ComputeArea(@ptrCast(*const ID2D1Geometry, self), worldTransform, flatteningTolerance, area);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_ComputeLength(self: *const T, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, length: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).ComputeLength(@ptrCast(*const ID2D1Geometry, self), worldTransform, flatteningTolerance, length);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_ComputePointAtLength(self: *const T, length: f32, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, point: ?*D2D_POINT_2F, unitTangentVector: ?*D2D_POINT_2F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).ComputePointAtLength(@ptrCast(*const ID2D1Geometry, self), length, worldTransform, flatteningTolerance, point, unitTangentVector);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Geometry_Widen(self: *const T, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, geometrySink: ?*ID2D1SimplifiedGeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Geometry.VTable, self.vtable).Widen(@ptrCast(*const ID2D1Geometry, self), strokeWidth, strokeStyle, worldTransform, flatteningTolerance, geometrySink);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1RectangleGeometry_Value = @import("../zig.zig").Guid.initString("2cd906a2-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1RectangleGeometry = &IID_ID2D1RectangleGeometry_Value;
pub const ID2D1RectangleGeometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
GetRect: fn(
self: *const ID2D1RectangleGeometry,
rect: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RectangleGeometry_GetRect(self: *const T, rect: ?*D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RectangleGeometry.VTable, self.vtable).GetRect(@ptrCast(*const ID2D1RectangleGeometry, self), rect);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1RoundedRectangleGeometry_Value = @import("../zig.zig").Guid.initString("2cd906a3-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1RoundedRectangleGeometry = &IID_ID2D1RoundedRectangleGeometry_Value;
pub const ID2D1RoundedRectangleGeometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
GetRoundedRect: fn(
self: *const ID2D1RoundedRectangleGeometry,
roundedRect: ?*D2D1_ROUNDED_RECT,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RoundedRectangleGeometry_GetRoundedRect(self: *const T, roundedRect: ?*D2D1_ROUNDED_RECT) callconv(.Inline) void {
return @ptrCast(*const ID2D1RoundedRectangleGeometry.VTable, self.vtable).GetRoundedRect(@ptrCast(*const ID2D1RoundedRectangleGeometry, self), roundedRect);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1EllipseGeometry_Value = @import("../zig.zig").Guid.initString("2cd906a4-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1EllipseGeometry = &IID_ID2D1EllipseGeometry_Value;
pub const ID2D1EllipseGeometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
GetEllipse: fn(
self: *const ID2D1EllipseGeometry,
ellipse: ?*D2D1_ELLIPSE,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EllipseGeometry_GetEllipse(self: *const T, ellipse: ?*D2D1_ELLIPSE) callconv(.Inline) void {
return @ptrCast(*const ID2D1EllipseGeometry.VTable, self.vtable).GetEllipse(@ptrCast(*const ID2D1EllipseGeometry, self), ellipse);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1GeometryGroup_Value = @import("../zig.zig").Guid.initString("2cd906a6-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1GeometryGroup = &IID_ID2D1GeometryGroup_Value;
pub const ID2D1GeometryGroup = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
GetFillMode: fn(
self: *const ID2D1GeometryGroup,
) callconv(@import("std").os.windows.WINAPI) D2D1_FILL_MODE,
GetSourceGeometryCount: fn(
self: *const ID2D1GeometryGroup,
) callconv(@import("std").os.windows.WINAPI) u32,
GetSourceGeometries: fn(
self: *const ID2D1GeometryGroup,
geometries: [*]?*ID2D1Geometry,
geometriesCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometryGroup_GetFillMode(self: *const T) callconv(.Inline) D2D1_FILL_MODE {
return @ptrCast(*const ID2D1GeometryGroup.VTable, self.vtable).GetFillMode(@ptrCast(*const ID2D1GeometryGroup, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometryGroup_GetSourceGeometryCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1GeometryGroup.VTable, self.vtable).GetSourceGeometryCount(@ptrCast(*const ID2D1GeometryGroup, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometryGroup_GetSourceGeometries(self: *const T, geometries: [*]?*ID2D1Geometry, geometriesCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometryGroup.VTable, self.vtable).GetSourceGeometries(@ptrCast(*const ID2D1GeometryGroup, self), geometries, geometriesCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1TransformedGeometry_Value = @import("../zig.zig").Guid.initString("2cd906bb-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1TransformedGeometry = &IID_ID2D1TransformedGeometry_Value;
pub const ID2D1TransformedGeometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
GetSourceGeometry: fn(
self: *const ID2D1TransformedGeometry,
sourceGeometry: ?*?*ID2D1Geometry,
) callconv(@import("std").os.windows.WINAPI) void,
GetTransform: fn(
self: *const ID2D1TransformedGeometry,
transform: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformedGeometry_GetSourceGeometry(self: *const T, sourceGeometry: ?*?*ID2D1Geometry) callconv(.Inline) void {
return @ptrCast(*const ID2D1TransformedGeometry.VTable, self.vtable).GetSourceGeometry(@ptrCast(*const ID2D1TransformedGeometry, self), sourceGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformedGeometry_GetTransform(self: *const T, transform: ?*D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1TransformedGeometry.VTable, self.vtable).GetTransform(@ptrCast(*const ID2D1TransformedGeometry, self), transform);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1GeometrySink_Value = @import("../zig.zig").Guid.initString("2cd9069f-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1GeometrySink = &IID_ID2D1GeometrySink_Value;
pub const ID2D1GeometrySink = extern struct {
pub const VTable = extern struct {
base: ID2D1SimplifiedGeometrySink.VTable,
AddLine: fn(
self: *const ID2D1GeometrySink,
point: D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
AddBezier: fn(
self: *const ID2D1GeometrySink,
bezier: ?*const D2D1_BEZIER_SEGMENT,
) callconv(@import("std").os.windows.WINAPI) void,
AddQuadraticBezier: fn(
self: *const ID2D1GeometrySink,
bezier: ?*const D2D1_QUADRATIC_BEZIER_SEGMENT,
) callconv(@import("std").os.windows.WINAPI) void,
AddQuadraticBeziers: fn(
self: *const ID2D1GeometrySink,
beziers: [*]const D2D1_QUADRATIC_BEZIER_SEGMENT,
beziersCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
AddArc: fn(
self: *const ID2D1GeometrySink,
arc: ?*const D2D1_ARC_SEGMENT,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1SimplifiedGeometrySink.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometrySink_AddLine(self: *const T, point: D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometrySink.VTable, self.vtable).AddLine(@ptrCast(*const ID2D1GeometrySink, self), point);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometrySink_AddBezier(self: *const T, bezier: ?*const D2D1_BEZIER_SEGMENT) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometrySink.VTable, self.vtable).AddBezier(@ptrCast(*const ID2D1GeometrySink, self), bezier);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometrySink_AddQuadraticBezier(self: *const T, bezier: ?*const D2D1_QUADRATIC_BEZIER_SEGMENT) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometrySink.VTable, self.vtable).AddQuadraticBezier(@ptrCast(*const ID2D1GeometrySink, self), bezier);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometrySink_AddQuadraticBeziers(self: *const T, beziers: [*]const D2D1_QUADRATIC_BEZIER_SEGMENT, beziersCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometrySink.VTable, self.vtable).AddQuadraticBeziers(@ptrCast(*const ID2D1GeometrySink, self), beziers, beziersCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GeometrySink_AddArc(self: *const T, arc: ?*const D2D1_ARC_SEGMENT) callconv(.Inline) void {
return @ptrCast(*const ID2D1GeometrySink.VTable, self.vtable).AddArc(@ptrCast(*const ID2D1GeometrySink, self), arc);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1TessellationSink_Value = @import("../zig.zig").Guid.initString("2cd906c1-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1TessellationSink = &IID_ID2D1TessellationSink_Value;
pub const ID2D1TessellationSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddTriangles: fn(
self: *const ID2D1TessellationSink,
triangles: [*]const D2D1_TRIANGLE,
trianglesCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
Close: fn(
self: *const ID2D1TessellationSink,
) 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 ID2D1TessellationSink_AddTriangles(self: *const T, triangles: [*]const D2D1_TRIANGLE, trianglesCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1TessellationSink.VTable, self.vtable).AddTriangles(@ptrCast(*const ID2D1TessellationSink, self), triangles, trianglesCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TessellationSink_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TessellationSink.VTable, self.vtable).Close(@ptrCast(*const ID2D1TessellationSink, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1PathGeometry_Value = @import("../zig.zig").Guid.initString("2cd906a5-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1PathGeometry = &IID_ID2D1PathGeometry_Value;
pub const ID2D1PathGeometry = extern struct {
pub const VTable = extern struct {
base: ID2D1Geometry.VTable,
Open: fn(
self: *const ID2D1PathGeometry,
geometrySink: ?*?*ID2D1GeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Stream: fn(
self: *const ID2D1PathGeometry,
geometrySink: ?*ID2D1GeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSegmentCount: fn(
self: *const ID2D1PathGeometry,
count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFigureCount: fn(
self: *const ID2D1PathGeometry,
count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Geometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PathGeometry_Open(self: *const T, geometrySink: ?*?*ID2D1GeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PathGeometry.VTable, self.vtable).Open(@ptrCast(*const ID2D1PathGeometry, self), geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PathGeometry_Stream(self: *const T, geometrySink: ?*ID2D1GeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PathGeometry.VTable, self.vtable).Stream(@ptrCast(*const ID2D1PathGeometry, self), geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PathGeometry_GetSegmentCount(self: *const T, count: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PathGeometry.VTable, self.vtable).GetSegmentCount(@ptrCast(*const ID2D1PathGeometry, self), count);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PathGeometry_GetFigureCount(self: *const T, count: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PathGeometry.VTable, self.vtable).GetFigureCount(@ptrCast(*const ID2D1PathGeometry, self), count);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Mesh_Value = @import("../zig.zig").Guid.initString("2cd906c2-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1Mesh = &IID_ID2D1Mesh_Value;
pub const ID2D1Mesh = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
Open: fn(
self: *const ID2D1Mesh,
tessellationSink: ?*?*ID2D1TessellationSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Mesh_Open(self: *const T, tessellationSink: ?*?*ID2D1TessellationSink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Mesh.VTable, self.vtable).Open(@ptrCast(*const ID2D1Mesh, self), tessellationSink);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Layer_Value = @import("../zig.zig").Guid.initString("2cd9069b-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1Layer = &IID_ID2D1Layer_Value;
pub const ID2D1Layer = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetSize: fn(
self: *const ID2D1Layer,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_F,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Layer_GetSize(self: *const T) callconv(.Inline) D2D_SIZE_F {
return @ptrCast(*const ID2D1Layer.VTable, self.vtable).GetSize(@ptrCast(*const ID2D1Layer, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1DrawingStateBlock_Value = @import("../zig.zig").Guid.initString("28506e39-ebf6-46a1-bb47-fd85565ab957");
pub const IID_ID2D1DrawingStateBlock = &IID_ID2D1DrawingStateBlock_Value;
pub const ID2D1DrawingStateBlock = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetDescription: fn(
self: *const ID2D1DrawingStateBlock,
stateDescription: ?*D2D1_DRAWING_STATE_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) void,
SetDescription: fn(
self: *const ID2D1DrawingStateBlock,
stateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) void,
SetTextRenderingParams: fn(
self: *const ID2D1DrawingStateBlock,
textRenderingParams: ?*IDWriteRenderingParams,
) callconv(@import("std").os.windows.WINAPI) void,
GetTextRenderingParams: fn(
self: *const ID2D1DrawingStateBlock,
textRenderingParams: ?*?*IDWriteRenderingParams,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock_GetDescription(self: *const T, stateDescription: ?*D2D1_DRAWING_STATE_DESCRIPTION) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock.VTable, self.vtable).GetDescription(@ptrCast(*const ID2D1DrawingStateBlock, self), stateDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock_SetDescription(self: *const T, stateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock.VTable, self.vtable).SetDescription(@ptrCast(*const ID2D1DrawingStateBlock, self), stateDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock_SetTextRenderingParams(self: *const T, textRenderingParams: ?*IDWriteRenderingParams) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock.VTable, self.vtable).SetTextRenderingParams(@ptrCast(*const ID2D1DrawingStateBlock, self), textRenderingParams);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock_GetTextRenderingParams(self: *const T, textRenderingParams: ?*?*IDWriteRenderingParams) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock.VTable, self.vtable).GetTextRenderingParams(@ptrCast(*const ID2D1DrawingStateBlock, self), textRenderingParams);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1RenderTarget_Value = @import("../zig.zig").Guid.initString("2cd90694-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1RenderTarget = &IID_ID2D1RenderTarget_Value;
pub const ID2D1RenderTarget = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
CreateBitmap: fn(
self: *const ID2D1RenderTarget,
size: D2D_SIZE_U,
srcData: ?*const anyopaque,
pitch: u32,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES,
bitmap: ?*?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBitmapFromWicBitmap: fn(
self: *const ID2D1RenderTarget,
wicBitmapSource: ?*IWICBitmapSource,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES,
bitmap: ?*?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateSharedBitmap: fn(
self: *const ID2D1RenderTarget,
riid: ?*const Guid,
data: ?*anyopaque,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES,
bitmap: ?*?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBitmapBrush: fn(
self: *const ID2D1RenderTarget,
bitmap: ?*ID2D1Bitmap,
bitmapBrushProperties: ?*const D2D1_BITMAP_BRUSH_PROPERTIES,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
bitmapBrush: ?*?*ID2D1BitmapBrush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateSolidColorBrush: fn(
self: *const ID2D1RenderTarget,
color: ?*const D2D1_COLOR_F,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
solidColorBrush: ?*?*ID2D1SolidColorBrush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGradientStopCollection: fn(
self: *const ID2D1RenderTarget,
gradientStops: [*]const D2D1_GRADIENT_STOP,
gradientStopsCount: u32,
colorInterpolationGamma: D2D1_GAMMA,
extendMode: D2D1_EXTEND_MODE,
gradientStopCollection: ?*?*ID2D1GradientStopCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateLinearGradientBrush: fn(
self: *const ID2D1RenderTarget,
linearGradientBrushProperties: ?*const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
gradientStopCollection: ?*ID2D1GradientStopCollection,
linearGradientBrush: ?*?*ID2D1LinearGradientBrush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateRadialGradientBrush: fn(
self: *const ID2D1RenderTarget,
radialGradientBrushProperties: ?*const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
gradientStopCollection: ?*ID2D1GradientStopCollection,
radialGradientBrush: ?*?*ID2D1RadialGradientBrush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCompatibleRenderTarget: fn(
self: *const ID2D1RenderTarget,
desiredSize: ?*const D2D_SIZE_F,
desiredPixelSize: ?*const D2D_SIZE_U,
desiredFormat: ?*const D2D1_PIXEL_FORMAT,
options: D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS,
bitmapRenderTarget: ?*?*ID2D1BitmapRenderTarget,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateLayer: fn(
self: *const ID2D1RenderTarget,
size: ?*const D2D_SIZE_F,
layer: ?*?*ID2D1Layer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateMesh: fn(
self: *const ID2D1RenderTarget,
mesh: ?*?*ID2D1Mesh,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawLine: fn(
self: *const ID2D1RenderTarget,
point0: D2D_POINT_2F,
point1: D2D_POINT_2F,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) void,
DrawRectangle: fn(
self: *const ID2D1RenderTarget,
rect: ?*const D2D_RECT_F,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) void,
FillRectangle: fn(
self: *const ID2D1RenderTarget,
rect: ?*const D2D_RECT_F,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
DrawRoundedRectangle: fn(
self: *const ID2D1RenderTarget,
roundedRect: ?*const D2D1_ROUNDED_RECT,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) void,
FillRoundedRectangle: fn(
self: *const ID2D1RenderTarget,
roundedRect: ?*const D2D1_ROUNDED_RECT,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
DrawEllipse: fn(
self: *const ID2D1RenderTarget,
ellipse: ?*const D2D1_ELLIPSE,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) void,
FillEllipse: fn(
self: *const ID2D1RenderTarget,
ellipse: ?*const D2D1_ELLIPSE,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
DrawGeometry: fn(
self: *const ID2D1RenderTarget,
geometry: ?*ID2D1Geometry,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) void,
FillGeometry: fn(
self: *const ID2D1RenderTarget,
geometry: ?*ID2D1Geometry,
brush: ?*ID2D1Brush,
opacityBrush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
FillMesh: fn(
self: *const ID2D1RenderTarget,
mesh: ?*ID2D1Mesh,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
FillOpacityMask: fn(
self: *const ID2D1RenderTarget,
opacityMask: ?*ID2D1Bitmap,
brush: ?*ID2D1Brush,
content: D2D1_OPACITY_MASK_CONTENT,
destinationRectangle: ?*const D2D_RECT_F,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
DrawBitmap: fn(
self: *const ID2D1RenderTarget,
bitmap: ?*ID2D1Bitmap,
destinationRectangle: ?*const D2D_RECT_F,
opacity: f32,
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
DrawText: fn(
self: *const ID2D1RenderTarget,
string: [*:0]const u16,
stringLength: u32,
textFormat: ?*IDWriteTextFormat,
layoutRect: ?*const D2D_RECT_F,
defaultFillBrush: ?*ID2D1Brush,
options: D2D1_DRAW_TEXT_OPTIONS,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
DrawTextLayout: fn(
self: *const ID2D1RenderTarget,
origin: D2D_POINT_2F,
textLayout: ?*IDWriteTextLayout,
defaultFillBrush: ?*ID2D1Brush,
options: D2D1_DRAW_TEXT_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) void,
DrawGlyphRun: fn(
self: *const ID2D1RenderTarget,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
foregroundBrush: ?*ID2D1Brush,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetTransform: fn(
self: *const ID2D1RenderTarget,
transform: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
GetTransform: fn(
self: *const ID2D1RenderTarget,
transform: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
SetAntialiasMode: fn(
self: *const ID2D1RenderTarget,
antialiasMode: D2D1_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetAntialiasMode: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D1_ANTIALIAS_MODE,
SetTextAntialiasMode: fn(
self: *const ID2D1RenderTarget,
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetTextAntialiasMode: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D1_TEXT_ANTIALIAS_MODE,
SetTextRenderingParams: fn(
self: *const ID2D1RenderTarget,
textRenderingParams: ?*IDWriteRenderingParams,
) callconv(@import("std").os.windows.WINAPI) void,
GetTextRenderingParams: fn(
self: *const ID2D1RenderTarget,
textRenderingParams: ?*?*IDWriteRenderingParams,
) callconv(@import("std").os.windows.WINAPI) void,
SetTags: fn(
self: *const ID2D1RenderTarget,
tag1: u64,
tag2: u64,
) callconv(@import("std").os.windows.WINAPI) void,
GetTags: fn(
self: *const ID2D1RenderTarget,
tag1: ?*u64,
tag2: ?*u64,
) callconv(@import("std").os.windows.WINAPI) void,
PushLayer: fn(
self: *const ID2D1RenderTarget,
layerParameters: ?*const D2D1_LAYER_PARAMETERS,
layer: ?*ID2D1Layer,
) callconv(@import("std").os.windows.WINAPI) void,
PopLayer: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) void,
Flush: fn(
self: *const ID2D1RenderTarget,
tag1: ?*u64,
tag2: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SaveDrawingState: fn(
self: *const ID2D1RenderTarget,
drawingStateBlock: ?*ID2D1DrawingStateBlock,
) callconv(@import("std").os.windows.WINAPI) void,
RestoreDrawingState: fn(
self: *const ID2D1RenderTarget,
drawingStateBlock: ?*ID2D1DrawingStateBlock,
) callconv(@import("std").os.windows.WINAPI) void,
PushAxisAlignedClip: fn(
self: *const ID2D1RenderTarget,
clipRect: ?*const D2D_RECT_F,
antialiasMode: D2D1_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
PopAxisAlignedClip: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) void,
Clear: fn(
self: *const ID2D1RenderTarget,
clearColor: ?*const D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) void,
BeginDraw: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) void,
EndDraw: fn(
self: *const ID2D1RenderTarget,
tag1: ?*u64,
tag2: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPixelFormat: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D1_PIXEL_FORMAT,
SetDpi: fn(
self: *const ID2D1RenderTarget,
dpiX: f32,
dpiY: f32,
) callconv(@import("std").os.windows.WINAPI) void,
GetDpi: fn(
self: *const ID2D1RenderTarget,
dpiX: ?*f32,
dpiY: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void,
GetSize: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_F,
GetPixelSize: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_U,
GetMaximumBitmapSize: fn(
self: *const ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) u32,
IsSupported: fn(
self: *const ID2D1RenderTarget,
renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateBitmap(self: *const T, size: D2D_SIZE_U, srcData: ?*const anyopaque, pitch: u32, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES, bitmap: ?*?*ID2D1Bitmap) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateBitmap(@ptrCast(*const ID2D1RenderTarget, self), size, srcData, pitch, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateBitmapFromWicBitmap(self: *const T, wicBitmapSource: ?*IWICBitmapSource, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES, bitmap: ?*?*ID2D1Bitmap) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateBitmapFromWicBitmap(@ptrCast(*const ID2D1RenderTarget, self), wicBitmapSource, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateSharedBitmap(self: *const T, riid: ?*const Guid, data: ?*anyopaque, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES, bitmap: ?*?*ID2D1Bitmap) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateSharedBitmap(@ptrCast(*const ID2D1RenderTarget, self), riid, data, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateBitmapBrush(self: *const T, bitmap: ?*ID2D1Bitmap, bitmapBrushProperties: ?*const D2D1_BITMAP_BRUSH_PROPERTIES, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, bitmapBrush: ?*?*ID2D1BitmapBrush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateBitmapBrush(@ptrCast(*const ID2D1RenderTarget, self), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateSolidColorBrush(self: *const T, color: ?*const D2D1_COLOR_F, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, solidColorBrush: ?*?*ID2D1SolidColorBrush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateSolidColorBrush(@ptrCast(*const ID2D1RenderTarget, self), color, brushProperties, solidColorBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateGradientStopCollection(self: *const T, gradientStops: [*]const D2D1_GRADIENT_STOP, gradientStopsCount: u32, colorInterpolationGamma: D2D1_GAMMA, extendMode: D2D1_EXTEND_MODE, gradientStopCollection: ?*?*ID2D1GradientStopCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateGradientStopCollection(@ptrCast(*const ID2D1RenderTarget, self), gradientStops, gradientStopsCount, colorInterpolationGamma, extendMode, gradientStopCollection);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateLinearGradientBrush(self: *const T, linearGradientBrushProperties: ?*const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, gradientStopCollection: ?*ID2D1GradientStopCollection, linearGradientBrush: ?*?*ID2D1LinearGradientBrush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateLinearGradientBrush(@ptrCast(*const ID2D1RenderTarget, self), linearGradientBrushProperties, brushProperties, gradientStopCollection, linearGradientBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateRadialGradientBrush(self: *const T, radialGradientBrushProperties: ?*const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, gradientStopCollection: ?*ID2D1GradientStopCollection, radialGradientBrush: ?*?*ID2D1RadialGradientBrush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateRadialGradientBrush(@ptrCast(*const ID2D1RenderTarget, self), radialGradientBrushProperties, brushProperties, gradientStopCollection, radialGradientBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateCompatibleRenderTarget(self: *const T, desiredSize: ?*const D2D_SIZE_F, desiredPixelSize: ?*const D2D_SIZE_U, desiredFormat: ?*const D2D1_PIXEL_FORMAT, options: D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS, bitmapRenderTarget: ?*?*ID2D1BitmapRenderTarget) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateCompatibleRenderTarget(@ptrCast(*const ID2D1RenderTarget, self), desiredSize, desiredPixelSize, desiredFormat, options, bitmapRenderTarget);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateLayer(self: *const T, size: ?*const D2D_SIZE_F, layer: ?*?*ID2D1Layer) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateLayer(@ptrCast(*const ID2D1RenderTarget, self), size, layer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_CreateMesh(self: *const T, mesh: ?*?*ID2D1Mesh) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).CreateMesh(@ptrCast(*const ID2D1RenderTarget, self), mesh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawLine(self: *const T, point0: D2D_POINT_2F, point1: D2D_POINT_2F, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawLine(@ptrCast(*const ID2D1RenderTarget, self), point0, point1, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawRectangle(self: *const T, rect: ?*const D2D_RECT_F, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawRectangle(@ptrCast(*const ID2D1RenderTarget, self), rect, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillRectangle(self: *const T, rect: ?*const D2D_RECT_F, brush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillRectangle(@ptrCast(*const ID2D1RenderTarget, self), rect, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawRoundedRectangle(self: *const T, roundedRect: ?*const D2D1_ROUNDED_RECT, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawRoundedRectangle(@ptrCast(*const ID2D1RenderTarget, self), roundedRect, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillRoundedRectangle(self: *const T, roundedRect: ?*const D2D1_ROUNDED_RECT, brush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillRoundedRectangle(@ptrCast(*const ID2D1RenderTarget, self), roundedRect, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawEllipse(self: *const T, ellipse: ?*const D2D1_ELLIPSE, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawEllipse(@ptrCast(*const ID2D1RenderTarget, self), ellipse, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillEllipse(self: *const T, ellipse: ?*const D2D1_ELLIPSE, brush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillEllipse(@ptrCast(*const ID2D1RenderTarget, self), ellipse, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawGeometry(self: *const T, geometry: ?*ID2D1Geometry, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawGeometry(@ptrCast(*const ID2D1RenderTarget, self), geometry, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillGeometry(self: *const T, geometry: ?*ID2D1Geometry, brush: ?*ID2D1Brush, opacityBrush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillGeometry(@ptrCast(*const ID2D1RenderTarget, self), geometry, brush, opacityBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillMesh(self: *const T, mesh: ?*ID2D1Mesh, brush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillMesh(@ptrCast(*const ID2D1RenderTarget, self), mesh, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_FillOpacityMask(self: *const T, opacityMask: ?*ID2D1Bitmap, brush: ?*ID2D1Brush, content: D2D1_OPACITY_MASK_CONTENT, destinationRectangle: ?*const D2D_RECT_F, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).FillOpacityMask(@ptrCast(*const ID2D1RenderTarget, self), opacityMask, brush, content, destinationRectangle, sourceRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawBitmap(self: *const T, bitmap: ?*ID2D1Bitmap, destinationRectangle: ?*const D2D_RECT_F, opacity: f32, interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawBitmap(@ptrCast(*const ID2D1RenderTarget, self), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawText(self: *const T, string: [*:0]const u16, stringLength: u32, textFormat: ?*IDWriteTextFormat, layoutRect: ?*const D2D_RECT_F, defaultFillBrush: ?*ID2D1Brush, options: D2D1_DRAW_TEXT_OPTIONS, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawText(@ptrCast(*const ID2D1RenderTarget, self), string, stringLength, textFormat, layoutRect, defaultFillBrush, options, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawTextLayout(self: *const T, origin: D2D_POINT_2F, textLayout: ?*IDWriteTextLayout, defaultFillBrush: ?*ID2D1Brush, options: D2D1_DRAW_TEXT_OPTIONS) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawTextLayout(@ptrCast(*const ID2D1RenderTarget, self), origin, textLayout, defaultFillBrush, options);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_DrawGlyphRun(self: *const T, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, foregroundBrush: ?*ID2D1Brush, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).DrawGlyphRun(@ptrCast(*const ID2D1RenderTarget, self), baselineOrigin, glyphRun, foregroundBrush, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetTransform(self: *const T, transform: ?*const D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetTransform(@ptrCast(*const ID2D1RenderTarget, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetTransform(self: *const T, transform: ?*D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetTransform(@ptrCast(*const ID2D1RenderTarget, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetAntialiasMode(self: *const T, antialiasMode: D2D1_ANTIALIAS_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetAntialiasMode(@ptrCast(*const ID2D1RenderTarget, self), antialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetAntialiasMode(self: *const T) callconv(.Inline) D2D1_ANTIALIAS_MODE {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetAntialiasMode(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetTextAntialiasMode(self: *const T, textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetTextAntialiasMode(@ptrCast(*const ID2D1RenderTarget, self), textAntialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetTextAntialiasMode(self: *const T) callconv(.Inline) D2D1_TEXT_ANTIALIAS_MODE {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetTextAntialiasMode(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetTextRenderingParams(self: *const T, textRenderingParams: ?*IDWriteRenderingParams) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetTextRenderingParams(@ptrCast(*const ID2D1RenderTarget, self), textRenderingParams);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetTextRenderingParams(self: *const T, textRenderingParams: ?*?*IDWriteRenderingParams) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetTextRenderingParams(@ptrCast(*const ID2D1RenderTarget, self), textRenderingParams);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetTags(self: *const T, tag1: u64, tag2: u64) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetTags(@ptrCast(*const ID2D1RenderTarget, self), tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetTags(self: *const T, tag1: ?*u64, tag2: ?*u64) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetTags(@ptrCast(*const ID2D1RenderTarget, self), tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_PushLayer(self: *const T, layerParameters: ?*const D2D1_LAYER_PARAMETERS, layer: ?*ID2D1Layer) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).PushLayer(@ptrCast(*const ID2D1RenderTarget, self), layerParameters, layer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_PopLayer(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).PopLayer(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_Flush(self: *const T, tag1: ?*u64, tag2: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).Flush(@ptrCast(*const ID2D1RenderTarget, self), tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SaveDrawingState(self: *const T, drawingStateBlock: ?*ID2D1DrawingStateBlock) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SaveDrawingState(@ptrCast(*const ID2D1RenderTarget, self), drawingStateBlock);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_RestoreDrawingState(self: *const T, drawingStateBlock: ?*ID2D1DrawingStateBlock) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).RestoreDrawingState(@ptrCast(*const ID2D1RenderTarget, self), drawingStateBlock);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_PushAxisAlignedClip(self: *const T, clipRect: ?*const D2D_RECT_F, antialiasMode: D2D1_ANTIALIAS_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).PushAxisAlignedClip(@ptrCast(*const ID2D1RenderTarget, self), clipRect, antialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_PopAxisAlignedClip(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).PopAxisAlignedClip(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_Clear(self: *const T, clearColor: ?*const D2D1_COLOR_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).Clear(@ptrCast(*const ID2D1RenderTarget, self), clearColor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_BeginDraw(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).BeginDraw(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_EndDraw(self: *const T, tag1: ?*u64, tag2: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).EndDraw(@ptrCast(*const ID2D1RenderTarget, self), tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetPixelFormat(self: *const T) callconv(.Inline) D2D1_PIXEL_FORMAT {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetPixelFormat(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_SetDpi(self: *const T, dpiX: f32, dpiY: f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).SetDpi(@ptrCast(*const ID2D1RenderTarget, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetDpi(self: *const T, dpiX: ?*f32, dpiY: ?*f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetDpi(@ptrCast(*const ID2D1RenderTarget, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetSize(self: *const T) callconv(.Inline) D2D_SIZE_F {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetSize(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetPixelSize(self: *const T) callconv(.Inline) D2D_SIZE_U {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetPixelSize(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_GetMaximumBitmapSize(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).GetMaximumBitmapSize(@ptrCast(*const ID2D1RenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderTarget_IsSupported(self: *const T, renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1RenderTarget.VTable, self.vtable).IsSupported(@ptrCast(*const ID2D1RenderTarget, self), renderTargetProperties);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1BitmapRenderTarget_Value = @import("../zig.zig").Guid.initString("2cd90695-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1BitmapRenderTarget = &IID_ID2D1BitmapRenderTarget_Value;
pub const ID2D1BitmapRenderTarget = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderTarget.VTable,
GetBitmap: fn(
self: *const ID2D1BitmapRenderTarget,
bitmap: ?*?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderTarget.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapRenderTarget_GetBitmap(self: *const T, bitmap: ?*?*ID2D1Bitmap) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1BitmapRenderTarget.VTable, self.vtable).GetBitmap(@ptrCast(*const ID2D1BitmapRenderTarget, self), bitmap);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1HwndRenderTarget_Value = @import("../zig.zig").Guid.initString("2cd90698-12e2-11dc-9fed-001143a055f9");
pub const IID_ID2D1HwndRenderTarget = &IID_ID2D1HwndRenderTarget_Value;
pub const ID2D1HwndRenderTarget = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderTarget.VTable,
CheckWindowState: fn(
self: *const ID2D1HwndRenderTarget,
) callconv(@import("std").os.windows.WINAPI) D2D1_WINDOW_STATE,
Resize: fn(
self: *const ID2D1HwndRenderTarget,
pixelSize: ?*const D2D_SIZE_U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetHwnd: fn(
self: *const ID2D1HwndRenderTarget,
) callconv(@import("std").os.windows.WINAPI) ?HWND,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderTarget.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1HwndRenderTarget_CheckWindowState(self: *const T) callconv(.Inline) D2D1_WINDOW_STATE {
return @ptrCast(*const ID2D1HwndRenderTarget.VTable, self.vtable).CheckWindowState(@ptrCast(*const ID2D1HwndRenderTarget, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1HwndRenderTarget_Resize(self: *const T, pixelSize: ?*const D2D_SIZE_U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1HwndRenderTarget.VTable, self.vtable).Resize(@ptrCast(*const ID2D1HwndRenderTarget, self), pixelSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1HwndRenderTarget_GetHwnd(self: *const T) callconv(.Inline) ?HWND {
return @ptrCast(*const ID2D1HwndRenderTarget.VTable, self.vtable).GetHwnd(@ptrCast(*const ID2D1HwndRenderTarget, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1GdiInteropRenderTarget_Value = @import("../zig.zig").Guid.initString("e0db51c3-6f77-4bae-b3d5-e47509b35838");
pub const IID_ID2D1GdiInteropRenderTarget = &IID_ID2D1GdiInteropRenderTarget_Value;
pub const ID2D1GdiInteropRenderTarget = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDC: fn(
self: *const ID2D1GdiInteropRenderTarget,
mode: D2D1_DC_INITIALIZE_MODE,
hdc: ?*?HDC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseDC: fn(
self: *const ID2D1GdiInteropRenderTarget,
update: ?*const RECT,
) 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 ID2D1GdiInteropRenderTarget_GetDC(self: *const T, mode: D2D1_DC_INITIALIZE_MODE, hdc: ?*?HDC) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiInteropRenderTarget.VTable, self.vtable).GetDC(@ptrCast(*const ID2D1GdiInteropRenderTarget, self), mode, hdc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiInteropRenderTarget_ReleaseDC(self: *const T, update: ?*const RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiInteropRenderTarget.VTable, self.vtable).ReleaseDC(@ptrCast(*const ID2D1GdiInteropRenderTarget, self), update);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1DCRenderTarget_Value = @import("../zig.zig").Guid.initString("1c51bc64-de61-46fd-9899-63a5d8f03950");
pub const IID_ID2D1DCRenderTarget = &IID_ID2D1DCRenderTarget_Value;
pub const ID2D1DCRenderTarget = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderTarget.VTable,
BindDC: fn(
self: *const ID2D1DCRenderTarget,
hDC: ?HDC,
pSubRect: ?*const RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderTarget.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DCRenderTarget_BindDC(self: *const T, hDC: ?HDC, pSubRect: ?*const RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DCRenderTarget.VTable, self.vtable).BindDC(@ptrCast(*const ID2D1DCRenderTarget, self), hDC, pSubRect);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.1'
const IID_ID2D1Factory_Value = @import("../zig.zig").Guid.initString("06152247-6f50-465a-9245-118bfd3b6007");
pub const IID_ID2D1Factory = &IID_ID2D1Factory_Value;
pub const ID2D1Factory = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ReloadSystemMetrics: fn(
self: *const ID2D1Factory,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDesktopDpi: fn(
self: *const ID2D1Factory,
dpiX: ?*f32,
dpiY: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void,
CreateRectangleGeometry: fn(
self: *const ID2D1Factory,
rectangle: ?*const D2D_RECT_F,
rectangleGeometry: ?*?*ID2D1RectangleGeometry,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateRoundedRectangleGeometry: fn(
self: *const ID2D1Factory,
roundedRectangle: ?*const D2D1_ROUNDED_RECT,
roundedRectangleGeometry: ?*?*ID2D1RoundedRectangleGeometry,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateEllipseGeometry: fn(
self: *const ID2D1Factory,
ellipse: ?*const D2D1_ELLIPSE,
ellipseGeometry: ?*?*ID2D1EllipseGeometry,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGeometryGroup: fn(
self: *const ID2D1Factory,
fillMode: D2D1_FILL_MODE,
geometries: [*]?*ID2D1Geometry,
geometriesCount: u32,
geometryGroup: ?*?*ID2D1GeometryGroup,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateTransformedGeometry: fn(
self: *const ID2D1Factory,
sourceGeometry: ?*ID2D1Geometry,
transform: ?*const D2D_MATRIX_3X2_F,
transformedGeometry: ?*?*ID2D1TransformedGeometry,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePathGeometry: fn(
self: *const ID2D1Factory,
pathGeometry: ?*?*ID2D1PathGeometry,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStrokeStyle: fn(
self: *const ID2D1Factory,
strokeStyleProperties: ?*const D2D1_STROKE_STYLE_PROPERTIES,
dashes: ?[*]const f32,
dashesCount: u32,
strokeStyle: ?*?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateDrawingStateBlock: fn(
self: *const ID2D1Factory,
drawingStateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION,
textRenderingParams: ?*IDWriteRenderingParams,
drawingStateBlock: ?*?*ID2D1DrawingStateBlock,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateWicBitmapRenderTarget: fn(
self: *const ID2D1Factory,
target: ?*IWICBitmap,
renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES,
renderTarget: ?*?*ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateHwndRenderTarget: fn(
self: *const ID2D1Factory,
renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES,
hwndRenderTargetProperties: ?*const D2D1_HWND_RENDER_TARGET_PROPERTIES,
hwndRenderTarget: ?*?*ID2D1HwndRenderTarget,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateDxgiSurfaceRenderTarget: fn(
self: *const ID2D1Factory,
dxgiSurface: ?*IDXGISurface,
renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES,
renderTarget: ?*?*ID2D1RenderTarget,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateDCRenderTarget: fn(
self: *const ID2D1Factory,
renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES,
dcRenderTarget: ?*?*ID2D1DCRenderTarget,
) 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 ID2D1Factory_ReloadSystemMetrics(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).ReloadSystemMetrics(@ptrCast(*const ID2D1Factory, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_GetDesktopDpi(self: *const T, dpiX: ?*f32, dpiY: ?*f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).GetDesktopDpi(@ptrCast(*const ID2D1Factory, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateRectangleGeometry(self: *const T, rectangle: ?*const D2D_RECT_F, rectangleGeometry: ?*?*ID2D1RectangleGeometry) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateRectangleGeometry(@ptrCast(*const ID2D1Factory, self), rectangle, rectangleGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateRoundedRectangleGeometry(self: *const T, roundedRectangle: ?*const D2D1_ROUNDED_RECT, roundedRectangleGeometry: ?*?*ID2D1RoundedRectangleGeometry) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateRoundedRectangleGeometry(@ptrCast(*const ID2D1Factory, self), roundedRectangle, roundedRectangleGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateEllipseGeometry(self: *const T, ellipse: ?*const D2D1_ELLIPSE, ellipseGeometry: ?*?*ID2D1EllipseGeometry) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateEllipseGeometry(@ptrCast(*const ID2D1Factory, self), ellipse, ellipseGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateGeometryGroup(self: *const T, fillMode: D2D1_FILL_MODE, geometries: [*]?*ID2D1Geometry, geometriesCount: u32, geometryGroup: ?*?*ID2D1GeometryGroup) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateGeometryGroup(@ptrCast(*const ID2D1Factory, self), fillMode, geometries, geometriesCount, geometryGroup);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateTransformedGeometry(self: *const T, sourceGeometry: ?*ID2D1Geometry, transform: ?*const D2D_MATRIX_3X2_F, transformedGeometry: ?*?*ID2D1TransformedGeometry) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateTransformedGeometry(@ptrCast(*const ID2D1Factory, self), sourceGeometry, transform, transformedGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreatePathGeometry(self: *const T, pathGeometry: ?*?*ID2D1PathGeometry) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreatePathGeometry(@ptrCast(*const ID2D1Factory, self), pathGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateStrokeStyle(self: *const T, strokeStyleProperties: ?*const D2D1_STROKE_STYLE_PROPERTIES, dashes: ?[*]const f32, dashesCount: u32, strokeStyle: ?*?*ID2D1StrokeStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateStrokeStyle(@ptrCast(*const ID2D1Factory, self), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateDrawingStateBlock(self: *const T, drawingStateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION, textRenderingParams: ?*IDWriteRenderingParams, drawingStateBlock: ?*?*ID2D1DrawingStateBlock) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateDrawingStateBlock(@ptrCast(*const ID2D1Factory, self), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateWicBitmapRenderTarget(self: *const T, target: ?*IWICBitmap, renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES, renderTarget: ?*?*ID2D1RenderTarget) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateWicBitmapRenderTarget(@ptrCast(*const ID2D1Factory, self), target, renderTargetProperties, renderTarget);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateHwndRenderTarget(self: *const T, renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES, hwndRenderTargetProperties: ?*const D2D1_HWND_RENDER_TARGET_PROPERTIES, hwndRenderTarget: ?*?*ID2D1HwndRenderTarget) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateHwndRenderTarget(@ptrCast(*const ID2D1Factory, self), renderTargetProperties, hwndRenderTargetProperties, hwndRenderTarget);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateDxgiSurfaceRenderTarget(self: *const T, dxgiSurface: ?*IDXGISurface, renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES, renderTarget: ?*?*ID2D1RenderTarget) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateDxgiSurfaceRenderTarget(@ptrCast(*const ID2D1Factory, self), dxgiSurface, renderTargetProperties, renderTarget);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory_CreateDCRenderTarget(self: *const T, renderTargetProperties: ?*const D2D1_RENDER_TARGET_PROPERTIES, dcRenderTarget: ?*?*ID2D1DCRenderTarget) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory.VTable, self.vtable).CreateDCRenderTarget(@ptrCast(*const ID2D1Factory, self), renderTargetProperties, dcRenderTarget);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D2D1_CHANNEL_SELECTOR = enum(u32) {
R = 0,
G = 1,
B = 2,
A = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CHANNEL_SELECTOR_R = D2D1_CHANNEL_SELECTOR.R;
pub const D2D1_CHANNEL_SELECTOR_G = D2D1_CHANNEL_SELECTOR.G;
pub const D2D1_CHANNEL_SELECTOR_B = D2D1_CHANNEL_SELECTOR.B;
pub const D2D1_CHANNEL_SELECTOR_A = D2D1_CHANNEL_SELECTOR.A;
pub const D2D1_CHANNEL_SELECTOR_FORCE_DWORD = D2D1_CHANNEL_SELECTOR.FORCE_DWORD;
pub const D2D1_BITMAPSOURCE_ORIENTATION = enum(u32) {
DEFAULT = 1,
FLIP_HORIZONTAL = 2,
ROTATE_CLOCKWISE180 = 3,
ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = 4,
ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = 5,
ROTATE_CLOCKWISE90 = 6,
ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = 7,
ROTATE_CLOCKWISE270 = 8,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BITMAPSOURCE_ORIENTATION_DEFAULT = D2D1_BITMAPSOURCE_ORIENTATION.DEFAULT;
pub const D2D1_BITMAPSOURCE_ORIENTATION_FLIP_HORIZONTAL = D2D1_BITMAPSOURCE_ORIENTATION.FLIP_HORIZONTAL;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180 = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE180;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE180_FLIP_HORIZONTAL;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE270_FLIP_HORIZONTAL;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90 = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE90;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE90_FLIP_HORIZONTAL;
pub const D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270 = D2D1_BITMAPSOURCE_ORIENTATION.ROTATE_CLOCKWISE270;
pub const D2D1_BITMAPSOURCE_ORIENTATION_FORCE_DWORD = D2D1_BITMAPSOURCE_ORIENTATION.FORCE_DWORD;
pub const D2D1_GAUSSIANBLUR_PROP = enum(u32) {
STANDARD_DEVIATION = 0,
OPTIMIZATION = 1,
BORDER_MODE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION = D2D1_GAUSSIANBLUR_PROP.STANDARD_DEVIATION;
pub const D2D1_GAUSSIANBLUR_PROP_OPTIMIZATION = D2D1_GAUSSIANBLUR_PROP.OPTIMIZATION;
pub const D2D1_GAUSSIANBLUR_PROP_BORDER_MODE = D2D1_GAUSSIANBLUR_PROP.BORDER_MODE;
pub const D2D1_GAUSSIANBLUR_PROP_FORCE_DWORD = D2D1_GAUSSIANBLUR_PROP.FORCE_DWORD;
pub const D2D1_GAUSSIANBLUR_OPTIMIZATION = enum(u32) {
SPEED = 0,
BALANCED = 1,
QUALITY = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GAUSSIANBLUR_OPTIMIZATION_SPEED = D2D1_GAUSSIANBLUR_OPTIMIZATION.SPEED;
pub const D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED = D2D1_GAUSSIANBLUR_OPTIMIZATION.BALANCED;
pub const D2D1_GAUSSIANBLUR_OPTIMIZATION_QUALITY = D2D1_GAUSSIANBLUR_OPTIMIZATION.QUALITY;
pub const D2D1_GAUSSIANBLUR_OPTIMIZATION_FORCE_DWORD = D2D1_GAUSSIANBLUR_OPTIMIZATION.FORCE_DWORD;
pub const D2D1_DIRECTIONALBLUR_PROP = enum(u32) {
STANDARD_DEVIATION = 0,
ANGLE = 1,
OPTIMIZATION = 2,
BORDER_MODE = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DIRECTIONALBLUR_PROP_STANDARD_DEVIATION = D2D1_DIRECTIONALBLUR_PROP.STANDARD_DEVIATION;
pub const D2D1_DIRECTIONALBLUR_PROP_ANGLE = D2D1_DIRECTIONALBLUR_PROP.ANGLE;
pub const D2D1_DIRECTIONALBLUR_PROP_OPTIMIZATION = D2D1_DIRECTIONALBLUR_PROP.OPTIMIZATION;
pub const D2D1_DIRECTIONALBLUR_PROP_BORDER_MODE = D2D1_DIRECTIONALBLUR_PROP.BORDER_MODE;
pub const D2D1_DIRECTIONALBLUR_PROP_FORCE_DWORD = D2D1_DIRECTIONALBLUR_PROP.FORCE_DWORD;
pub const D2D1_DIRECTIONALBLUR_OPTIMIZATION = enum(u32) {
SPEED = 0,
BALANCED = 1,
QUALITY = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DIRECTIONALBLUR_OPTIMIZATION_SPEED = D2D1_DIRECTIONALBLUR_OPTIMIZATION.SPEED;
pub const D2D1_DIRECTIONALBLUR_OPTIMIZATION_BALANCED = D2D1_DIRECTIONALBLUR_OPTIMIZATION.BALANCED;
pub const D2D1_DIRECTIONALBLUR_OPTIMIZATION_QUALITY = D2D1_DIRECTIONALBLUR_OPTIMIZATION.QUALITY;
pub const D2D1_DIRECTIONALBLUR_OPTIMIZATION_FORCE_DWORD = D2D1_DIRECTIONALBLUR_OPTIMIZATION.FORCE_DWORD;
pub const D2D1_SHADOW_PROP = enum(u32) {
BLUR_STANDARD_DEVIATION = 0,
COLOR = 1,
OPTIMIZATION = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION = D2D1_SHADOW_PROP.BLUR_STANDARD_DEVIATION;
pub const D2D1_SHADOW_PROP_COLOR = D2D1_SHADOW_PROP.COLOR;
pub const D2D1_SHADOW_PROP_OPTIMIZATION = D2D1_SHADOW_PROP.OPTIMIZATION;
pub const D2D1_SHADOW_PROP_FORCE_DWORD = D2D1_SHADOW_PROP.FORCE_DWORD;
pub const D2D1_SHADOW_OPTIMIZATION = enum(u32) {
SPEED = 0,
BALANCED = 1,
QUALITY = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SHADOW_OPTIMIZATION_SPEED = D2D1_SHADOW_OPTIMIZATION.SPEED;
pub const D2D1_SHADOW_OPTIMIZATION_BALANCED = D2D1_SHADOW_OPTIMIZATION.BALANCED;
pub const D2D1_SHADOW_OPTIMIZATION_QUALITY = D2D1_SHADOW_OPTIMIZATION.QUALITY;
pub const D2D1_SHADOW_OPTIMIZATION_FORCE_DWORD = D2D1_SHADOW_OPTIMIZATION.FORCE_DWORD;
pub const D2D1_BLEND_PROP = enum(u32) {
MODE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BLEND_PROP_MODE = D2D1_BLEND_PROP.MODE;
pub const D2D1_BLEND_PROP_FORCE_DWORD = D2D1_BLEND_PROP.FORCE_DWORD;
pub const D2D1_SATURATION_PROP = enum(u32) {
SATURATION = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SATURATION_PROP_SATURATION = D2D1_SATURATION_PROP.SATURATION;
pub const D2D1_SATURATION_PROP_FORCE_DWORD = D2D1_SATURATION_PROP.FORCE_DWORD;
pub const D2D1_HUEROTATION_PROP = enum(u32) {
ANGLE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HUEROTATION_PROP_ANGLE = D2D1_HUEROTATION_PROP.ANGLE;
pub const D2D1_HUEROTATION_PROP_FORCE_DWORD = D2D1_HUEROTATION_PROP.FORCE_DWORD;
pub const D2D1_COLORMATRIX_PROP = enum(u32) {
COLOR_MATRIX = 0,
ALPHA_MODE = 1,
CLAMP_OUTPUT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLORMATRIX_PROP_COLOR_MATRIX = D2D1_COLORMATRIX_PROP.COLOR_MATRIX;
pub const D2D1_COLORMATRIX_PROP_ALPHA_MODE = D2D1_COLORMATRIX_PROP.ALPHA_MODE;
pub const D2D1_COLORMATRIX_PROP_CLAMP_OUTPUT = D2D1_COLORMATRIX_PROP.CLAMP_OUTPUT;
pub const D2D1_COLORMATRIX_PROP_FORCE_DWORD = D2D1_COLORMATRIX_PROP.FORCE_DWORD;
pub const D2D1_BITMAPSOURCE_PROP = enum(u32) {
WIC_BITMAP_SOURCE = 0,
SCALE = 1,
INTERPOLATION_MODE = 2,
ENABLE_DPI_CORRECTION = 3,
ALPHA_MODE = 4,
ORIENTATION = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE = D2D1_BITMAPSOURCE_PROP.WIC_BITMAP_SOURCE;
pub const D2D1_BITMAPSOURCE_PROP_SCALE = D2D1_BITMAPSOURCE_PROP.SCALE;
pub const D2D1_BITMAPSOURCE_PROP_INTERPOLATION_MODE = D2D1_BITMAPSOURCE_PROP.INTERPOLATION_MODE;
pub const D2D1_BITMAPSOURCE_PROP_ENABLE_DPI_CORRECTION = D2D1_BITMAPSOURCE_PROP.ENABLE_DPI_CORRECTION;
pub const D2D1_BITMAPSOURCE_PROP_ALPHA_MODE = D2D1_BITMAPSOURCE_PROP.ALPHA_MODE;
pub const D2D1_BITMAPSOURCE_PROP_ORIENTATION = D2D1_BITMAPSOURCE_PROP.ORIENTATION;
pub const D2D1_BITMAPSOURCE_PROP_FORCE_DWORD = D2D1_BITMAPSOURCE_PROP.FORCE_DWORD;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
FANT = 6,
MIPMAP_LINEAR = 7,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_LINEAR = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.LINEAR;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_CUBIC = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.CUBIC;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_FANT = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.FANT;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_MIPMAP_LINEAR = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.MIPMAP_LINEAR;
pub const D2D1_BITMAPSOURCE_INTERPOLATION_MODE_FORCE_DWORD = D2D1_BITMAPSOURCE_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_BITMAPSOURCE_ALPHA_MODE = enum(u32) {
PREMULTIPLIED = 1,
STRAIGHT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BITMAPSOURCE_ALPHA_MODE_PREMULTIPLIED = D2D1_BITMAPSOURCE_ALPHA_MODE.PREMULTIPLIED;
pub const D2D1_BITMAPSOURCE_ALPHA_MODE_STRAIGHT = D2D1_BITMAPSOURCE_ALPHA_MODE.STRAIGHT;
pub const D2D1_BITMAPSOURCE_ALPHA_MODE_FORCE_DWORD = D2D1_BITMAPSOURCE_ALPHA_MODE.FORCE_DWORD;
pub const D2D1_COMPOSITE_PROP = enum(u32) {
MODE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COMPOSITE_PROP_MODE = D2D1_COMPOSITE_PROP.MODE;
pub const D2D1_COMPOSITE_PROP_FORCE_DWORD = D2D1_COMPOSITE_PROP.FORCE_DWORD;
pub const D2D1_3DTRANSFORM_PROP = enum(u32) {
INTERPOLATION_MODE = 0,
BORDER_MODE = 1,
TRANSFORM_MATRIX = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_3DTRANSFORM_PROP_INTERPOLATION_MODE = D2D1_3DTRANSFORM_PROP.INTERPOLATION_MODE;
pub const D2D1_3DTRANSFORM_PROP_BORDER_MODE = D2D1_3DTRANSFORM_PROP.BORDER_MODE;
pub const D2D1_3DTRANSFORM_PROP_TRANSFORM_MATRIX = D2D1_3DTRANSFORM_PROP.TRANSFORM_MATRIX;
pub const D2D1_3DTRANSFORM_PROP_FORCE_DWORD = D2D1_3DTRANSFORM_PROP.FORCE_DWORD;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_3DTRANSFORM_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_LINEAR = D2D1_3DTRANSFORM_INTERPOLATION_MODE.LINEAR;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_CUBIC = D2D1_3DTRANSFORM_INTERPOLATION_MODE.CUBIC;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_3DTRANSFORM_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = D2D1_3DTRANSFORM_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_3DTRANSFORM_INTERPOLATION_MODE_FORCE_DWORD = D2D1_3DTRANSFORM_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP = enum(u32) {
INTERPOLATION_MODE = 0,
BORDER_MODE = 1,
DEPTH = 2,
PERSPECTIVE_ORIGIN = 3,
LOCAL_OFFSET = 4,
GLOBAL_OFFSET = 5,
ROTATION_ORIGIN = 6,
ROTATION = 7,
FORCE_DWORD = 4294967295,
};
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_INTERPOLATION_MODE = D2D1_3DPERSPECTIVETRANSFORM_PROP.INTERPOLATION_MODE;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_BORDER_MODE = D2D1_3DPERSPECTIVETRANSFORM_PROP.BORDER_MODE;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_DEPTH = D2D1_3DPERSPECTIVETRANSFORM_PROP.DEPTH;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_PERSPECTIVE_ORIGIN = D2D1_3DPERSPECTIVETRANSFORM_PROP.PERSPECTIVE_ORIGIN;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_LOCAL_OFFSET = D2D1_3DPERSPECTIVETRANSFORM_PROP.LOCAL_OFFSET;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_GLOBAL_OFFSET = D2D1_3DPERSPECTIVETRANSFORM_PROP.GLOBAL_OFFSET;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION_ORIGIN = D2D1_3DPERSPECTIVETRANSFORM_PROP.ROTATION_ORIGIN;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION = D2D1_3DPERSPECTIVETRANSFORM_PROP.ROTATION;
pub const D2D1_3DPERSPECTIVETRANSFORM_PROP_FORCE_DWORD = D2D1_3DPERSPECTIVETRANSFORM_PROP.FORCE_DWORD;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.LINEAR;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_CUBIC = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.CUBIC;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_FORCE_DWORD = D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_2DAFFINETRANSFORM_PROP = enum(u32) {
INTERPOLATION_MODE = 0,
BORDER_MODE = 1,
TRANSFORM_MATRIX = 2,
SHARPNESS = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE = D2D1_2DAFFINETRANSFORM_PROP.INTERPOLATION_MODE;
pub const D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE = D2D1_2DAFFINETRANSFORM_PROP.BORDER_MODE;
pub const D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX = D2D1_2DAFFINETRANSFORM_PROP.TRANSFORM_MATRIX;
pub const D2D1_2DAFFINETRANSFORM_PROP_SHARPNESS = D2D1_2DAFFINETRANSFORM_PROP.SHARPNESS;
pub const D2D1_2DAFFINETRANSFORM_PROP_FORCE_DWORD = D2D1_2DAFFINETRANSFORM_PROP.FORCE_DWORD;
pub const D2D1_DPICOMPENSATION_PROP = enum(u32) {
INTERPOLATION_MODE = 0,
BORDER_MODE = 1,
INPUT_DPI = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DPICOMPENSATION_PROP_INTERPOLATION_MODE = D2D1_DPICOMPENSATION_PROP.INTERPOLATION_MODE;
pub const D2D1_DPICOMPENSATION_PROP_BORDER_MODE = D2D1_DPICOMPENSATION_PROP.BORDER_MODE;
pub const D2D1_DPICOMPENSATION_PROP_INPUT_DPI = D2D1_DPICOMPENSATION_PROP.INPUT_DPI;
pub const D2D1_DPICOMPENSATION_PROP_FORCE_DWORD = D2D1_DPICOMPENSATION_PROP.FORCE_DWORD;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_LINEAR = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.LINEAR;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_CUBIC = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.CUBIC;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_ANISOTROPIC = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_DPICOMPENSATION_INTERPOLATION_MODE_FORCE_DWORD = D2D1_DPICOMPENSATION_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_SCALE_PROP = enum(u32) {
SCALE = 0,
CENTER_POINT = 1,
INTERPOLATION_MODE = 2,
BORDER_MODE = 3,
SHARPNESS = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SCALE_PROP_SCALE = D2D1_SCALE_PROP.SCALE;
pub const D2D1_SCALE_PROP_CENTER_POINT = D2D1_SCALE_PROP.CENTER_POINT;
pub const D2D1_SCALE_PROP_INTERPOLATION_MODE = D2D1_SCALE_PROP.INTERPOLATION_MODE;
pub const D2D1_SCALE_PROP_BORDER_MODE = D2D1_SCALE_PROP.BORDER_MODE;
pub const D2D1_SCALE_PROP_SHARPNESS = D2D1_SCALE_PROP.SHARPNESS;
pub const D2D1_SCALE_PROP_FORCE_DWORD = D2D1_SCALE_PROP.FORCE_DWORD;
pub const D2D1_SCALE_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SCALE_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_SCALE_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_SCALE_INTERPOLATION_MODE_LINEAR = D2D1_SCALE_INTERPOLATION_MODE.LINEAR;
pub const D2D1_SCALE_INTERPOLATION_MODE_CUBIC = D2D1_SCALE_INTERPOLATION_MODE.CUBIC;
pub const D2D1_SCALE_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_SCALE_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_SCALE_INTERPOLATION_MODE_ANISOTROPIC = D2D1_SCALE_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_SCALE_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_SCALE_INTERPOLATION_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_SCALE_INTERPOLATION_MODE_FORCE_DWORD = D2D1_SCALE_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_TURBULENCE_PROP = enum(u32) {
OFFSET = 0,
SIZE = 1,
BASE_FREQUENCY = 2,
NUM_OCTAVES = 3,
SEED = 4,
NOISE = 5,
STITCHABLE = 6,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TURBULENCE_PROP_OFFSET = D2D1_TURBULENCE_PROP.OFFSET;
pub const D2D1_TURBULENCE_PROP_SIZE = D2D1_TURBULENCE_PROP.SIZE;
pub const D2D1_TURBULENCE_PROP_BASE_FREQUENCY = D2D1_TURBULENCE_PROP.BASE_FREQUENCY;
pub const D2D1_TURBULENCE_PROP_NUM_OCTAVES = D2D1_TURBULENCE_PROP.NUM_OCTAVES;
pub const D2D1_TURBULENCE_PROP_SEED = D2D1_TURBULENCE_PROP.SEED;
pub const D2D1_TURBULENCE_PROP_NOISE = D2D1_TURBULENCE_PROP.NOISE;
pub const D2D1_TURBULENCE_PROP_STITCHABLE = D2D1_TURBULENCE_PROP.STITCHABLE;
pub const D2D1_TURBULENCE_PROP_FORCE_DWORD = D2D1_TURBULENCE_PROP.FORCE_DWORD;
pub const D2D1_DISPLACEMENTMAP_PROP = enum(u32) {
SCALE = 0,
X_CHANNEL_SELECT = 1,
Y_CHANNEL_SELECT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISPLACEMENTMAP_PROP_SCALE = D2D1_DISPLACEMENTMAP_PROP.SCALE;
pub const D2D1_DISPLACEMENTMAP_PROP_X_CHANNEL_SELECT = D2D1_DISPLACEMENTMAP_PROP.X_CHANNEL_SELECT;
pub const D2D1_DISPLACEMENTMAP_PROP_Y_CHANNEL_SELECT = D2D1_DISPLACEMENTMAP_PROP.Y_CHANNEL_SELECT;
pub const D2D1_DISPLACEMENTMAP_PROP_FORCE_DWORD = D2D1_DISPLACEMENTMAP_PROP.FORCE_DWORD;
pub const D2D1_COLORMANAGEMENT_PROP = enum(u32) {
SOURCE_COLOR_CONTEXT = 0,
SOURCE_RENDERING_INTENT = 1,
DESTINATION_COLOR_CONTEXT = 2,
DESTINATION_RENDERING_INTENT = 3,
ALPHA_MODE = 4,
QUALITY = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLORMANAGEMENT_PROP_SOURCE_COLOR_CONTEXT = D2D1_COLORMANAGEMENT_PROP.SOURCE_COLOR_CONTEXT;
pub const D2D1_COLORMANAGEMENT_PROP_SOURCE_RENDERING_INTENT = D2D1_COLORMANAGEMENT_PROP.SOURCE_RENDERING_INTENT;
pub const D2D1_COLORMANAGEMENT_PROP_DESTINATION_COLOR_CONTEXT = D2D1_COLORMANAGEMENT_PROP.DESTINATION_COLOR_CONTEXT;
pub const D2D1_COLORMANAGEMENT_PROP_DESTINATION_RENDERING_INTENT = D2D1_COLORMANAGEMENT_PROP.DESTINATION_RENDERING_INTENT;
pub const D2D1_COLORMANAGEMENT_PROP_ALPHA_MODE = D2D1_COLORMANAGEMENT_PROP.ALPHA_MODE;
pub const D2D1_COLORMANAGEMENT_PROP_QUALITY = D2D1_COLORMANAGEMENT_PROP.QUALITY;
pub const D2D1_COLORMANAGEMENT_PROP_FORCE_DWORD = D2D1_COLORMANAGEMENT_PROP.FORCE_DWORD;
pub const D2D1_COLORMANAGEMENT_ALPHA_MODE = enum(u32) {
PREMULTIPLIED = 1,
STRAIGHT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLORMANAGEMENT_ALPHA_MODE_PREMULTIPLIED = D2D1_COLORMANAGEMENT_ALPHA_MODE.PREMULTIPLIED;
pub const D2D1_COLORMANAGEMENT_ALPHA_MODE_STRAIGHT = D2D1_COLORMANAGEMENT_ALPHA_MODE.STRAIGHT;
pub const D2D1_COLORMANAGEMENT_ALPHA_MODE_FORCE_DWORD = D2D1_COLORMANAGEMENT_ALPHA_MODE.FORCE_DWORD;
pub const D2D1_COLORMANAGEMENT_QUALITY = enum(u32) {
PROOF = 0,
NORMAL = 1,
BEST = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLORMANAGEMENT_QUALITY_PROOF = D2D1_COLORMANAGEMENT_QUALITY.PROOF;
pub const D2D1_COLORMANAGEMENT_QUALITY_NORMAL = D2D1_COLORMANAGEMENT_QUALITY.NORMAL;
pub const D2D1_COLORMANAGEMENT_QUALITY_BEST = D2D1_COLORMANAGEMENT_QUALITY.BEST;
pub const D2D1_COLORMANAGEMENT_QUALITY_FORCE_DWORD = D2D1_COLORMANAGEMENT_QUALITY.FORCE_DWORD;
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT = enum(u32) {
PERCEPTUAL = 0,
RELATIVE_COLORIMETRIC = 1,
SATURATION = 2,
ABSOLUTE_COLORIMETRIC = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL = D2D1_COLORMANAGEMENT_RENDERING_INTENT.PERCEPTUAL;
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT_RELATIVE_COLORIMETRIC = D2D1_COLORMANAGEMENT_RENDERING_INTENT.RELATIVE_COLORIMETRIC;
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT_SATURATION = D2D1_COLORMANAGEMENT_RENDERING_INTENT.SATURATION;
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = D2D1_COLORMANAGEMENT_RENDERING_INTENT.ABSOLUTE_COLORIMETRIC;
pub const D2D1_COLORMANAGEMENT_RENDERING_INTENT_FORCE_DWORD = D2D1_COLORMANAGEMENT_RENDERING_INTENT.FORCE_DWORD;
pub const D2D1_HISTOGRAM_PROP = enum(u32) {
NUM_BINS = 0,
CHANNEL_SELECT = 1,
HISTOGRAM_OUTPUT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HISTOGRAM_PROP_NUM_BINS = D2D1_HISTOGRAM_PROP.NUM_BINS;
pub const D2D1_HISTOGRAM_PROP_CHANNEL_SELECT = D2D1_HISTOGRAM_PROP.CHANNEL_SELECT;
pub const D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT = D2D1_HISTOGRAM_PROP.HISTOGRAM_OUTPUT;
pub const D2D1_HISTOGRAM_PROP_FORCE_DWORD = D2D1_HISTOGRAM_PROP.FORCE_DWORD;
pub const D2D1_POINTSPECULAR_PROP = enum(u32) {
LIGHT_POSITION = 0,
SPECULAR_EXPONENT = 1,
SPECULAR_CONSTANT = 2,
SURFACE_SCALE = 3,
COLOR = 4,
KERNEL_UNIT_LENGTH = 5,
SCALE_MODE = 6,
FORCE_DWORD = 4294967295,
};
pub const D2D1_POINTSPECULAR_PROP_LIGHT_POSITION = D2D1_POINTSPECULAR_PROP.LIGHT_POSITION;
pub const D2D1_POINTSPECULAR_PROP_SPECULAR_EXPONENT = D2D1_POINTSPECULAR_PROP.SPECULAR_EXPONENT;
pub const D2D1_POINTSPECULAR_PROP_SPECULAR_CONSTANT = D2D1_POINTSPECULAR_PROP.SPECULAR_CONSTANT;
pub const D2D1_POINTSPECULAR_PROP_SURFACE_SCALE = D2D1_POINTSPECULAR_PROP.SURFACE_SCALE;
pub const D2D1_POINTSPECULAR_PROP_COLOR = D2D1_POINTSPECULAR_PROP.COLOR;
pub const D2D1_POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH = D2D1_POINTSPECULAR_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_POINTSPECULAR_PROP_SCALE_MODE = D2D1_POINTSPECULAR_PROP.SCALE_MODE;
pub const D2D1_POINTSPECULAR_PROP_FORCE_DWORD = D2D1_POINTSPECULAR_PROP.FORCE_DWORD;
pub const D2D1_POINTSPECULAR_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_POINTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_POINTSPECULAR_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_POINTSPECULAR_SCALE_MODE_LINEAR = D2D1_POINTSPECULAR_SCALE_MODE.LINEAR;
pub const D2D1_POINTSPECULAR_SCALE_MODE_CUBIC = D2D1_POINTSPECULAR_SCALE_MODE.CUBIC;
pub const D2D1_POINTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_POINTSPECULAR_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_POINTSPECULAR_SCALE_MODE_ANISOTROPIC = D2D1_POINTSPECULAR_SCALE_MODE.ANISOTROPIC;
pub const D2D1_POINTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_POINTSPECULAR_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_POINTSPECULAR_SCALE_MODE_FORCE_DWORD = D2D1_POINTSPECULAR_SCALE_MODE.FORCE_DWORD;
pub const D2D1_SPOTSPECULAR_PROP = enum(u32) {
LIGHT_POSITION = 0,
POINTS_AT = 1,
FOCUS = 2,
LIMITING_CONE_ANGLE = 3,
SPECULAR_EXPONENT = 4,
SPECULAR_CONSTANT = 5,
SURFACE_SCALE = 6,
COLOR = 7,
KERNEL_UNIT_LENGTH = 8,
SCALE_MODE = 9,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SPOTSPECULAR_PROP_LIGHT_POSITION = D2D1_SPOTSPECULAR_PROP.LIGHT_POSITION;
pub const D2D1_SPOTSPECULAR_PROP_POINTS_AT = D2D1_SPOTSPECULAR_PROP.POINTS_AT;
pub const D2D1_SPOTSPECULAR_PROP_FOCUS = D2D1_SPOTSPECULAR_PROP.FOCUS;
pub const D2D1_SPOTSPECULAR_PROP_LIMITING_CONE_ANGLE = D2D1_SPOTSPECULAR_PROP.LIMITING_CONE_ANGLE;
pub const D2D1_SPOTSPECULAR_PROP_SPECULAR_EXPONENT = D2D1_SPOTSPECULAR_PROP.SPECULAR_EXPONENT;
pub const D2D1_SPOTSPECULAR_PROP_SPECULAR_CONSTANT = D2D1_SPOTSPECULAR_PROP.SPECULAR_CONSTANT;
pub const D2D1_SPOTSPECULAR_PROP_SURFACE_SCALE = D2D1_SPOTSPECULAR_PROP.SURFACE_SCALE;
pub const D2D1_SPOTSPECULAR_PROP_COLOR = D2D1_SPOTSPECULAR_PROP.COLOR;
pub const D2D1_SPOTSPECULAR_PROP_KERNEL_UNIT_LENGTH = D2D1_SPOTSPECULAR_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_SPOTSPECULAR_PROP_SCALE_MODE = D2D1_SPOTSPECULAR_PROP.SCALE_MODE;
pub const D2D1_SPOTSPECULAR_PROP_FORCE_DWORD = D2D1_SPOTSPECULAR_PROP.FORCE_DWORD;
pub const D2D1_SPOTSPECULAR_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SPOTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_SPOTSPECULAR_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_LINEAR = D2D1_SPOTSPECULAR_SCALE_MODE.LINEAR;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_CUBIC = D2D1_SPOTSPECULAR_SCALE_MODE.CUBIC;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_SPOTSPECULAR_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_ANISOTROPIC = D2D1_SPOTSPECULAR_SCALE_MODE.ANISOTROPIC;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_SPOTSPECULAR_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_SPOTSPECULAR_SCALE_MODE_FORCE_DWORD = D2D1_SPOTSPECULAR_SCALE_MODE.FORCE_DWORD;
pub const D2D1_DISTANTSPECULAR_PROP = enum(u32) {
AZIMUTH = 0,
ELEVATION = 1,
SPECULAR_EXPONENT = 2,
SPECULAR_CONSTANT = 3,
SURFACE_SCALE = 4,
COLOR = 5,
KERNEL_UNIT_LENGTH = 6,
SCALE_MODE = 7,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISTANTSPECULAR_PROP_AZIMUTH = D2D1_DISTANTSPECULAR_PROP.AZIMUTH;
pub const D2D1_DISTANTSPECULAR_PROP_ELEVATION = D2D1_DISTANTSPECULAR_PROP.ELEVATION;
pub const D2D1_DISTANTSPECULAR_PROP_SPECULAR_EXPONENT = D2D1_DISTANTSPECULAR_PROP.SPECULAR_EXPONENT;
pub const D2D1_DISTANTSPECULAR_PROP_SPECULAR_CONSTANT = D2D1_DISTANTSPECULAR_PROP.SPECULAR_CONSTANT;
pub const D2D1_DISTANTSPECULAR_PROP_SURFACE_SCALE = D2D1_DISTANTSPECULAR_PROP.SURFACE_SCALE;
pub const D2D1_DISTANTSPECULAR_PROP_COLOR = D2D1_DISTANTSPECULAR_PROP.COLOR;
pub const D2D1_DISTANTSPECULAR_PROP_KERNEL_UNIT_LENGTH = D2D1_DISTANTSPECULAR_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_DISTANTSPECULAR_PROP_SCALE_MODE = D2D1_DISTANTSPECULAR_PROP.SCALE_MODE;
pub const D2D1_DISTANTSPECULAR_PROP_FORCE_DWORD = D2D1_DISTANTSPECULAR_PROP.FORCE_DWORD;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_DISTANTSPECULAR_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_LINEAR = D2D1_DISTANTSPECULAR_SCALE_MODE.LINEAR;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_CUBIC = D2D1_DISTANTSPECULAR_SCALE_MODE.CUBIC;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_DISTANTSPECULAR_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_ANISOTROPIC = D2D1_DISTANTSPECULAR_SCALE_MODE.ANISOTROPIC;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_DISTANTSPECULAR_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_DISTANTSPECULAR_SCALE_MODE_FORCE_DWORD = D2D1_DISTANTSPECULAR_SCALE_MODE.FORCE_DWORD;
pub const D2D1_POINTDIFFUSE_PROP = enum(u32) {
LIGHT_POSITION = 0,
DIFFUSE_CONSTANT = 1,
SURFACE_SCALE = 2,
COLOR = 3,
KERNEL_UNIT_LENGTH = 4,
SCALE_MODE = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_POINTDIFFUSE_PROP_LIGHT_POSITION = D2D1_POINTDIFFUSE_PROP.LIGHT_POSITION;
pub const D2D1_POINTDIFFUSE_PROP_DIFFUSE_CONSTANT = D2D1_POINTDIFFUSE_PROP.DIFFUSE_CONSTANT;
pub const D2D1_POINTDIFFUSE_PROP_SURFACE_SCALE = D2D1_POINTDIFFUSE_PROP.SURFACE_SCALE;
pub const D2D1_POINTDIFFUSE_PROP_COLOR = D2D1_POINTDIFFUSE_PROP.COLOR;
pub const D2D1_POINTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = D2D1_POINTDIFFUSE_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_POINTDIFFUSE_PROP_SCALE_MODE = D2D1_POINTDIFFUSE_PROP.SCALE_MODE;
pub const D2D1_POINTDIFFUSE_PROP_FORCE_DWORD = D2D1_POINTDIFFUSE_PROP.FORCE_DWORD;
pub const D2D1_POINTDIFFUSE_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_POINTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_POINTDIFFUSE_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_LINEAR = D2D1_POINTDIFFUSE_SCALE_MODE.LINEAR;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_CUBIC = D2D1_POINTDIFFUSE_SCALE_MODE.CUBIC;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_POINTDIFFUSE_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_ANISOTROPIC = D2D1_POINTDIFFUSE_SCALE_MODE.ANISOTROPIC;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_POINTDIFFUSE_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_POINTDIFFUSE_SCALE_MODE_FORCE_DWORD = D2D1_POINTDIFFUSE_SCALE_MODE.FORCE_DWORD;
pub const D2D1_SPOTDIFFUSE_PROP = enum(u32) {
LIGHT_POSITION = 0,
POINTS_AT = 1,
FOCUS = 2,
LIMITING_CONE_ANGLE = 3,
DIFFUSE_CONSTANT = 4,
SURFACE_SCALE = 5,
COLOR = 6,
KERNEL_UNIT_LENGTH = 7,
SCALE_MODE = 8,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SPOTDIFFUSE_PROP_LIGHT_POSITION = D2D1_SPOTDIFFUSE_PROP.LIGHT_POSITION;
pub const D2D1_SPOTDIFFUSE_PROP_POINTS_AT = D2D1_SPOTDIFFUSE_PROP.POINTS_AT;
pub const D2D1_SPOTDIFFUSE_PROP_FOCUS = D2D1_SPOTDIFFUSE_PROP.FOCUS;
pub const D2D1_SPOTDIFFUSE_PROP_LIMITING_CONE_ANGLE = D2D1_SPOTDIFFUSE_PROP.LIMITING_CONE_ANGLE;
pub const D2D1_SPOTDIFFUSE_PROP_DIFFUSE_CONSTANT = D2D1_SPOTDIFFUSE_PROP.DIFFUSE_CONSTANT;
pub const D2D1_SPOTDIFFUSE_PROP_SURFACE_SCALE = D2D1_SPOTDIFFUSE_PROP.SURFACE_SCALE;
pub const D2D1_SPOTDIFFUSE_PROP_COLOR = D2D1_SPOTDIFFUSE_PROP.COLOR;
pub const D2D1_SPOTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = D2D1_SPOTDIFFUSE_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_SPOTDIFFUSE_PROP_SCALE_MODE = D2D1_SPOTDIFFUSE_PROP.SCALE_MODE;
pub const D2D1_SPOTDIFFUSE_PROP_FORCE_DWORD = D2D1_SPOTDIFFUSE_PROP.FORCE_DWORD;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_SPOTDIFFUSE_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_LINEAR = D2D1_SPOTDIFFUSE_SCALE_MODE.LINEAR;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_CUBIC = D2D1_SPOTDIFFUSE_SCALE_MODE.CUBIC;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_SPOTDIFFUSE_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_ANISOTROPIC = D2D1_SPOTDIFFUSE_SCALE_MODE.ANISOTROPIC;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_SPOTDIFFUSE_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_SPOTDIFFUSE_SCALE_MODE_FORCE_DWORD = D2D1_SPOTDIFFUSE_SCALE_MODE.FORCE_DWORD;
pub const D2D1_DISTANTDIFFUSE_PROP = enum(u32) {
AZIMUTH = 0,
ELEVATION = 1,
DIFFUSE_CONSTANT = 2,
SURFACE_SCALE = 3,
COLOR = 4,
KERNEL_UNIT_LENGTH = 5,
SCALE_MODE = 6,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISTANTDIFFUSE_PROP_AZIMUTH = D2D1_DISTANTDIFFUSE_PROP.AZIMUTH;
pub const D2D1_DISTANTDIFFUSE_PROP_ELEVATION = D2D1_DISTANTDIFFUSE_PROP.ELEVATION;
pub const D2D1_DISTANTDIFFUSE_PROP_DIFFUSE_CONSTANT = D2D1_DISTANTDIFFUSE_PROP.DIFFUSE_CONSTANT;
pub const D2D1_DISTANTDIFFUSE_PROP_SURFACE_SCALE = D2D1_DISTANTDIFFUSE_PROP.SURFACE_SCALE;
pub const D2D1_DISTANTDIFFUSE_PROP_COLOR = D2D1_DISTANTDIFFUSE_PROP.COLOR;
pub const D2D1_DISTANTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = D2D1_DISTANTDIFFUSE_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_DISTANTDIFFUSE_PROP_SCALE_MODE = D2D1_DISTANTDIFFUSE_PROP.SCALE_MODE;
pub const D2D1_DISTANTDIFFUSE_PROP_FORCE_DWORD = D2D1_DISTANTDIFFUSE_PROP.FORCE_DWORD;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_DISTANTDIFFUSE_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_LINEAR = D2D1_DISTANTDIFFUSE_SCALE_MODE.LINEAR;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_CUBIC = D2D1_DISTANTDIFFUSE_SCALE_MODE.CUBIC;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_DISTANTDIFFUSE_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_ANISOTROPIC = D2D1_DISTANTDIFFUSE_SCALE_MODE.ANISOTROPIC;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_DISTANTDIFFUSE_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_DISTANTDIFFUSE_SCALE_MODE_FORCE_DWORD = D2D1_DISTANTDIFFUSE_SCALE_MODE.FORCE_DWORD;
pub const D2D1_FLOOD_PROP = enum(u32) {
COLOR = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_FLOOD_PROP_COLOR = D2D1_FLOOD_PROP.COLOR;
pub const D2D1_FLOOD_PROP_FORCE_DWORD = D2D1_FLOOD_PROP.FORCE_DWORD;
pub const D2D1_LINEARTRANSFER_PROP = enum(u32) {
RED_Y_INTERCEPT = 0,
RED_SLOPE = 1,
RED_DISABLE = 2,
GREEN_Y_INTERCEPT = 3,
GREEN_SLOPE = 4,
GREEN_DISABLE = 5,
BLUE_Y_INTERCEPT = 6,
BLUE_SLOPE = 7,
BLUE_DISABLE = 8,
ALPHA_Y_INTERCEPT = 9,
ALPHA_SLOPE = 10,
ALPHA_DISABLE = 11,
CLAMP_OUTPUT = 12,
FORCE_DWORD = 4294967295,
};
pub const D2D1_LINEARTRANSFER_PROP_RED_Y_INTERCEPT = D2D1_LINEARTRANSFER_PROP.RED_Y_INTERCEPT;
pub const D2D1_LINEARTRANSFER_PROP_RED_SLOPE = D2D1_LINEARTRANSFER_PROP.RED_SLOPE;
pub const D2D1_LINEARTRANSFER_PROP_RED_DISABLE = D2D1_LINEARTRANSFER_PROP.RED_DISABLE;
pub const D2D1_LINEARTRANSFER_PROP_GREEN_Y_INTERCEPT = D2D1_LINEARTRANSFER_PROP.GREEN_Y_INTERCEPT;
pub const D2D1_LINEARTRANSFER_PROP_GREEN_SLOPE = D2D1_LINEARTRANSFER_PROP.GREEN_SLOPE;
pub const D2D1_LINEARTRANSFER_PROP_GREEN_DISABLE = D2D1_LINEARTRANSFER_PROP.GREEN_DISABLE;
pub const D2D1_LINEARTRANSFER_PROP_BLUE_Y_INTERCEPT = D2D1_LINEARTRANSFER_PROP.BLUE_Y_INTERCEPT;
pub const D2D1_LINEARTRANSFER_PROP_BLUE_SLOPE = D2D1_LINEARTRANSFER_PROP.BLUE_SLOPE;
pub const D2D1_LINEARTRANSFER_PROP_BLUE_DISABLE = D2D1_LINEARTRANSFER_PROP.BLUE_DISABLE;
pub const D2D1_LINEARTRANSFER_PROP_ALPHA_Y_INTERCEPT = D2D1_LINEARTRANSFER_PROP.ALPHA_Y_INTERCEPT;
pub const D2D1_LINEARTRANSFER_PROP_ALPHA_SLOPE = D2D1_LINEARTRANSFER_PROP.ALPHA_SLOPE;
pub const D2D1_LINEARTRANSFER_PROP_ALPHA_DISABLE = D2D1_LINEARTRANSFER_PROP.ALPHA_DISABLE;
pub const D2D1_LINEARTRANSFER_PROP_CLAMP_OUTPUT = D2D1_LINEARTRANSFER_PROP.CLAMP_OUTPUT;
pub const D2D1_LINEARTRANSFER_PROP_FORCE_DWORD = D2D1_LINEARTRANSFER_PROP.FORCE_DWORD;
pub const D2D1_GAMMATRANSFER_PROP = enum(u32) {
RED_AMPLITUDE = 0,
RED_EXPONENT = 1,
RED_OFFSET = 2,
RED_DISABLE = 3,
GREEN_AMPLITUDE = 4,
GREEN_EXPONENT = 5,
GREEN_OFFSET = 6,
GREEN_DISABLE = 7,
BLUE_AMPLITUDE = 8,
BLUE_EXPONENT = 9,
BLUE_OFFSET = 10,
BLUE_DISABLE = 11,
ALPHA_AMPLITUDE = 12,
ALPHA_EXPONENT = 13,
ALPHA_OFFSET = 14,
ALPHA_DISABLE = 15,
CLAMP_OUTPUT = 16,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GAMMATRANSFER_PROP_RED_AMPLITUDE = D2D1_GAMMATRANSFER_PROP.RED_AMPLITUDE;
pub const D2D1_GAMMATRANSFER_PROP_RED_EXPONENT = D2D1_GAMMATRANSFER_PROP.RED_EXPONENT;
pub const D2D1_GAMMATRANSFER_PROP_RED_OFFSET = D2D1_GAMMATRANSFER_PROP.RED_OFFSET;
pub const D2D1_GAMMATRANSFER_PROP_RED_DISABLE = D2D1_GAMMATRANSFER_PROP.RED_DISABLE;
pub const D2D1_GAMMATRANSFER_PROP_GREEN_AMPLITUDE = D2D1_GAMMATRANSFER_PROP.GREEN_AMPLITUDE;
pub const D2D1_GAMMATRANSFER_PROP_GREEN_EXPONENT = D2D1_GAMMATRANSFER_PROP.GREEN_EXPONENT;
pub const D2D1_GAMMATRANSFER_PROP_GREEN_OFFSET = D2D1_GAMMATRANSFER_PROP.GREEN_OFFSET;
pub const D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE = D2D1_GAMMATRANSFER_PROP.GREEN_DISABLE;
pub const D2D1_GAMMATRANSFER_PROP_BLUE_AMPLITUDE = D2D1_GAMMATRANSFER_PROP.BLUE_AMPLITUDE;
pub const D2D1_GAMMATRANSFER_PROP_BLUE_EXPONENT = D2D1_GAMMATRANSFER_PROP.BLUE_EXPONENT;
pub const D2D1_GAMMATRANSFER_PROP_BLUE_OFFSET = D2D1_GAMMATRANSFER_PROP.BLUE_OFFSET;
pub const D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE = D2D1_GAMMATRANSFER_PROP.BLUE_DISABLE;
pub const D2D1_GAMMATRANSFER_PROP_ALPHA_AMPLITUDE = D2D1_GAMMATRANSFER_PROP.ALPHA_AMPLITUDE;
pub const D2D1_GAMMATRANSFER_PROP_ALPHA_EXPONENT = D2D1_GAMMATRANSFER_PROP.ALPHA_EXPONENT;
pub const D2D1_GAMMATRANSFER_PROP_ALPHA_OFFSET = D2D1_GAMMATRANSFER_PROP.ALPHA_OFFSET;
pub const D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE = D2D1_GAMMATRANSFER_PROP.ALPHA_DISABLE;
pub const D2D1_GAMMATRANSFER_PROP_CLAMP_OUTPUT = D2D1_GAMMATRANSFER_PROP.CLAMP_OUTPUT;
pub const D2D1_GAMMATRANSFER_PROP_FORCE_DWORD = D2D1_GAMMATRANSFER_PROP.FORCE_DWORD;
pub const D2D1_TABLETRANSFER_PROP = enum(u32) {
RED_TABLE = 0,
RED_DISABLE = 1,
GREEN_TABLE = 2,
GREEN_DISABLE = 3,
BLUE_TABLE = 4,
BLUE_DISABLE = 5,
ALPHA_TABLE = 6,
ALPHA_DISABLE = 7,
CLAMP_OUTPUT = 8,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TABLETRANSFER_PROP_RED_TABLE = D2D1_TABLETRANSFER_PROP.RED_TABLE;
pub const D2D1_TABLETRANSFER_PROP_RED_DISABLE = D2D1_TABLETRANSFER_PROP.RED_DISABLE;
pub const D2D1_TABLETRANSFER_PROP_GREEN_TABLE = D2D1_TABLETRANSFER_PROP.GREEN_TABLE;
pub const D2D1_TABLETRANSFER_PROP_GREEN_DISABLE = D2D1_TABLETRANSFER_PROP.GREEN_DISABLE;
pub const D2D1_TABLETRANSFER_PROP_BLUE_TABLE = D2D1_TABLETRANSFER_PROP.BLUE_TABLE;
pub const D2D1_TABLETRANSFER_PROP_BLUE_DISABLE = D2D1_TABLETRANSFER_PROP.BLUE_DISABLE;
pub const D2D1_TABLETRANSFER_PROP_ALPHA_TABLE = D2D1_TABLETRANSFER_PROP.ALPHA_TABLE;
pub const D2D1_TABLETRANSFER_PROP_ALPHA_DISABLE = D2D1_TABLETRANSFER_PROP.ALPHA_DISABLE;
pub const D2D1_TABLETRANSFER_PROP_CLAMP_OUTPUT = D2D1_TABLETRANSFER_PROP.CLAMP_OUTPUT;
pub const D2D1_TABLETRANSFER_PROP_FORCE_DWORD = D2D1_TABLETRANSFER_PROP.FORCE_DWORD;
pub const D2D1_DISCRETETRANSFER_PROP = enum(u32) {
RED_TABLE = 0,
RED_DISABLE = 1,
GREEN_TABLE = 2,
GREEN_DISABLE = 3,
BLUE_TABLE = 4,
BLUE_DISABLE = 5,
ALPHA_TABLE = 6,
ALPHA_DISABLE = 7,
CLAMP_OUTPUT = 8,
FORCE_DWORD = 4294967295,
};
pub const D2D1_DISCRETETRANSFER_PROP_RED_TABLE = D2D1_DISCRETETRANSFER_PROP.RED_TABLE;
pub const D2D1_DISCRETETRANSFER_PROP_RED_DISABLE = D2D1_DISCRETETRANSFER_PROP.RED_DISABLE;
pub const D2D1_DISCRETETRANSFER_PROP_GREEN_TABLE = D2D1_DISCRETETRANSFER_PROP.GREEN_TABLE;
pub const D2D1_DISCRETETRANSFER_PROP_GREEN_DISABLE = D2D1_DISCRETETRANSFER_PROP.GREEN_DISABLE;
pub const D2D1_DISCRETETRANSFER_PROP_BLUE_TABLE = D2D1_DISCRETETRANSFER_PROP.BLUE_TABLE;
pub const D2D1_DISCRETETRANSFER_PROP_BLUE_DISABLE = D2D1_DISCRETETRANSFER_PROP.BLUE_DISABLE;
pub const D2D1_DISCRETETRANSFER_PROP_ALPHA_TABLE = D2D1_DISCRETETRANSFER_PROP.ALPHA_TABLE;
pub const D2D1_DISCRETETRANSFER_PROP_ALPHA_DISABLE = D2D1_DISCRETETRANSFER_PROP.ALPHA_DISABLE;
pub const D2D1_DISCRETETRANSFER_PROP_CLAMP_OUTPUT = D2D1_DISCRETETRANSFER_PROP.CLAMP_OUTPUT;
pub const D2D1_DISCRETETRANSFER_PROP_FORCE_DWORD = D2D1_DISCRETETRANSFER_PROP.FORCE_DWORD;
pub const D2D1_CONVOLVEMATRIX_PROP = enum(u32) {
KERNEL_UNIT_LENGTH = 0,
SCALE_MODE = 1,
KERNEL_SIZE_X = 2,
KERNEL_SIZE_Y = 3,
KERNEL_MATRIX = 4,
DIVISOR = 5,
BIAS = 6,
KERNEL_OFFSET = 7,
PRESERVE_ALPHA = 8,
BORDER_MODE = 9,
CLAMP_OUTPUT = 10,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CONVOLVEMATRIX_PROP_KERNEL_UNIT_LENGTH = D2D1_CONVOLVEMATRIX_PROP.KERNEL_UNIT_LENGTH;
pub const D2D1_CONVOLVEMATRIX_PROP_SCALE_MODE = D2D1_CONVOLVEMATRIX_PROP.SCALE_MODE;
pub const D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_X = D2D1_CONVOLVEMATRIX_PROP.KERNEL_SIZE_X;
pub const D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_Y = D2D1_CONVOLVEMATRIX_PROP.KERNEL_SIZE_Y;
pub const D2D1_CONVOLVEMATRIX_PROP_KERNEL_MATRIX = D2D1_CONVOLVEMATRIX_PROP.KERNEL_MATRIX;
pub const D2D1_CONVOLVEMATRIX_PROP_DIVISOR = D2D1_CONVOLVEMATRIX_PROP.DIVISOR;
pub const D2D1_CONVOLVEMATRIX_PROP_BIAS = D2D1_CONVOLVEMATRIX_PROP.BIAS;
pub const D2D1_CONVOLVEMATRIX_PROP_KERNEL_OFFSET = D2D1_CONVOLVEMATRIX_PROP.KERNEL_OFFSET;
pub const D2D1_CONVOLVEMATRIX_PROP_PRESERVE_ALPHA = D2D1_CONVOLVEMATRIX_PROP.PRESERVE_ALPHA;
pub const D2D1_CONVOLVEMATRIX_PROP_BORDER_MODE = D2D1_CONVOLVEMATRIX_PROP.BORDER_MODE;
pub const D2D1_CONVOLVEMATRIX_PROP_CLAMP_OUTPUT = D2D1_CONVOLVEMATRIX_PROP.CLAMP_OUTPUT;
pub const D2D1_CONVOLVEMATRIX_PROP_FORCE_DWORD = D2D1_CONVOLVEMATRIX_PROP.FORCE_DWORD;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_CONVOLVEMATRIX_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_LINEAR = D2D1_CONVOLVEMATRIX_SCALE_MODE.LINEAR;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_CUBIC = D2D1_CONVOLVEMATRIX_SCALE_MODE.CUBIC;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_CONVOLVEMATRIX_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_ANISOTROPIC = D2D1_CONVOLVEMATRIX_SCALE_MODE.ANISOTROPIC;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_HIGH_QUALITY_CUBIC = D2D1_CONVOLVEMATRIX_SCALE_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_CONVOLVEMATRIX_SCALE_MODE_FORCE_DWORD = D2D1_CONVOLVEMATRIX_SCALE_MODE.FORCE_DWORD;
pub const D2D1_BRIGHTNESS_PROP = enum(u32) {
WHITE_POINT = 0,
BLACK_POINT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BRIGHTNESS_PROP_WHITE_POINT = D2D1_BRIGHTNESS_PROP.WHITE_POINT;
pub const D2D1_BRIGHTNESS_PROP_BLACK_POINT = D2D1_BRIGHTNESS_PROP.BLACK_POINT;
pub const D2D1_BRIGHTNESS_PROP_FORCE_DWORD = D2D1_BRIGHTNESS_PROP.FORCE_DWORD;
pub const D2D1_ARITHMETICCOMPOSITE_PROP = enum(u32) {
COEFFICIENTS = 0,
CLAMP_OUTPUT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS = D2D1_ARITHMETICCOMPOSITE_PROP.COEFFICIENTS;
pub const D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT = D2D1_ARITHMETICCOMPOSITE_PROP.CLAMP_OUTPUT;
pub const D2D1_ARITHMETICCOMPOSITE_PROP_FORCE_DWORD = D2D1_ARITHMETICCOMPOSITE_PROP.FORCE_DWORD;
pub const D2D1_CROP_PROP = enum(u32) {
RECT = 0,
BORDER_MODE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CROP_PROP_RECT = D2D1_CROP_PROP.RECT;
pub const D2D1_CROP_PROP_BORDER_MODE = D2D1_CROP_PROP.BORDER_MODE;
pub const D2D1_CROP_PROP_FORCE_DWORD = D2D1_CROP_PROP.FORCE_DWORD;
pub const D2D1_BORDER_PROP = enum(u32) {
EDGE_MODE_X = 0,
EDGE_MODE_Y = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BORDER_PROP_EDGE_MODE_X = D2D1_BORDER_PROP.EDGE_MODE_X;
pub const D2D1_BORDER_PROP_EDGE_MODE_Y = D2D1_BORDER_PROP.EDGE_MODE_Y;
pub const D2D1_BORDER_PROP_FORCE_DWORD = D2D1_BORDER_PROP.FORCE_DWORD;
pub const D2D1_BORDER_EDGE_MODE = enum(u32) {
CLAMP = 0,
WRAP = 1,
MIRROR = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BORDER_EDGE_MODE_CLAMP = D2D1_BORDER_EDGE_MODE.CLAMP;
pub const D2D1_BORDER_EDGE_MODE_WRAP = D2D1_BORDER_EDGE_MODE.WRAP;
pub const D2D1_BORDER_EDGE_MODE_MIRROR = D2D1_BORDER_EDGE_MODE.MIRROR;
pub const D2D1_BORDER_EDGE_MODE_FORCE_DWORD = D2D1_BORDER_EDGE_MODE.FORCE_DWORD;
pub const D2D1_MORPHOLOGY_PROP = enum(u32) {
MODE = 0,
WIDTH = 1,
HEIGHT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_MORPHOLOGY_PROP_MODE = D2D1_MORPHOLOGY_PROP.MODE;
pub const D2D1_MORPHOLOGY_PROP_WIDTH = D2D1_MORPHOLOGY_PROP.WIDTH;
pub const D2D1_MORPHOLOGY_PROP_HEIGHT = D2D1_MORPHOLOGY_PROP.HEIGHT;
pub const D2D1_MORPHOLOGY_PROP_FORCE_DWORD = D2D1_MORPHOLOGY_PROP.FORCE_DWORD;
pub const D2D1_MORPHOLOGY_MODE = enum(u32) {
ERODE = 0,
DILATE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_MORPHOLOGY_MODE_ERODE = D2D1_MORPHOLOGY_MODE.ERODE;
pub const D2D1_MORPHOLOGY_MODE_DILATE = D2D1_MORPHOLOGY_MODE.DILATE;
pub const D2D1_MORPHOLOGY_MODE_FORCE_DWORD = D2D1_MORPHOLOGY_MODE.FORCE_DWORD;
pub const D2D1_TILE_PROP = enum(u32) {
RECT = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TILE_PROP_RECT = D2D1_TILE_PROP.RECT;
pub const D2D1_TILE_PROP_FORCE_DWORD = D2D1_TILE_PROP.FORCE_DWORD;
pub const D2D1_ATLAS_PROP = enum(u32) {
INPUT_RECT = 0,
INPUT_PADDING_RECT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_ATLAS_PROP_INPUT_RECT = D2D1_ATLAS_PROP.INPUT_RECT;
pub const D2D1_ATLAS_PROP_INPUT_PADDING_RECT = D2D1_ATLAS_PROP.INPUT_PADDING_RECT;
pub const D2D1_ATLAS_PROP_FORCE_DWORD = D2D1_ATLAS_PROP.FORCE_DWORD;
pub const D2D1_OPACITYMETADATA_PROP = enum(u32) {
INPUT_OPAQUE_RECT = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_OPACITYMETADATA_PROP_INPUT_OPAQUE_RECT = D2D1_OPACITYMETADATA_PROP.INPUT_OPAQUE_RECT;
pub const D2D1_OPACITYMETADATA_PROP_FORCE_DWORD = D2D1_OPACITYMETADATA_PROP.FORCE_DWORD;
pub const PD2D1_EFFECT_FACTORY = fn(
effectImpl: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const D2D1_PROPERTY_TYPE = enum(u32) {
UNKNOWN = 0,
STRING = 1,
BOOL = 2,
UINT32 = 3,
INT32 = 4,
FLOAT = 5,
VECTOR2 = 6,
VECTOR3 = 7,
VECTOR4 = 8,
BLOB = 9,
IUNKNOWN = 10,
ENUM = 11,
ARRAY = 12,
CLSID = 13,
MATRIX_3X2 = 14,
MATRIX_4X3 = 15,
MATRIX_4X4 = 16,
MATRIX_5X4 = 17,
COLOR_CONTEXT = 18,
FORCE_DWORD = 4294967295,
};
pub const D2D1_PROPERTY_TYPE_UNKNOWN = D2D1_PROPERTY_TYPE.UNKNOWN;
pub const D2D1_PROPERTY_TYPE_STRING = D2D1_PROPERTY_TYPE.STRING;
pub const D2D1_PROPERTY_TYPE_BOOL = D2D1_PROPERTY_TYPE.BOOL;
pub const D2D1_PROPERTY_TYPE_UINT32 = D2D1_PROPERTY_TYPE.UINT32;
pub const D2D1_PROPERTY_TYPE_INT32 = D2D1_PROPERTY_TYPE.INT32;
pub const D2D1_PROPERTY_TYPE_FLOAT = D2D1_PROPERTY_TYPE.FLOAT;
pub const D2D1_PROPERTY_TYPE_VECTOR2 = D2D1_PROPERTY_TYPE.VECTOR2;
pub const D2D1_PROPERTY_TYPE_VECTOR3 = D2D1_PROPERTY_TYPE.VECTOR3;
pub const D2D1_PROPERTY_TYPE_VECTOR4 = D2D1_PROPERTY_TYPE.VECTOR4;
pub const D2D1_PROPERTY_TYPE_BLOB = D2D1_PROPERTY_TYPE.BLOB;
pub const D2D1_PROPERTY_TYPE_IUNKNOWN = D2D1_PROPERTY_TYPE.IUNKNOWN;
pub const D2D1_PROPERTY_TYPE_ENUM = D2D1_PROPERTY_TYPE.ENUM;
pub const D2D1_PROPERTY_TYPE_ARRAY = D2D1_PROPERTY_TYPE.ARRAY;
pub const D2D1_PROPERTY_TYPE_CLSID = D2D1_PROPERTY_TYPE.CLSID;
pub const D2D1_PROPERTY_TYPE_MATRIX_3X2 = D2D1_PROPERTY_TYPE.MATRIX_3X2;
pub const D2D1_PROPERTY_TYPE_MATRIX_4X3 = D2D1_PROPERTY_TYPE.MATRIX_4X3;
pub const D2D1_PROPERTY_TYPE_MATRIX_4X4 = D2D1_PROPERTY_TYPE.MATRIX_4X4;
pub const D2D1_PROPERTY_TYPE_MATRIX_5X4 = D2D1_PROPERTY_TYPE.MATRIX_5X4;
pub const D2D1_PROPERTY_TYPE_COLOR_CONTEXT = D2D1_PROPERTY_TYPE.COLOR_CONTEXT;
pub const D2D1_PROPERTY_TYPE_FORCE_DWORD = D2D1_PROPERTY_TYPE.FORCE_DWORD;
pub const D2D1_PROPERTY = enum(u32) {
CLSID = 2147483648,
DISPLAYNAME = 2147483649,
AUTHOR = 2147483650,
CATEGORY = 2147483651,
DESCRIPTION = 2147483652,
INPUTS = 2147483653,
CACHED = 2147483654,
PRECISION = 2147483655,
MIN_INPUTS = 2147483656,
MAX_INPUTS = 2147483657,
FORCE_DWORD = 4294967295,
};
pub const D2D1_PROPERTY_CLSID = D2D1_PROPERTY.CLSID;
pub const D2D1_PROPERTY_DISPLAYNAME = D2D1_PROPERTY.DISPLAYNAME;
pub const D2D1_PROPERTY_AUTHOR = D2D1_PROPERTY.AUTHOR;
pub const D2D1_PROPERTY_CATEGORY = D2D1_PROPERTY.CATEGORY;
pub const D2D1_PROPERTY_DESCRIPTION = D2D1_PROPERTY.DESCRIPTION;
pub const D2D1_PROPERTY_INPUTS = D2D1_PROPERTY.INPUTS;
pub const D2D1_PROPERTY_CACHED = D2D1_PROPERTY.CACHED;
pub const D2D1_PROPERTY_PRECISION = D2D1_PROPERTY.PRECISION;
pub const D2D1_PROPERTY_MIN_INPUTS = D2D1_PROPERTY.MIN_INPUTS;
pub const D2D1_PROPERTY_MAX_INPUTS = D2D1_PROPERTY.MAX_INPUTS;
pub const D2D1_PROPERTY_FORCE_DWORD = D2D1_PROPERTY.FORCE_DWORD;
pub const D2D1_SUBPROPERTY = enum(u32) {
DISPLAYNAME = 2147483648,
ISREADONLY = 2147483649,
MIN = 2147483650,
MAX = 2147483651,
DEFAULT = 2147483652,
FIELDS = 2147483653,
INDEX = 2147483654,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SUBPROPERTY_DISPLAYNAME = D2D1_SUBPROPERTY.DISPLAYNAME;
pub const D2D1_SUBPROPERTY_ISREADONLY = D2D1_SUBPROPERTY.ISREADONLY;
pub const D2D1_SUBPROPERTY_MIN = D2D1_SUBPROPERTY.MIN;
pub const D2D1_SUBPROPERTY_MAX = D2D1_SUBPROPERTY.MAX;
pub const D2D1_SUBPROPERTY_DEFAULT = D2D1_SUBPROPERTY.DEFAULT;
pub const D2D1_SUBPROPERTY_FIELDS = D2D1_SUBPROPERTY.FIELDS;
pub const D2D1_SUBPROPERTY_INDEX = D2D1_SUBPROPERTY.INDEX;
pub const D2D1_SUBPROPERTY_FORCE_DWORD = D2D1_SUBPROPERTY.FORCE_DWORD;
pub const D2D1_BITMAP_OPTIONS = enum(u32) {
NONE = 0,
TARGET = 1,
CANNOT_DRAW = 2,
CPU_READ = 4,
GDI_COMPATIBLE = 8,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TARGET: u1 = 0,
CANNOT_DRAW: u1 = 0,
CPU_READ: u1 = 0,
GDI_COMPATIBLE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_BITMAP_OPTIONS {
return @intToEnum(D2D1_BITMAP_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_BITMAP_OPTIONS.NONE) else 0)
| (if (o.TARGET == 1) @enumToInt(D2D1_BITMAP_OPTIONS.TARGET) else 0)
| (if (o.CANNOT_DRAW == 1) @enumToInt(D2D1_BITMAP_OPTIONS.CANNOT_DRAW) else 0)
| (if (o.CPU_READ == 1) @enumToInt(D2D1_BITMAP_OPTIONS.CPU_READ) else 0)
| (if (o.GDI_COMPATIBLE == 1) @enumToInt(D2D1_BITMAP_OPTIONS.GDI_COMPATIBLE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_BITMAP_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_BITMAP_OPTIONS_NONE = D2D1_BITMAP_OPTIONS.NONE;
pub const D2D1_BITMAP_OPTIONS_TARGET = D2D1_BITMAP_OPTIONS.TARGET;
pub const D2D1_BITMAP_OPTIONS_CANNOT_DRAW = D2D1_BITMAP_OPTIONS.CANNOT_DRAW;
pub const D2D1_BITMAP_OPTIONS_CPU_READ = D2D1_BITMAP_OPTIONS.CPU_READ;
pub const D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE = D2D1_BITMAP_OPTIONS.GDI_COMPATIBLE;
pub const D2D1_BITMAP_OPTIONS_FORCE_DWORD = D2D1_BITMAP_OPTIONS.FORCE_DWORD;
pub const D2D1_BUFFER_PRECISION = enum(u32) {
UNKNOWN = 0,
@"8BPC_UNORM" = 1,
@"8BPC_UNORM_SRGB" = 2,
@"16BPC_UNORM" = 3,
@"16BPC_FLOAT" = 4,
@"32BPC_FLOAT" = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BUFFER_PRECISION_UNKNOWN = D2D1_BUFFER_PRECISION.UNKNOWN;
pub const D2D1_BUFFER_PRECISION_8BPC_UNORM = D2D1_BUFFER_PRECISION.@"8BPC_UNORM";
pub const D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = D2D1_BUFFER_PRECISION.@"8BPC_UNORM_SRGB";
pub const D2D1_BUFFER_PRECISION_16BPC_UNORM = D2D1_BUFFER_PRECISION.@"16BPC_UNORM";
pub const D2D1_BUFFER_PRECISION_16BPC_FLOAT = D2D1_BUFFER_PRECISION.@"16BPC_FLOAT";
pub const D2D1_BUFFER_PRECISION_32BPC_FLOAT = D2D1_BUFFER_PRECISION.@"32BPC_FLOAT";
pub const D2D1_BUFFER_PRECISION_FORCE_DWORD = D2D1_BUFFER_PRECISION.FORCE_DWORD;
pub const D2D1_MAP_OPTIONS = enum(u32) {
NONE = 0,
READ = 1,
WRITE = 2,
DISCARD = 4,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
READ: u1 = 0,
WRITE: u1 = 0,
DISCARD: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_MAP_OPTIONS {
return @intToEnum(D2D1_MAP_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_MAP_OPTIONS.NONE) else 0)
| (if (o.READ == 1) @enumToInt(D2D1_MAP_OPTIONS.READ) else 0)
| (if (o.WRITE == 1) @enumToInt(D2D1_MAP_OPTIONS.WRITE) else 0)
| (if (o.DISCARD == 1) @enumToInt(D2D1_MAP_OPTIONS.DISCARD) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_MAP_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_MAP_OPTIONS_NONE = D2D1_MAP_OPTIONS.NONE;
pub const D2D1_MAP_OPTIONS_READ = D2D1_MAP_OPTIONS.READ;
pub const D2D1_MAP_OPTIONS_WRITE = D2D1_MAP_OPTIONS.WRITE;
pub const D2D1_MAP_OPTIONS_DISCARD = D2D1_MAP_OPTIONS.DISCARD;
pub const D2D1_MAP_OPTIONS_FORCE_DWORD = D2D1_MAP_OPTIONS.FORCE_DWORD;
pub const D2D1_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE.LINEAR;
pub const D2D1_INTERPOLATION_MODE_CUBIC = D2D1_INTERPOLATION_MODE.CUBIC;
pub const D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_INTERPOLATION_MODE_ANISOTROPIC = D2D1_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_INTERPOLATION_MODE_FORCE_DWORD = D2D1_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_UNIT_MODE = enum(u32) {
DIPS = 0,
PIXELS = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_UNIT_MODE_DIPS = D2D1_UNIT_MODE.DIPS;
pub const D2D1_UNIT_MODE_PIXELS = D2D1_UNIT_MODE.PIXELS;
pub const D2D1_UNIT_MODE_FORCE_DWORD = D2D1_UNIT_MODE.FORCE_DWORD;
pub const D2D1_COLOR_SPACE = enum(u32) {
CUSTOM = 0,
SRGB = 1,
SCRGB = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLOR_SPACE_CUSTOM = D2D1_COLOR_SPACE.CUSTOM;
pub const D2D1_COLOR_SPACE_SRGB = D2D1_COLOR_SPACE.SRGB;
pub const D2D1_COLOR_SPACE_SCRGB = D2D1_COLOR_SPACE.SCRGB;
pub const D2D1_COLOR_SPACE_FORCE_DWORD = D2D1_COLOR_SPACE.FORCE_DWORD;
pub const D2D1_DEVICE_CONTEXT_OPTIONS = enum(u32) {
NONE = 0,
ENABLE_MULTITHREADED_OPTIMIZATIONS = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
ENABLE_MULTITHREADED_OPTIMIZATIONS: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_DEVICE_CONTEXT_OPTIONS {
return @intToEnum(D2D1_DEVICE_CONTEXT_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_DEVICE_CONTEXT_OPTIONS.NONE) else 0)
| (if (o.ENABLE_MULTITHREADED_OPTIMIZATIONS == 1) @enumToInt(D2D1_DEVICE_CONTEXT_OPTIONS.ENABLE_MULTITHREADED_OPTIMIZATIONS) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_DEVICE_CONTEXT_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_DEVICE_CONTEXT_OPTIONS_NONE = D2D1_DEVICE_CONTEXT_OPTIONS.NONE;
pub const D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS = D2D1_DEVICE_CONTEXT_OPTIONS.ENABLE_MULTITHREADED_OPTIMIZATIONS;
pub const D2D1_DEVICE_CONTEXT_OPTIONS_FORCE_DWORD = D2D1_DEVICE_CONTEXT_OPTIONS.FORCE_DWORD;
pub const D2D1_STROKE_TRANSFORM_TYPE = enum(u32) {
NORMAL = 0,
FIXED = 1,
HAIRLINE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_STROKE_TRANSFORM_TYPE_NORMAL = D2D1_STROKE_TRANSFORM_TYPE.NORMAL;
pub const D2D1_STROKE_TRANSFORM_TYPE_FIXED = D2D1_STROKE_TRANSFORM_TYPE.FIXED;
pub const D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE = D2D1_STROKE_TRANSFORM_TYPE.HAIRLINE;
pub const D2D1_STROKE_TRANSFORM_TYPE_FORCE_DWORD = D2D1_STROKE_TRANSFORM_TYPE.FORCE_DWORD;
pub const D2D1_PRIMITIVE_BLEND = enum(u32) {
SOURCE_OVER = 0,
COPY = 1,
MIN = 2,
ADD = 3,
MAX = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_PRIMITIVE_BLEND_SOURCE_OVER = D2D1_PRIMITIVE_BLEND.SOURCE_OVER;
pub const D2D1_PRIMITIVE_BLEND_COPY = D2D1_PRIMITIVE_BLEND.COPY;
pub const D2D1_PRIMITIVE_BLEND_MIN = D2D1_PRIMITIVE_BLEND.MIN;
pub const D2D1_PRIMITIVE_BLEND_ADD = D2D1_PRIMITIVE_BLEND.ADD;
pub const D2D1_PRIMITIVE_BLEND_MAX = D2D1_PRIMITIVE_BLEND.MAX;
pub const D2D1_PRIMITIVE_BLEND_FORCE_DWORD = D2D1_PRIMITIVE_BLEND.FORCE_DWORD;
pub const D2D1_THREADING_MODE = enum(u32) {
SINGLE_THREADED = 0,
MULTI_THREADED = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_THREADING_MODE_SINGLE_THREADED = D2D1_THREADING_MODE.SINGLE_THREADED;
pub const D2D1_THREADING_MODE_MULTI_THREADED = D2D1_THREADING_MODE.MULTI_THREADED;
pub const D2D1_THREADING_MODE_FORCE_DWORD = D2D1_THREADING_MODE.FORCE_DWORD;
pub const D2D1_COLOR_INTERPOLATION_MODE = enum(u32) {
STRAIGHT = 0,
PREMULTIPLIED = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = D2D1_COLOR_INTERPOLATION_MODE.STRAIGHT;
pub const D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = D2D1_COLOR_INTERPOLATION_MODE.PREMULTIPLIED;
pub const D2D1_COLOR_INTERPOLATION_MODE_FORCE_DWORD = D2D1_COLOR_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_BITMAP_PROPERTIES1 = extern struct {
pixelFormat: D2D1_PIXEL_FORMAT,
dpiX: f32,
dpiY: f32,
bitmapOptions: D2D1_BITMAP_OPTIONS,
colorContext: ?*ID2D1ColorContext,
};
pub const D2D1_MAPPED_RECT = extern struct {
pitch: u32,
bits: ?*u8,
};
pub const D2D1_RENDERING_CONTROLS = extern struct {
bufferPrecision: D2D1_BUFFER_PRECISION,
tileSize: D2D_SIZE_U,
};
pub const D2D1_EFFECT_INPUT_DESCRIPTION = extern struct {
effect: ?*ID2D1Effect,
inputIndex: u32,
inputRectangle: D2D_RECT_F,
};
pub const D2D1_POINT_DESCRIPTION = extern struct {
point: D2D_POINT_2F,
unitTangentVector: D2D_POINT_2F,
endSegment: u32,
endFigure: u32,
lengthToEndSegment: f32,
};
pub const D2D1_IMAGE_BRUSH_PROPERTIES = extern struct {
sourceRectangle: D2D_RECT_F,
extendModeX: D2D1_EXTEND_MODE,
extendModeY: D2D1_EXTEND_MODE,
interpolationMode: D2D1_INTERPOLATION_MODE,
};
pub const D2D1_BITMAP_BRUSH_PROPERTIES1 = extern struct {
extendModeX: D2D1_EXTEND_MODE,
extendModeY: D2D1_EXTEND_MODE,
interpolationMode: D2D1_INTERPOLATION_MODE,
};
pub const D2D1_STROKE_STYLE_PROPERTIES1 = extern struct {
startCap: D2D1_CAP_STYLE,
endCap: D2D1_CAP_STYLE,
dashCap: D2D1_CAP_STYLE,
lineJoin: D2D1_LINE_JOIN,
miterLimit: f32,
dashStyle: D2D1_DASH_STYLE,
dashOffset: f32,
transformType: D2D1_STROKE_TRANSFORM_TYPE,
};
pub const D2D1_LAYER_OPTIONS1 = enum(u32) {
NONE = 0,
INITIALIZE_FROM_BACKGROUND = 1,
IGNORE_ALPHA = 2,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
INITIALIZE_FROM_BACKGROUND: u1 = 0,
IGNORE_ALPHA: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_LAYER_OPTIONS1 {
return @intToEnum(D2D1_LAYER_OPTIONS1,
(if (o.NONE == 1) @enumToInt(D2D1_LAYER_OPTIONS1.NONE) else 0)
| (if (o.INITIALIZE_FROM_BACKGROUND == 1) @enumToInt(D2D1_LAYER_OPTIONS1.INITIALIZE_FROM_BACKGROUND) else 0)
| (if (o.IGNORE_ALPHA == 1) @enumToInt(D2D1_LAYER_OPTIONS1.IGNORE_ALPHA) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_LAYER_OPTIONS1.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_LAYER_OPTIONS1_NONE = D2D1_LAYER_OPTIONS1.NONE;
pub const D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = D2D1_LAYER_OPTIONS1.INITIALIZE_FROM_BACKGROUND;
pub const D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = D2D1_LAYER_OPTIONS1.IGNORE_ALPHA;
pub const D2D1_LAYER_OPTIONS1_FORCE_DWORD = D2D1_LAYER_OPTIONS1.FORCE_DWORD;
pub const D2D1_LAYER_PARAMETERS1 = extern struct {
contentBounds: D2D_RECT_F,
geometricMask: ?*ID2D1Geometry,
maskAntialiasMode: D2D1_ANTIALIAS_MODE,
maskTransform: D2D_MATRIX_3X2_F,
opacity: f32,
opacityBrush: ?*ID2D1Brush,
layerOptions: D2D1_LAYER_OPTIONS1,
};
pub const D2D1_PRINT_FONT_SUBSET_MODE = enum(u32) {
DEFAULT = 0,
EACHPAGE = 1,
NONE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT = D2D1_PRINT_FONT_SUBSET_MODE.DEFAULT;
pub const D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE = D2D1_PRINT_FONT_SUBSET_MODE.EACHPAGE;
pub const D2D1_PRINT_FONT_SUBSET_MODE_NONE = D2D1_PRINT_FONT_SUBSET_MODE.NONE;
pub const D2D1_PRINT_FONT_SUBSET_MODE_FORCE_DWORD = D2D1_PRINT_FONT_SUBSET_MODE.FORCE_DWORD;
pub const D2D1_DRAWING_STATE_DESCRIPTION1 = extern struct {
antialiasMode: D2D1_ANTIALIAS_MODE,
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
tag1: u64,
tag2: u64,
transform: D2D_MATRIX_3X2_F,
primitiveBlend: D2D1_PRIMITIVE_BLEND,
unitMode: D2D1_UNIT_MODE,
};
pub const D2D1_PRINT_CONTROL_PROPERTIES = extern struct {
fontSubset: D2D1_PRINT_FONT_SUBSET_MODE,
rasterDPI: f32,
colorSpace: D2D1_COLOR_SPACE,
};
pub const D2D1_CREATION_PROPERTIES = extern struct {
threadingMode: D2D1_THREADING_MODE,
debugLevel: D2D1_DEBUG_LEVEL,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1GdiMetafileSink_Value = @import("../zig.zig").Guid.initString("82237326-8111-4f7c-bcf4-b5c1175564fe");
pub const IID_ID2D1GdiMetafileSink = &IID_ID2D1GdiMetafileSink_Value;
pub const ID2D1GdiMetafileSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ProcessRecord: fn(
self: *const ID2D1GdiMetafileSink,
recordType: u32,
recordData: ?*const anyopaque,
recordDataSize: 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 ID2D1GdiMetafileSink_ProcessRecord(self: *const T, recordType: u32, recordData: ?*const anyopaque, recordDataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafileSink.VTable, self.vtable).ProcessRecord(@ptrCast(*const ID2D1GdiMetafileSink, self), recordType, recordData, recordDataSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1GdiMetafile_Value = @import("../zig.zig").Guid.initString("2f543dc3-cfc1-4211-864f-cfd91c6f3395");
pub const IID_ID2D1GdiMetafile = &IID_ID2D1GdiMetafile_Value;
pub const ID2D1GdiMetafile = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
Stream: fn(
self: *const ID2D1GdiMetafile,
sink: ?*ID2D1GdiMetafileSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBounds: fn(
self: *const ID2D1GdiMetafile,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiMetafile_Stream(self: *const T, sink: ?*ID2D1GdiMetafileSink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafile.VTable, self.vtable).Stream(@ptrCast(*const ID2D1GdiMetafile, self), sink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiMetafile_GetBounds(self: *const T, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafile.VTable, self.vtable).GetBounds(@ptrCast(*const ID2D1GdiMetafile, self), bounds);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1CommandSink_Value = @import("../zig.zig").Guid.initString("54d7898a-a061-40a7-bec7-e465bcba2c4f");
pub const IID_ID2D1CommandSink = &IID_ID2D1CommandSink_Value;
pub const ID2D1CommandSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
BeginDraw: fn(
self: *const ID2D1CommandSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndDraw: fn(
self: *const ID2D1CommandSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAntialiasMode: fn(
self: *const ID2D1CommandSink,
antialiasMode: D2D1_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTags: fn(
self: *const ID2D1CommandSink,
tag1: u64,
tag2: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTextAntialiasMode: fn(
self: *const ID2D1CommandSink,
textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTextRenderingParams: fn(
self: *const ID2D1CommandSink,
textRenderingParams: ?*IDWriteRenderingParams,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTransform: fn(
self: *const ID2D1CommandSink,
transform: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPrimitiveBlend: fn(
self: *const ID2D1CommandSink,
primitiveBlend: D2D1_PRIMITIVE_BLEND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetUnitMode: fn(
self: *const ID2D1CommandSink,
unitMode: D2D1_UNIT_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clear: fn(
self: *const ID2D1CommandSink,
color: ?*const D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGlyphRun: fn(
self: *const ID2D1CommandSink,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
glyphRunDescription: ?*const DWRITE_GLYPH_RUN_DESCRIPTION,
foregroundBrush: ?*ID2D1Brush,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawLine: fn(
self: *const ID2D1CommandSink,
point0: D2D_POINT_2F,
point1: D2D_POINT_2F,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGeometry: fn(
self: *const ID2D1CommandSink,
geometry: ?*ID2D1Geometry,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawRectangle: fn(
self: *const ID2D1CommandSink,
rect: ?*const D2D_RECT_F,
brush: ?*ID2D1Brush,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawBitmap: fn(
self: *const ID2D1CommandSink,
bitmap: ?*ID2D1Bitmap,
destinationRectangle: ?*const D2D_RECT_F,
opacity: f32,
interpolationMode: D2D1_INTERPOLATION_MODE,
sourceRectangle: ?*const D2D_RECT_F,
perspectiveTransform: ?*const D2D_MATRIX_4X4_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawImage: fn(
self: *const ID2D1CommandSink,
image: ?*ID2D1Image,
targetOffset: ?*const D2D_POINT_2F,
imageRectangle: ?*const D2D_RECT_F,
interpolationMode: D2D1_INTERPOLATION_MODE,
compositeMode: D2D1_COMPOSITE_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGdiMetafile: fn(
self: *const ID2D1CommandSink,
gdiMetafile: ?*ID2D1GdiMetafile,
targetOffset: ?*const D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillMesh: fn(
self: *const ID2D1CommandSink,
mesh: ?*ID2D1Mesh,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillOpacityMask: fn(
self: *const ID2D1CommandSink,
opacityMask: ?*ID2D1Bitmap,
brush: ?*ID2D1Brush,
destinationRectangle: ?*const D2D_RECT_F,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillGeometry: fn(
self: *const ID2D1CommandSink,
geometry: ?*ID2D1Geometry,
brush: ?*ID2D1Brush,
opacityBrush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillRectangle: fn(
self: *const ID2D1CommandSink,
rect: ?*const D2D_RECT_F,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushAxisAlignedClip: fn(
self: *const ID2D1CommandSink,
clipRect: ?*const D2D_RECT_F,
antialiasMode: D2D1_ANTIALIAS_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PushLayer: fn(
self: *const ID2D1CommandSink,
layerParameters1: ?*const D2D1_LAYER_PARAMETERS1,
layer: ?*ID2D1Layer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PopAxisAlignedClip: fn(
self: *const ID2D1CommandSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PopLayer: fn(
self: *const ID2D1CommandSink,
) 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 ID2D1CommandSink_BeginDraw(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).BeginDraw(@ptrCast(*const ID2D1CommandSink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_EndDraw(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).EndDraw(@ptrCast(*const ID2D1CommandSink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetAntialiasMode(self: *const T, antialiasMode: D2D1_ANTIALIAS_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetAntialiasMode(@ptrCast(*const ID2D1CommandSink, self), antialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetTags(self: *const T, tag1: u64, tag2: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetTags(@ptrCast(*const ID2D1CommandSink, self), tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetTextAntialiasMode(self: *const T, textAntialiasMode: D2D1_TEXT_ANTIALIAS_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetTextAntialiasMode(@ptrCast(*const ID2D1CommandSink, self), textAntialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetTextRenderingParams(self: *const T, textRenderingParams: ?*IDWriteRenderingParams) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetTextRenderingParams(@ptrCast(*const ID2D1CommandSink, self), textRenderingParams);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetTransform(self: *const T, transform: ?*const D2D_MATRIX_3X2_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetTransform(@ptrCast(*const ID2D1CommandSink, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetPrimitiveBlend(self: *const T, primitiveBlend: D2D1_PRIMITIVE_BLEND) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetPrimitiveBlend(@ptrCast(*const ID2D1CommandSink, self), primitiveBlend);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_SetUnitMode(self: *const T, unitMode: D2D1_UNIT_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).SetUnitMode(@ptrCast(*const ID2D1CommandSink, self), unitMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_Clear(self: *const T, color: ?*const D2D1_COLOR_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).Clear(@ptrCast(*const ID2D1CommandSink, self), color);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawGlyphRun(self: *const T, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, glyphRunDescription: ?*const DWRITE_GLYPH_RUN_DESCRIPTION, foregroundBrush: ?*ID2D1Brush, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawGlyphRun(@ptrCast(*const ID2D1CommandSink, self), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawLine(self: *const T, point0: D2D_POINT_2F, point1: D2D_POINT_2F, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawLine(@ptrCast(*const ID2D1CommandSink, self), point0, point1, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawGeometry(self: *const T, geometry: ?*ID2D1Geometry, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawGeometry(@ptrCast(*const ID2D1CommandSink, self), geometry, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawRectangle(self: *const T, rect: ?*const D2D_RECT_F, brush: ?*ID2D1Brush, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawRectangle(@ptrCast(*const ID2D1CommandSink, self), rect, brush, strokeWidth, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawBitmap(self: *const T, bitmap: ?*ID2D1Bitmap, destinationRectangle: ?*const D2D_RECT_F, opacity: f32, interpolationMode: D2D1_INTERPOLATION_MODE, sourceRectangle: ?*const D2D_RECT_F, perspectiveTransform: ?*const D2D_MATRIX_4X4_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawBitmap(@ptrCast(*const ID2D1CommandSink, self), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawImage(self: *const T, image: ?*ID2D1Image, targetOffset: ?*const D2D_POINT_2F, imageRectangle: ?*const D2D_RECT_F, interpolationMode: D2D1_INTERPOLATION_MODE, compositeMode: D2D1_COMPOSITE_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawImage(@ptrCast(*const ID2D1CommandSink, self), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_DrawGdiMetafile(self: *const T, gdiMetafile: ?*ID2D1GdiMetafile, targetOffset: ?*const D2D_POINT_2F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).DrawGdiMetafile(@ptrCast(*const ID2D1CommandSink, self), gdiMetafile, targetOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_FillMesh(self: *const T, mesh: ?*ID2D1Mesh, brush: ?*ID2D1Brush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).FillMesh(@ptrCast(*const ID2D1CommandSink, self), mesh, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_FillOpacityMask(self: *const T, opacityMask: ?*ID2D1Bitmap, brush: ?*ID2D1Brush, destinationRectangle: ?*const D2D_RECT_F, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).FillOpacityMask(@ptrCast(*const ID2D1CommandSink, self), opacityMask, brush, destinationRectangle, sourceRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_FillGeometry(self: *const T, geometry: ?*ID2D1Geometry, brush: ?*ID2D1Brush, opacityBrush: ?*ID2D1Brush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).FillGeometry(@ptrCast(*const ID2D1CommandSink, self), geometry, brush, opacityBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_FillRectangle(self: *const T, rect: ?*const D2D_RECT_F, brush: ?*ID2D1Brush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).FillRectangle(@ptrCast(*const ID2D1CommandSink, self), rect, brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_PushAxisAlignedClip(self: *const T, clipRect: ?*const D2D_RECT_F, antialiasMode: D2D1_ANTIALIAS_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).PushAxisAlignedClip(@ptrCast(*const ID2D1CommandSink, self), clipRect, antialiasMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_PushLayer(self: *const T, layerParameters1: ?*const D2D1_LAYER_PARAMETERS1, layer: ?*ID2D1Layer) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).PushLayer(@ptrCast(*const ID2D1CommandSink, self), layerParameters1, layer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_PopAxisAlignedClip(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).PopAxisAlignedClip(@ptrCast(*const ID2D1CommandSink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink_PopLayer(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink.VTable, self.vtable).PopLayer(@ptrCast(*const ID2D1CommandSink, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1CommandList_Value = @import("../zig.zig").Guid.initString("b4f34a19-2383-4d76-94f6-ec343657c3dc");
pub const IID_ID2D1CommandList = &IID_ID2D1CommandList_Value;
pub const ID2D1CommandList = extern struct {
pub const VTable = extern struct {
base: ID2D1Image.VTable,
Stream: fn(
self: *const ID2D1CommandList,
sink: ?*ID2D1CommandSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const ID2D1CommandList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Image.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandList_Stream(self: *const T, sink: ?*ID2D1CommandSink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandList.VTable, self.vtable).Stream(@ptrCast(*const ID2D1CommandList, self), sink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandList_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandList.VTable, self.vtable).Close(@ptrCast(*const ID2D1CommandList, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1PrintControl_Value = @import("../zig.zig").Guid.initString("2c1d867d-c290-41c8-ae7e-34a98702e9a5");
pub const IID_ID2D1PrintControl = &IID_ID2D1PrintControl_Value;
pub const ID2D1PrintControl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddPage: fn(
self: *const ID2D1PrintControl,
commandList: ?*ID2D1CommandList,
pageSize: D2D_SIZE_F,
pagePrintTicketStream: ?*IStream,
tag1: ?*u64,
tag2: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const ID2D1PrintControl,
) 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 ID2D1PrintControl_AddPage(self: *const T, commandList: ?*ID2D1CommandList, pageSize: D2D_SIZE_F, pagePrintTicketStream: ?*IStream, tag1: ?*u64, tag2: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PrintControl.VTable, self.vtable).AddPage(@ptrCast(*const ID2D1PrintControl, self), commandList, pageSize, pagePrintTicketStream, tag1, tag2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PrintControl_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PrintControl.VTable, self.vtable).Close(@ptrCast(*const ID2D1PrintControl, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ImageBrush_Value = @import("../zig.zig").Guid.initString("fe9e984d-3f95-407c-b5db-cb94d4e8f87c");
pub const IID_ID2D1ImageBrush = &IID_ID2D1ImageBrush_Value;
pub const ID2D1ImageBrush = extern struct {
pub const VTable = extern struct {
base: ID2D1Brush.VTable,
SetImage: fn(
self: *const ID2D1ImageBrush,
image: ?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
SetExtendModeX: fn(
self: *const ID2D1ImageBrush,
extendModeX: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetExtendModeY: fn(
self: *const ID2D1ImageBrush,
extendModeY: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetInterpolationMode: fn(
self: *const ID2D1ImageBrush,
interpolationMode: D2D1_INTERPOLATION_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetSourceRectangle: fn(
self: *const ID2D1ImageBrush,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
GetImage: fn(
self: *const ID2D1ImageBrush,
image: ?*?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
GetExtendModeX: fn(
self: *const ID2D1ImageBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
GetExtendModeY: fn(
self: *const ID2D1ImageBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
GetInterpolationMode: fn(
self: *const ID2D1ImageBrush,
) callconv(@import("std").os.windows.WINAPI) D2D1_INTERPOLATION_MODE,
GetSourceRectangle: fn(
self: *const ID2D1ImageBrush,
sourceRectangle: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Brush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_SetImage(self: *const T, image: ?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).SetImage(@ptrCast(*const ID2D1ImageBrush, self), image);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_SetExtendModeX(self: *const T, extendModeX: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).SetExtendModeX(@ptrCast(*const ID2D1ImageBrush, self), extendModeX);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_SetExtendModeY(self: *const T, extendModeY: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).SetExtendModeY(@ptrCast(*const ID2D1ImageBrush, self), extendModeY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_SetInterpolationMode(self: *const T, interpolationMode: D2D1_INTERPOLATION_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).SetInterpolationMode(@ptrCast(*const ID2D1ImageBrush, self), interpolationMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_SetSourceRectangle(self: *const T, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).SetSourceRectangle(@ptrCast(*const ID2D1ImageBrush, self), sourceRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_GetImage(self: *const T, image: ?*?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).GetImage(@ptrCast(*const ID2D1ImageBrush, self), image);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_GetExtendModeX(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).GetExtendModeX(@ptrCast(*const ID2D1ImageBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_GetExtendModeY(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).GetExtendModeY(@ptrCast(*const ID2D1ImageBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_GetInterpolationMode(self: *const T) callconv(.Inline) D2D1_INTERPOLATION_MODE {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).GetInterpolationMode(@ptrCast(*const ID2D1ImageBrush, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageBrush_GetSourceRectangle(self: *const T, sourceRectangle: ?*D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageBrush.VTable, self.vtable).GetSourceRectangle(@ptrCast(*const ID2D1ImageBrush, self), sourceRectangle);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1BitmapBrush1_Value = @import("../zig.zig").Guid.initString("41343a53-e41a-49a2-91cd-21793bbb62e5");
pub const IID_ID2D1BitmapBrush1 = &IID_ID2D1BitmapBrush1_Value;
pub const ID2D1BitmapBrush1 = extern struct {
pub const VTable = extern struct {
base: ID2D1BitmapBrush.VTable,
SetInterpolationMode1: fn(
self: *const ID2D1BitmapBrush1,
interpolationMode: D2D1_INTERPOLATION_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetInterpolationMode1: fn(
self: *const ID2D1BitmapBrush1,
) callconv(@import("std").os.windows.WINAPI) D2D1_INTERPOLATION_MODE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1BitmapBrush.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush1_SetInterpolationMode1(self: *const T, interpolationMode: D2D1_INTERPOLATION_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BitmapBrush1.VTable, self.vtable).SetInterpolationMode1(@ptrCast(*const ID2D1BitmapBrush1, self), interpolationMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BitmapBrush1_GetInterpolationMode1(self: *const T) callconv(.Inline) D2D1_INTERPOLATION_MODE {
return @ptrCast(*const ID2D1BitmapBrush1.VTable, self.vtable).GetInterpolationMode1(@ptrCast(*const ID2D1BitmapBrush1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1StrokeStyle1_Value = @import("../zig.zig").Guid.initString("10a72a66-e91c-43f4-993f-ddf4b82b0b4a");
pub const IID_ID2D1StrokeStyle1 = &IID_ID2D1StrokeStyle1_Value;
pub const ID2D1StrokeStyle1 = extern struct {
pub const VTable = extern struct {
base: ID2D1StrokeStyle.VTable,
GetStrokeTransformType: fn(
self: *const ID2D1StrokeStyle1,
) callconv(@import("std").os.windows.WINAPI) D2D1_STROKE_TRANSFORM_TYPE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1StrokeStyle.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1StrokeStyle1_GetStrokeTransformType(self: *const T) callconv(.Inline) D2D1_STROKE_TRANSFORM_TYPE {
return @ptrCast(*const ID2D1StrokeStyle1.VTable, self.vtable).GetStrokeTransformType(@ptrCast(*const ID2D1StrokeStyle1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1PathGeometry1_Value = @import("../zig.zig").Guid.initString("62baa2d2-ab54-41b7-b872-787e0106a421");
pub const IID_ID2D1PathGeometry1 = &IID_ID2D1PathGeometry1_Value;
pub const ID2D1PathGeometry1 = extern struct {
pub const VTable = extern struct {
base: ID2D1PathGeometry.VTable,
ComputePointAndSegmentAtLength: fn(
self: *const ID2D1PathGeometry1,
length: f32,
startSegment: u32,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
pointDescription: ?*D2D1_POINT_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1PathGeometry.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1PathGeometry1_ComputePointAndSegmentAtLength(self: *const T, length: f32, startSegment: u32, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, pointDescription: ?*D2D1_POINT_DESCRIPTION) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1PathGeometry1.VTable, self.vtable).ComputePointAndSegmentAtLength(@ptrCast(*const ID2D1PathGeometry1, self), length, startSegment, worldTransform, flatteningTolerance, pointDescription);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Properties_Value = @import("../zig.zig").Guid.initString("483473d7-cd46-4f9d-9d3a-3112aa80159d");
pub const IID_ID2D1Properties = &IID_ID2D1Properties_Value;
pub const ID2D1Properties = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetPropertyCount: fn(
self: *const ID2D1Properties,
) callconv(@import("std").os.windows.WINAPI) u32,
GetPropertyName: fn(
self: *const ID2D1Properties,
index: u32,
name: [*:0]u16,
nameCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyNameLength: fn(
self: *const ID2D1Properties,
index: u32,
) callconv(@import("std").os.windows.WINAPI) u32,
GetType: fn(
self: *const ID2D1Properties,
index: u32,
) callconv(@import("std").os.windows.WINAPI) D2D1_PROPERTY_TYPE,
GetPropertyIndex: fn(
self: *const ID2D1Properties,
name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) u32,
SetValueByName: fn(
self: *const ID2D1Properties,
name: ?[*:0]const u16,
type: D2D1_PROPERTY_TYPE,
data: [*:0]const u8,
dataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetValue: fn(
self: *const ID2D1Properties,
index: u32,
type: D2D1_PROPERTY_TYPE,
data: [*:0]const u8,
dataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValueByName: fn(
self: *const ID2D1Properties,
name: ?[*:0]const u16,
type: D2D1_PROPERTY_TYPE,
data: [*:0]u8,
dataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValue: fn(
self: *const ID2D1Properties,
index: u32,
type: D2D1_PROPERTY_TYPE,
data: [*:0]u8,
dataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValueSize: fn(
self: *const ID2D1Properties,
index: u32,
) callconv(@import("std").os.windows.WINAPI) u32,
GetSubProperties: fn(
self: *const ID2D1Properties,
index: u32,
subProperties: ?*?*ID2D1Properties,
) 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 ID2D1Properties_GetPropertyCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetPropertyCount(@ptrCast(*const ID2D1Properties, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetPropertyName(self: *const T, index: u32, name: [*:0]u16, nameCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetPropertyName(@ptrCast(*const ID2D1Properties, self), index, name, nameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetPropertyNameLength(self: *const T, index: u32) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetPropertyNameLength(@ptrCast(*const ID2D1Properties, self), index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetType(self: *const T, index: u32) callconv(.Inline) D2D1_PROPERTY_TYPE {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetType(@ptrCast(*const ID2D1Properties, self), index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetPropertyIndex(self: *const T, name: ?[*:0]const u16) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetPropertyIndex(@ptrCast(*const ID2D1Properties, self), name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_SetValueByName(self: *const T, name: ?[*:0]const u16, type_: D2D1_PROPERTY_TYPE, data: [*:0]const u8, dataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).SetValueByName(@ptrCast(*const ID2D1Properties, self), name, type_, data, dataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_SetValue(self: *const T, index: u32, type_: D2D1_PROPERTY_TYPE, data: [*:0]const u8, dataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).SetValue(@ptrCast(*const ID2D1Properties, self), index, type_, data, dataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetValueByName(self: *const T, name: ?[*:0]const u16, type_: D2D1_PROPERTY_TYPE, data: [*:0]u8, dataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetValueByName(@ptrCast(*const ID2D1Properties, self), name, type_, data, dataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetValue(self: *const T, index: u32, type_: D2D1_PROPERTY_TYPE, data: [*:0]u8, dataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetValue(@ptrCast(*const ID2D1Properties, self), index, type_, data, dataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetValueSize(self: *const T, index: u32) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetValueSize(@ptrCast(*const ID2D1Properties, self), index);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Properties_GetSubProperties(self: *const T, index: u32, subProperties: ?*?*ID2D1Properties) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Properties.VTable, self.vtable).GetSubProperties(@ptrCast(*const ID2D1Properties, self), index, subProperties);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Effect_Value = @import("../zig.zig").Guid.initString("28211a43-7d89-476f-8181-2d6159b220ad");
pub const IID_ID2D1Effect = &IID_ID2D1Effect_Value;
pub const ID2D1Effect = extern struct {
pub const VTable = extern struct {
base: ID2D1Properties.VTable,
SetInput: fn(
self: *const ID2D1Effect,
index: u32,
input: ?*ID2D1Image,
invalidate: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
SetInputCount: fn(
self: *const ID2D1Effect,
inputCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInput: fn(
self: *const ID2D1Effect,
index: u32,
input: ?*?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
GetInputCount: fn(
self: *const ID2D1Effect,
) callconv(@import("std").os.windows.WINAPI) u32,
GetOutput: fn(
self: *const ID2D1Effect,
outputImage: ?*?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Properties.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Effect_SetInput(self: *const T, index: u32, input: ?*ID2D1Image, invalidate: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID2D1Effect.VTable, self.vtable).SetInput(@ptrCast(*const ID2D1Effect, self), index, input, invalidate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Effect_SetInputCount(self: *const T, inputCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Effect.VTable, self.vtable).SetInputCount(@ptrCast(*const ID2D1Effect, self), inputCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Effect_GetInput(self: *const T, index: u32, input: ?*?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1Effect.VTable, self.vtable).GetInput(@ptrCast(*const ID2D1Effect, self), index, input);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Effect_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Effect.VTable, self.vtable).GetInputCount(@ptrCast(*const ID2D1Effect, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Effect_GetOutput(self: *const T, outputImage: ?*?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1Effect.VTable, self.vtable).GetOutput(@ptrCast(*const ID2D1Effect, self), outputImage);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Bitmap1_Value = @import("../zig.zig").Guid.initString("a898a84c-3873-4588-b08b-ebbf978df041");
pub const IID_ID2D1Bitmap1 = &IID_ID2D1Bitmap1_Value;
pub const ID2D1Bitmap1 = extern struct {
pub const VTable = extern struct {
base: ID2D1Bitmap.VTable,
GetColorContext: fn(
self: *const ID2D1Bitmap1,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) void,
GetOptions: fn(
self: *const ID2D1Bitmap1,
) callconv(@import("std").os.windows.WINAPI) D2D1_BITMAP_OPTIONS,
GetSurface: fn(
self: *const ID2D1Bitmap1,
dxgiSurface: ?*?*IDXGISurface,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Map: fn(
self: *const ID2D1Bitmap1,
options: D2D1_MAP_OPTIONS,
mappedRect: ?*D2D1_MAPPED_RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unmap: fn(
self: *const ID2D1Bitmap1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Bitmap.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap1_GetColorContext(self: *const T, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) void {
return @ptrCast(*const ID2D1Bitmap1.VTable, self.vtable).GetColorContext(@ptrCast(*const ID2D1Bitmap1, self), colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap1_GetOptions(self: *const T) callconv(.Inline) D2D1_BITMAP_OPTIONS {
return @ptrCast(*const ID2D1Bitmap1.VTable, self.vtable).GetOptions(@ptrCast(*const ID2D1Bitmap1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap1_GetSurface(self: *const T, dxgiSurface: ?*?*IDXGISurface) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap1.VTable, self.vtable).GetSurface(@ptrCast(*const ID2D1Bitmap1, self), dxgiSurface);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap1_Map(self: *const T, options: D2D1_MAP_OPTIONS, mappedRect: ?*D2D1_MAPPED_RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap1.VTable, self.vtable).Map(@ptrCast(*const ID2D1Bitmap1, self), options, mappedRect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Bitmap1_Unmap(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Bitmap1.VTable, self.vtable).Unmap(@ptrCast(*const ID2D1Bitmap1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ColorContext_Value = @import("../zig.zig").Guid.initString("1c4820bb-5771-4518-a581-2fe4dd0ec657");
pub const IID_ID2D1ColorContext = &IID_ID2D1ColorContext_Value;
pub const ID2D1ColorContext = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetColorSpace: fn(
self: *const ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_SPACE,
GetProfileSize: fn(
self: *const ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) u32,
GetProfile: fn(
self: *const ID2D1ColorContext,
profile: [*:0]u8,
profileSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext_GetColorSpace(self: *const T) callconv(.Inline) D2D1_COLOR_SPACE {
return @ptrCast(*const ID2D1ColorContext.VTable, self.vtable).GetColorSpace(@ptrCast(*const ID2D1ColorContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext_GetProfileSize(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1ColorContext.VTable, self.vtable).GetProfileSize(@ptrCast(*const ID2D1ColorContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext_GetProfile(self: *const T, profile: [*:0]u8, profileSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ColorContext.VTable, self.vtable).GetProfile(@ptrCast(*const ID2D1ColorContext, self), profile, profileSize);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1GradientStopCollection1_Value = @import("../zig.zig").Guid.initString("ae1572f4-5dd0-4777-998b-9279472ae63b");
pub const IID_ID2D1GradientStopCollection1 = &IID_ID2D1GradientStopCollection1_Value;
pub const ID2D1GradientStopCollection1 = extern struct {
pub const VTable = extern struct {
base: ID2D1GradientStopCollection.VTable,
GetGradientStops1: fn(
self: *const ID2D1GradientStopCollection1,
gradientStops: [*]D2D1_GRADIENT_STOP,
gradientStopsCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
GetPreInterpolationSpace: fn(
self: *const ID2D1GradientStopCollection1,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_SPACE,
GetPostInterpolationSpace: fn(
self: *const ID2D1GradientStopCollection1,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_SPACE,
GetBufferPrecision: fn(
self: *const ID2D1GradientStopCollection1,
) callconv(@import("std").os.windows.WINAPI) D2D1_BUFFER_PRECISION,
GetColorInterpolationMode: fn(
self: *const ID2D1GradientStopCollection1,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_INTERPOLATION_MODE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1GradientStopCollection.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection1_GetGradientStops1(self: *const T, gradientStops: [*]D2D1_GRADIENT_STOP, gradientStopsCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1GradientStopCollection1.VTable, self.vtable).GetGradientStops1(@ptrCast(*const ID2D1GradientStopCollection1, self), gradientStops, gradientStopsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection1_GetPreInterpolationSpace(self: *const T) callconv(.Inline) D2D1_COLOR_SPACE {
return @ptrCast(*const ID2D1GradientStopCollection1.VTable, self.vtable).GetPreInterpolationSpace(@ptrCast(*const ID2D1GradientStopCollection1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection1_GetPostInterpolationSpace(self: *const T) callconv(.Inline) D2D1_COLOR_SPACE {
return @ptrCast(*const ID2D1GradientStopCollection1.VTable, self.vtable).GetPostInterpolationSpace(@ptrCast(*const ID2D1GradientStopCollection1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection1_GetBufferPrecision(self: *const T) callconv(.Inline) D2D1_BUFFER_PRECISION {
return @ptrCast(*const ID2D1GradientStopCollection1.VTable, self.vtable).GetBufferPrecision(@ptrCast(*const ID2D1GradientStopCollection1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientStopCollection1_GetColorInterpolationMode(self: *const T) callconv(.Inline) D2D1_COLOR_INTERPOLATION_MODE {
return @ptrCast(*const ID2D1GradientStopCollection1.VTable, self.vtable).GetColorInterpolationMode(@ptrCast(*const ID2D1GradientStopCollection1, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1DrawingStateBlock1_Value = @import("../zig.zig").Guid.initString("689f1f85-c72e-4e33-8f19-85754efd5ace");
pub const IID_ID2D1DrawingStateBlock1 = &IID_ID2D1DrawingStateBlock1_Value;
pub const ID2D1DrawingStateBlock1 = extern struct {
pub const VTable = extern struct {
base: ID2D1DrawingStateBlock.VTable,
GetDescription: fn(
self: *const ID2D1DrawingStateBlock1,
stateDescription: ?*D2D1_DRAWING_STATE_DESCRIPTION1,
) callconv(@import("std").os.windows.WINAPI) void,
SetDescription: fn(
self: *const ID2D1DrawingStateBlock1,
stateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION1,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DrawingStateBlock.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock1_GetDescription(self: *const T, stateDescription: ?*D2D1_DRAWING_STATE_DESCRIPTION1) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock1.VTable, self.vtable).GetDescription(@ptrCast(*const ID2D1DrawingStateBlock1, self), stateDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawingStateBlock1_SetDescription(self: *const T, stateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION1) callconv(.Inline) void {
return @ptrCast(*const ID2D1DrawingStateBlock1.VTable, self.vtable).SetDescription(@ptrCast(*const ID2D1DrawingStateBlock1, self), stateDescription);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1DeviceContext_Value = @import("../zig.zig").Guid.initString("e8f7fe7a-191c-466d-ad95-975678bda998");
pub const IID_ID2D1DeviceContext = &IID_ID2D1DeviceContext_Value;
pub const ID2D1DeviceContext = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderTarget.VTable,
CreateBitmap: fn(
self: *const ID2D1DeviceContext,
size: D2D_SIZE_U,
sourceData: ?*const anyopaque,
pitch: u32,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1,
bitmap: ?*?*ID2D1Bitmap1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBitmapFromWicBitmap: fn(
self: *const ID2D1DeviceContext,
wicBitmapSource: ?*IWICBitmapSource,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1,
bitmap: ?*?*ID2D1Bitmap1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContext: fn(
self: *const ID2D1DeviceContext,
space: D2D1_COLOR_SPACE,
profile: ?[*:0]const u8,
profileSize: u32,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromFilename: fn(
self: *const ID2D1DeviceContext,
filename: ?[*:0]const u16,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromWicColorContext: fn(
self: *const ID2D1DeviceContext,
wicColorContext: ?*IWICColorContext,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBitmapFromDxgiSurface: fn(
self: *const ID2D1DeviceContext,
surface: ?*IDXGISurface,
bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1,
bitmap: ?*?*ID2D1Bitmap1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateEffect: fn(
self: *const ID2D1DeviceContext,
effectId: ?*const Guid,
effect: ?*?*ID2D1Effect,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGradientStopCollection: fn(
self: *const ID2D1DeviceContext,
straightAlphaGradientStops: [*]const D2D1_GRADIENT_STOP,
straightAlphaGradientStopsCount: u32,
preInterpolationSpace: D2D1_COLOR_SPACE,
postInterpolationSpace: D2D1_COLOR_SPACE,
bufferPrecision: D2D1_BUFFER_PRECISION,
extendMode: D2D1_EXTEND_MODE,
colorInterpolationMode: D2D1_COLOR_INTERPOLATION_MODE,
gradientStopCollection1: ?*?*ID2D1GradientStopCollection1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateImageBrush: fn(
self: *const ID2D1DeviceContext,
image: ?*ID2D1Image,
imageBrushProperties: ?*const D2D1_IMAGE_BRUSH_PROPERTIES,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
imageBrush: ?*?*ID2D1ImageBrush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBitmapBrush: fn(
self: *const ID2D1DeviceContext,
bitmap: ?*ID2D1Bitmap,
bitmapBrushProperties: ?*const D2D1_BITMAP_BRUSH_PROPERTIES1,
brushProperties: ?*const D2D1_BRUSH_PROPERTIES,
bitmapBrush: ?*?*ID2D1BitmapBrush1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateCommandList: fn(
self: *const ID2D1DeviceContext,
commandList: ?*?*ID2D1CommandList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsDxgiFormatSupported: fn(
self: *const ID2D1DeviceContext,
format: DXGI_FORMAT,
) callconv(@import("std").os.windows.WINAPI) BOOL,
IsBufferPrecisionSupported: fn(
self: *const ID2D1DeviceContext,
bufferPrecision: D2D1_BUFFER_PRECISION,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetImageLocalBounds: fn(
self: *const ID2D1DeviceContext,
image: ?*ID2D1Image,
localBounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetImageWorldBounds: fn(
self: *const ID2D1DeviceContext,
image: ?*ID2D1Image,
worldBounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGlyphRunWorldBounds: fn(
self: *const ID2D1DeviceContext,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
measuringMode: DWRITE_MEASURING_MODE,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDevice: fn(
self: *const ID2D1DeviceContext,
device: ?*?*ID2D1Device,
) callconv(@import("std").os.windows.WINAPI) void,
SetTarget: fn(
self: *const ID2D1DeviceContext,
image: ?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
GetTarget: fn(
self: *const ID2D1DeviceContext,
image: ?*?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) void,
SetRenderingControls: fn(
self: *const ID2D1DeviceContext,
renderingControls: ?*const D2D1_RENDERING_CONTROLS,
) callconv(@import("std").os.windows.WINAPI) void,
GetRenderingControls: fn(
self: *const ID2D1DeviceContext,
renderingControls: ?*D2D1_RENDERING_CONTROLS,
) callconv(@import("std").os.windows.WINAPI) void,
SetPrimitiveBlend: fn(
self: *const ID2D1DeviceContext,
primitiveBlend: D2D1_PRIMITIVE_BLEND,
) callconv(@import("std").os.windows.WINAPI) void,
GetPrimitiveBlend: fn(
self: *const ID2D1DeviceContext,
) callconv(@import("std").os.windows.WINAPI) D2D1_PRIMITIVE_BLEND,
SetUnitMode: fn(
self: *const ID2D1DeviceContext,
unitMode: D2D1_UNIT_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetUnitMode: fn(
self: *const ID2D1DeviceContext,
) callconv(@import("std").os.windows.WINAPI) D2D1_UNIT_MODE,
DrawGlyphRun: fn(
self: *const ID2D1DeviceContext,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
glyphRunDescription: ?*const DWRITE_GLYPH_RUN_DESCRIPTION,
foregroundBrush: ?*ID2D1Brush,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
DrawImage: fn(
self: *const ID2D1DeviceContext,
image: ?*ID2D1Image,
targetOffset: ?*const D2D_POINT_2F,
imageRectangle: ?*const D2D_RECT_F,
interpolationMode: D2D1_INTERPOLATION_MODE,
compositeMode: D2D1_COMPOSITE_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
DrawGdiMetafile: fn(
self: *const ID2D1DeviceContext,
gdiMetafile: ?*ID2D1GdiMetafile,
targetOffset: ?*const D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void,
DrawBitmap: fn(
self: *const ID2D1DeviceContext,
bitmap: ?*ID2D1Bitmap,
destinationRectangle: ?*const D2D_RECT_F,
opacity: f32,
interpolationMode: D2D1_INTERPOLATION_MODE,
sourceRectangle: ?*const D2D_RECT_F,
perspectiveTransform: ?*const D2D_MATRIX_4X4_F,
) callconv(@import("std").os.windows.WINAPI) void,
PushLayer: fn(
self: *const ID2D1DeviceContext,
layerParameters: ?*const D2D1_LAYER_PARAMETERS1,
layer: ?*ID2D1Layer,
) callconv(@import("std").os.windows.WINAPI) void,
InvalidateEffectInputRectangle: fn(
self: *const ID2D1DeviceContext,
effect: ?*ID2D1Effect,
input: u32,
inputRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetEffectInvalidRectangleCount: fn(
self: *const ID2D1DeviceContext,
effect: ?*ID2D1Effect,
rectangleCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetEffectInvalidRectangles: fn(
self: *const ID2D1DeviceContext,
effect: ?*ID2D1Effect,
rectangles: [*]D2D_RECT_F,
rectanglesCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetEffectRequiredInputRectangles: fn(
self: *const ID2D1DeviceContext,
renderEffect: ?*ID2D1Effect,
renderImageRectangle: ?*const D2D_RECT_F,
inputDescriptions: [*]const D2D1_EFFECT_INPUT_DESCRIPTION,
requiredInputRects: [*]D2D_RECT_F,
inputCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FillOpacityMask: fn(
self: *const ID2D1DeviceContext,
opacityMask: ?*ID2D1Bitmap,
brush: ?*ID2D1Brush,
destinationRectangle: ?*const D2D_RECT_F,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderTarget.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateBitmap(self: *const T, size: D2D_SIZE_U, sourceData: ?*const anyopaque, pitch: u32, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1, bitmap: ?*?*ID2D1Bitmap1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateBitmap(@ptrCast(*const ID2D1DeviceContext, self), size, sourceData, pitch, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateBitmapFromWicBitmap(self: *const T, wicBitmapSource: ?*IWICBitmapSource, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1, bitmap: ?*?*ID2D1Bitmap1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateBitmapFromWicBitmap(@ptrCast(*const ID2D1DeviceContext, self), wicBitmapSource, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateColorContext(self: *const T, space: D2D1_COLOR_SPACE, profile: ?[*:0]const u8, profileSize: u32, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateColorContext(@ptrCast(*const ID2D1DeviceContext, self), space, profile, profileSize, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateColorContextFromFilename(self: *const T, filename: ?[*:0]const u16, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateColorContextFromFilename(@ptrCast(*const ID2D1DeviceContext, self), filename, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateColorContextFromWicColorContext(self: *const T, wicColorContext: ?*IWICColorContext, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateColorContextFromWicColorContext(@ptrCast(*const ID2D1DeviceContext, self), wicColorContext, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateBitmapFromDxgiSurface(self: *const T, surface: ?*IDXGISurface, bitmapProperties: ?*const D2D1_BITMAP_PROPERTIES1, bitmap: ?*?*ID2D1Bitmap1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateBitmapFromDxgiSurface(@ptrCast(*const ID2D1DeviceContext, self), surface, bitmapProperties, bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateEffect(self: *const T, effectId: ?*const Guid, effect: ?*?*ID2D1Effect) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateEffect(@ptrCast(*const ID2D1DeviceContext, self), effectId, effect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateGradientStopCollection(self: *const T, straightAlphaGradientStops: [*]const D2D1_GRADIENT_STOP, straightAlphaGradientStopsCount: u32, preInterpolationSpace: D2D1_COLOR_SPACE, postInterpolationSpace: D2D1_COLOR_SPACE, bufferPrecision: D2D1_BUFFER_PRECISION, extendMode: D2D1_EXTEND_MODE, colorInterpolationMode: D2D1_COLOR_INTERPOLATION_MODE, gradientStopCollection1: ?*?*ID2D1GradientStopCollection1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateGradientStopCollection(@ptrCast(*const ID2D1DeviceContext, self), straightAlphaGradientStops, straightAlphaGradientStopsCount, preInterpolationSpace, postInterpolationSpace, bufferPrecision, extendMode, colorInterpolationMode, gradientStopCollection1);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateImageBrush(self: *const T, image: ?*ID2D1Image, imageBrushProperties: ?*const D2D1_IMAGE_BRUSH_PROPERTIES, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, imageBrush: ?*?*ID2D1ImageBrush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateImageBrush(@ptrCast(*const ID2D1DeviceContext, self), image, imageBrushProperties, brushProperties, imageBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateBitmapBrush(self: *const T, bitmap: ?*ID2D1Bitmap, bitmapBrushProperties: ?*const D2D1_BITMAP_BRUSH_PROPERTIES1, brushProperties: ?*const D2D1_BRUSH_PROPERTIES, bitmapBrush: ?*?*ID2D1BitmapBrush1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateBitmapBrush(@ptrCast(*const ID2D1DeviceContext, self), bitmap, bitmapBrushProperties, brushProperties, bitmapBrush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_CreateCommandList(self: *const T, commandList: ?*?*ID2D1CommandList) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).CreateCommandList(@ptrCast(*const ID2D1DeviceContext, self), commandList);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_IsDxgiFormatSupported(self: *const T, format: DXGI_FORMAT) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).IsDxgiFormatSupported(@ptrCast(*const ID2D1DeviceContext, self), format);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_IsBufferPrecisionSupported(self: *const T, bufferPrecision: D2D1_BUFFER_PRECISION) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).IsBufferPrecisionSupported(@ptrCast(*const ID2D1DeviceContext, self), bufferPrecision);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetImageLocalBounds(self: *const T, image: ?*ID2D1Image, localBounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetImageLocalBounds(@ptrCast(*const ID2D1DeviceContext, self), image, localBounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetImageWorldBounds(self: *const T, image: ?*ID2D1Image, worldBounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetImageWorldBounds(@ptrCast(*const ID2D1DeviceContext, self), image, worldBounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetGlyphRunWorldBounds(self: *const T, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, measuringMode: DWRITE_MEASURING_MODE, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetGlyphRunWorldBounds(@ptrCast(*const ID2D1DeviceContext, self), baselineOrigin, glyphRun, measuringMode, bounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetDevice(self: *const T, device: ?*?*ID2D1Device) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetDevice(@ptrCast(*const ID2D1DeviceContext, self), device);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_SetTarget(self: *const T, image: ?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).SetTarget(@ptrCast(*const ID2D1DeviceContext, self), image);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetTarget(self: *const T, image: ?*?*ID2D1Image) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetTarget(@ptrCast(*const ID2D1DeviceContext, self), image);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_SetRenderingControls(self: *const T, renderingControls: ?*const D2D1_RENDERING_CONTROLS) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).SetRenderingControls(@ptrCast(*const ID2D1DeviceContext, self), renderingControls);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetRenderingControls(self: *const T, renderingControls: ?*D2D1_RENDERING_CONTROLS) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetRenderingControls(@ptrCast(*const ID2D1DeviceContext, self), renderingControls);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_SetPrimitiveBlend(self: *const T, primitiveBlend: D2D1_PRIMITIVE_BLEND) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).SetPrimitiveBlend(@ptrCast(*const ID2D1DeviceContext, self), primitiveBlend);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetPrimitiveBlend(self: *const T) callconv(.Inline) D2D1_PRIMITIVE_BLEND {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetPrimitiveBlend(@ptrCast(*const ID2D1DeviceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_SetUnitMode(self: *const T, unitMode: D2D1_UNIT_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).SetUnitMode(@ptrCast(*const ID2D1DeviceContext, self), unitMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetUnitMode(self: *const T) callconv(.Inline) D2D1_UNIT_MODE {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetUnitMode(@ptrCast(*const ID2D1DeviceContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_DrawGlyphRun(self: *const T, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, glyphRunDescription: ?*const DWRITE_GLYPH_RUN_DESCRIPTION, foregroundBrush: ?*ID2D1Brush, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).DrawGlyphRun(@ptrCast(*const ID2D1DeviceContext, self), baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_DrawImage(self: *const T, image: ?*ID2D1Image, targetOffset: ?*const D2D_POINT_2F, imageRectangle: ?*const D2D_RECT_F, interpolationMode: D2D1_INTERPOLATION_MODE, compositeMode: D2D1_COMPOSITE_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).DrawImage(@ptrCast(*const ID2D1DeviceContext, self), image, targetOffset, imageRectangle, interpolationMode, compositeMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_DrawGdiMetafile(self: *const T, gdiMetafile: ?*ID2D1GdiMetafile, targetOffset: ?*const D2D_POINT_2F) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).DrawGdiMetafile(@ptrCast(*const ID2D1DeviceContext, self), gdiMetafile, targetOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_DrawBitmap(self: *const T, bitmap: ?*ID2D1Bitmap, destinationRectangle: ?*const D2D_RECT_F, opacity: f32, interpolationMode: D2D1_INTERPOLATION_MODE, sourceRectangle: ?*const D2D_RECT_F, perspectiveTransform: ?*const D2D_MATRIX_4X4_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).DrawBitmap(@ptrCast(*const ID2D1DeviceContext, self), bitmap, destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_PushLayer(self: *const T, layerParameters: ?*const D2D1_LAYER_PARAMETERS1, layer: ?*ID2D1Layer) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).PushLayer(@ptrCast(*const ID2D1DeviceContext, self), layerParameters, layer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_InvalidateEffectInputRectangle(self: *const T, effect: ?*ID2D1Effect, input: u32, inputRectangle: ?*const D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).InvalidateEffectInputRectangle(@ptrCast(*const ID2D1DeviceContext, self), effect, input, inputRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetEffectInvalidRectangleCount(self: *const T, effect: ?*ID2D1Effect, rectangleCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetEffectInvalidRectangleCount(@ptrCast(*const ID2D1DeviceContext, self), effect, rectangleCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetEffectInvalidRectangles(self: *const T, effect: ?*ID2D1Effect, rectangles: [*]D2D_RECT_F, rectanglesCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetEffectInvalidRectangles(@ptrCast(*const ID2D1DeviceContext, self), effect, rectangles, rectanglesCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_GetEffectRequiredInputRectangles(self: *const T, renderEffect: ?*ID2D1Effect, renderImageRectangle: ?*const D2D_RECT_F, inputDescriptions: [*]const D2D1_EFFECT_INPUT_DESCRIPTION, requiredInputRects: [*]D2D_RECT_F, inputCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).GetEffectRequiredInputRectangles(@ptrCast(*const ID2D1DeviceContext, self), renderEffect, renderImageRectangle, inputDescriptions, requiredInputRects, inputCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext_FillOpacityMask(self: *const T, opacityMask: ?*ID2D1Bitmap, brush: ?*ID2D1Brush, destinationRectangle: ?*const D2D_RECT_F, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext.VTable, self.vtable).FillOpacityMask(@ptrCast(*const ID2D1DeviceContext, self), opacityMask, brush, destinationRectangle, sourceRectangle);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Device_Value = @import("../zig.zig").Guid.initString("47dd575d-ac05-4cdd-8049-9b02cd16f44c");
pub const IID_ID2D1Device = &IID_ID2D1Device_Value;
pub const ID2D1Device = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext: ?*?*ID2D1DeviceContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePrintControl: fn(
self: *const ID2D1Device,
wicFactory: ?*IWICImagingFactory,
documentTarget: ?*IPrintDocumentPackageTarget,
printControlProperties: ?*const D2D1_PRINT_CONTROL_PROPERTIES,
printControl: ?*?*ID2D1PrintControl,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMaximumTextureMemory: fn(
self: *const ID2D1Device,
maximumInBytes: u64,
) callconv(@import("std").os.windows.WINAPI) void,
GetMaximumTextureMemory: fn(
self: *const ID2D1Device,
) callconv(@import("std").os.windows.WINAPI) u64,
ClearResources: fn(
self: *const ID2D1Device,
millisecondsSinceUse: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext: ?*?*ID2D1DeviceContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device, self), options, deviceContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device_CreatePrintControl(self: *const T, wicFactory: ?*IWICImagingFactory, documentTarget: ?*IPrintDocumentPackageTarget, printControlProperties: ?*const D2D1_PRINT_CONTROL_PROPERTIES, printControl: ?*?*ID2D1PrintControl) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device.VTable, self.vtable).CreatePrintControl(@ptrCast(*const ID2D1Device, self), wicFactory, documentTarget, printControlProperties, printControl);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device_SetMaximumTextureMemory(self: *const T, maximumInBytes: u64) callconv(.Inline) void {
return @ptrCast(*const ID2D1Device.VTable, self.vtable).SetMaximumTextureMemory(@ptrCast(*const ID2D1Device, self), maximumInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device_GetMaximumTextureMemory(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID2D1Device.VTable, self.vtable).GetMaximumTextureMemory(@ptrCast(*const ID2D1Device, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device_ClearResources(self: *const T, millisecondsSinceUse: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1Device.VTable, self.vtable).ClearResources(@ptrCast(*const ID2D1Device, self), millisecondsSinceUse);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Factory1_Value = @import("../zig.zig").Guid.initString("bb12d362-daee-4b9a-aa1d-14ba401cfa1f");
pub const IID_ID2D1Factory1 = &IID_ID2D1Factory1_Value;
pub const ID2D1Factory1 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory.VTable,
CreateDevice: fn(
self: *const ID2D1Factory1,
dxgiDevice: ?*IDXGIDevice,
d2dDevice: ?*?*ID2D1Device,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStrokeStyle: fn(
self: *const ID2D1Factory1,
strokeStyleProperties: ?*const D2D1_STROKE_STYLE_PROPERTIES1,
dashes: ?[*]const f32,
dashesCount: u32,
strokeStyle: ?*?*ID2D1StrokeStyle1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePathGeometry: fn(
self: *const ID2D1Factory1,
pathGeometry: ?*?*ID2D1PathGeometry1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateDrawingStateBlock: fn(
self: *const ID2D1Factory1,
drawingStateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION1,
textRenderingParams: ?*IDWriteRenderingParams,
drawingStateBlock: ?*?*ID2D1DrawingStateBlock1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGdiMetafile: fn(
self: *const ID2D1Factory1,
metafileStream: ?*IStream,
metafile: ?*?*ID2D1GdiMetafile,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterEffectFromStream: fn(
self: *const ID2D1Factory1,
classId: ?*const Guid,
propertyXml: ?*IStream,
bindings: ?[*]const D2D1_PROPERTY_BINDING,
bindingsCount: u32,
effectFactory: ?PD2D1_EFFECT_FACTORY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterEffectFromString: fn(
self: *const ID2D1Factory1,
classId: ?*const Guid,
propertyXml: ?[*:0]const u16,
bindings: ?[*]const D2D1_PROPERTY_BINDING,
bindingsCount: u32,
effectFactory: ?PD2D1_EFFECT_FACTORY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterEffect: fn(
self: *const ID2D1Factory1,
classId: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisteredEffects: fn(
self: *const ID2D1Factory1,
effects: ?[*]Guid,
effectsCount: u32,
effectsReturned: ?*u32,
effectsRegistered: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetEffectProperties: fn(
self: *const ID2D1Factory1,
effectId: ?*const Guid,
properties: ?*?*ID2D1Properties,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice: ?*?*ID2D1Device) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory1, self), dxgiDevice, d2dDevice);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_CreateStrokeStyle(self: *const T, strokeStyleProperties: ?*const D2D1_STROKE_STYLE_PROPERTIES1, dashes: ?[*]const f32, dashesCount: u32, strokeStyle: ?*?*ID2D1StrokeStyle1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).CreateStrokeStyle(@ptrCast(*const ID2D1Factory1, self), strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_CreatePathGeometry(self: *const T, pathGeometry: ?*?*ID2D1PathGeometry1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).CreatePathGeometry(@ptrCast(*const ID2D1Factory1, self), pathGeometry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_CreateDrawingStateBlock(self: *const T, drawingStateDescription: ?*const D2D1_DRAWING_STATE_DESCRIPTION1, textRenderingParams: ?*IDWriteRenderingParams, drawingStateBlock: ?*?*ID2D1DrawingStateBlock1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).CreateDrawingStateBlock(@ptrCast(*const ID2D1Factory1, self), drawingStateDescription, textRenderingParams, drawingStateBlock);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_CreateGdiMetafile(self: *const T, metafileStream: ?*IStream, metafile: ?*?*ID2D1GdiMetafile) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).CreateGdiMetafile(@ptrCast(*const ID2D1Factory1, self), metafileStream, metafile);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_RegisterEffectFromStream(self: *const T, classId: ?*const Guid, propertyXml: ?*IStream, bindings: ?[*]const D2D1_PROPERTY_BINDING, bindingsCount: u32, effectFactory: ?PD2D1_EFFECT_FACTORY) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).RegisterEffectFromStream(@ptrCast(*const ID2D1Factory1, self), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_RegisterEffectFromString(self: *const T, classId: ?*const Guid, propertyXml: ?[*:0]const u16, bindings: ?[*]const D2D1_PROPERTY_BINDING, bindingsCount: u32, effectFactory: ?PD2D1_EFFECT_FACTORY) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).RegisterEffectFromString(@ptrCast(*const ID2D1Factory1, self), classId, propertyXml, bindings, bindingsCount, effectFactory);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_UnregisterEffect(self: *const T, classId: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).UnregisterEffect(@ptrCast(*const ID2D1Factory1, self), classId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_GetRegisteredEffects(self: *const T, effects: ?[*]Guid, effectsCount: u32, effectsReturned: ?*u32, effectsRegistered: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).GetRegisteredEffects(@ptrCast(*const ID2D1Factory1, self), effects, effectsCount, effectsReturned, effectsRegistered);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory1_GetEffectProperties(self: *const T, effectId: ?*const Guid, properties: ?*?*ID2D1Properties) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory1.VTable, self.vtable).GetEffectProperties(@ptrCast(*const ID2D1Factory1, self), effectId, properties);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Multithread_Value = @import("../zig.zig").Guid.initString("31e6e7bc-e0ff-4d46-8c64-a0a8c41c15d3");
pub const IID_ID2D1Multithread = &IID_ID2D1Multithread_Value;
pub const ID2D1Multithread = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetMultithreadProtected: fn(
self: *const ID2D1Multithread,
) callconv(@import("std").os.windows.WINAPI) BOOL,
Enter: fn(
self: *const ID2D1Multithread,
) callconv(@import("std").os.windows.WINAPI) void,
Leave: fn(
self: *const ID2D1Multithread,
) callconv(@import("std").os.windows.WINAPI) void,
};
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 ID2D1Multithread_GetMultithreadProtected(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1Multithread.VTable, self.vtable).GetMultithreadProtected(@ptrCast(*const ID2D1Multithread, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Multithread_Enter(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1Multithread.VTable, self.vtable).Enter(@ptrCast(*const ID2D1Multithread, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Multithread_Leave(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1Multithread.VTable, self.vtable).Leave(@ptrCast(*const ID2D1Multithread, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const Matrix4x3F = extern struct {
__AnonymousBase_d2d1_1helper_L45_C31: D2D_MATRIX_4X3_F,
};
pub const Matrix4x4F = extern struct {
__AnonymousBase_d2d1_1helper_L97_C31: D2D_MATRIX_4X4_F,
};
pub const Matrix5x4F = extern struct {
__AnonymousBase_d2d1_1helper_L472_C31: D2D_MATRIX_5X4_F,
};
pub const PD2D1_PROPERTY_SET_FUNCTION = fn(
effect: ?*IUnknown,
data: [*:0]const u8,
dataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const PD2D1_PROPERTY_GET_FUNCTION = fn(
effect: ?*IUnknown,
data: ?[*:0]u8,
dataSize: u32,
actualSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const D2D1_CHANGE_TYPE = enum(u32) {
NONE = 0,
PROPERTIES = 1,
CONTEXT = 2,
GRAPH = 3,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
PROPERTIES: u1 = 0,
CONTEXT: u1 = 0,
GRAPH: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_CHANGE_TYPE {
return @intToEnum(D2D1_CHANGE_TYPE,
(if (o.NONE == 1) @enumToInt(D2D1_CHANGE_TYPE.NONE) else 0)
| (if (o.PROPERTIES == 1) @enumToInt(D2D1_CHANGE_TYPE.PROPERTIES) else 0)
| (if (o.CONTEXT == 1) @enumToInt(D2D1_CHANGE_TYPE.CONTEXT) else 0)
| (if (o.GRAPH == 1) @enumToInt(D2D1_CHANGE_TYPE.GRAPH) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_CHANGE_TYPE.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_CHANGE_TYPE_NONE = D2D1_CHANGE_TYPE.NONE;
pub const D2D1_CHANGE_TYPE_PROPERTIES = D2D1_CHANGE_TYPE.PROPERTIES;
pub const D2D1_CHANGE_TYPE_CONTEXT = D2D1_CHANGE_TYPE.CONTEXT;
pub const D2D1_CHANGE_TYPE_GRAPH = D2D1_CHANGE_TYPE.GRAPH;
pub const D2D1_CHANGE_TYPE_FORCE_DWORD = D2D1_CHANGE_TYPE.FORCE_DWORD;
pub const D2D1_PIXEL_OPTIONS = enum(u32) {
NONE = 0,
TRIVIAL_SAMPLING = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
TRIVIAL_SAMPLING: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_PIXEL_OPTIONS {
return @intToEnum(D2D1_PIXEL_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_PIXEL_OPTIONS.NONE) else 0)
| (if (o.TRIVIAL_SAMPLING == 1) @enumToInt(D2D1_PIXEL_OPTIONS.TRIVIAL_SAMPLING) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_PIXEL_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_PIXEL_OPTIONS_NONE = D2D1_PIXEL_OPTIONS.NONE;
pub const D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING = D2D1_PIXEL_OPTIONS.TRIVIAL_SAMPLING;
pub const D2D1_PIXEL_OPTIONS_FORCE_DWORD = D2D1_PIXEL_OPTIONS.FORCE_DWORD;
pub const D2D1_VERTEX_OPTIONS = enum(u32) {
NONE = 0,
DO_NOT_CLEAR = 1,
USE_DEPTH_BUFFER = 2,
ASSUME_NO_OVERLAP = 4,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DO_NOT_CLEAR: u1 = 0,
USE_DEPTH_BUFFER: u1 = 0,
ASSUME_NO_OVERLAP: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_VERTEX_OPTIONS {
return @intToEnum(D2D1_VERTEX_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_VERTEX_OPTIONS.NONE) else 0)
| (if (o.DO_NOT_CLEAR == 1) @enumToInt(D2D1_VERTEX_OPTIONS.DO_NOT_CLEAR) else 0)
| (if (o.USE_DEPTH_BUFFER == 1) @enumToInt(D2D1_VERTEX_OPTIONS.USE_DEPTH_BUFFER) else 0)
| (if (o.ASSUME_NO_OVERLAP == 1) @enumToInt(D2D1_VERTEX_OPTIONS.ASSUME_NO_OVERLAP) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_VERTEX_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_VERTEX_OPTIONS_NONE = D2D1_VERTEX_OPTIONS.NONE;
pub const D2D1_VERTEX_OPTIONS_DO_NOT_CLEAR = D2D1_VERTEX_OPTIONS.DO_NOT_CLEAR;
pub const D2D1_VERTEX_OPTIONS_USE_DEPTH_BUFFER = D2D1_VERTEX_OPTIONS.USE_DEPTH_BUFFER;
pub const D2D1_VERTEX_OPTIONS_ASSUME_NO_OVERLAP = D2D1_VERTEX_OPTIONS.ASSUME_NO_OVERLAP;
pub const D2D1_VERTEX_OPTIONS_FORCE_DWORD = D2D1_VERTEX_OPTIONS.FORCE_DWORD;
pub const D2D1_VERTEX_USAGE = enum(u32) {
STATIC = 0,
DYNAMIC = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_VERTEX_USAGE_STATIC = D2D1_VERTEX_USAGE.STATIC;
pub const D2D1_VERTEX_USAGE_DYNAMIC = D2D1_VERTEX_USAGE.DYNAMIC;
pub const D2D1_VERTEX_USAGE_FORCE_DWORD = D2D1_VERTEX_USAGE.FORCE_DWORD;
pub const D2D1_BLEND_OPERATION = enum(u32) {
ADD = 1,
SUBTRACT = 2,
REV_SUBTRACT = 3,
MIN = 4,
MAX = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BLEND_OPERATION_ADD = D2D1_BLEND_OPERATION.ADD;
pub const D2D1_BLEND_OPERATION_SUBTRACT = D2D1_BLEND_OPERATION.SUBTRACT;
pub const D2D1_BLEND_OPERATION_REV_SUBTRACT = D2D1_BLEND_OPERATION.REV_SUBTRACT;
pub const D2D1_BLEND_OPERATION_MIN = D2D1_BLEND_OPERATION.MIN;
pub const D2D1_BLEND_OPERATION_MAX = D2D1_BLEND_OPERATION.MAX;
pub const D2D1_BLEND_OPERATION_FORCE_DWORD = D2D1_BLEND_OPERATION.FORCE_DWORD;
pub const D2D1_BLEND = enum(u32) {
ZERO = 1,
ONE = 2,
SRC_COLOR = 3,
INV_SRC_COLOR = 4,
SRC_ALPHA = 5,
INV_SRC_ALPHA = 6,
DEST_ALPHA = 7,
INV_DEST_ALPHA = 8,
DEST_COLOR = 9,
INV_DEST_COLOR = 10,
SRC_ALPHA_SAT = 11,
BLEND_FACTOR = 14,
INV_BLEND_FACTOR = 15,
FORCE_DWORD = 4294967295,
};
pub const D2D1_BLEND_ZERO = D2D1_BLEND.ZERO;
pub const D2D1_BLEND_ONE = D2D1_BLEND.ONE;
pub const D2D1_BLEND_SRC_COLOR = D2D1_BLEND.SRC_COLOR;
pub const D2D1_BLEND_INV_SRC_COLOR = D2D1_BLEND.INV_SRC_COLOR;
pub const D2D1_BLEND_SRC_ALPHA = D2D1_BLEND.SRC_ALPHA;
pub const D2D1_BLEND_INV_SRC_ALPHA = D2D1_BLEND.INV_SRC_ALPHA;
pub const D2D1_BLEND_DEST_ALPHA = D2D1_BLEND.DEST_ALPHA;
pub const D2D1_BLEND_INV_DEST_ALPHA = D2D1_BLEND.INV_DEST_ALPHA;
pub const D2D1_BLEND_DEST_COLOR = D2D1_BLEND.DEST_COLOR;
pub const D2D1_BLEND_INV_DEST_COLOR = D2D1_BLEND.INV_DEST_COLOR;
pub const D2D1_BLEND_SRC_ALPHA_SAT = D2D1_BLEND.SRC_ALPHA_SAT;
pub const D2D1_BLEND_BLEND_FACTOR = D2D1_BLEND.BLEND_FACTOR;
pub const D2D1_BLEND_INV_BLEND_FACTOR = D2D1_BLEND.INV_BLEND_FACTOR;
pub const D2D1_BLEND_FORCE_DWORD = D2D1_BLEND.FORCE_DWORD;
pub const D2D1_CHANNEL_DEPTH = enum(u32) {
DEFAULT = 0,
@"1" = 1,
@"4" = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CHANNEL_DEPTH_DEFAULT = D2D1_CHANNEL_DEPTH.DEFAULT;
pub const D2D1_CHANNEL_DEPTH_1 = D2D1_CHANNEL_DEPTH.@"1";
pub const D2D1_CHANNEL_DEPTH_4 = D2D1_CHANNEL_DEPTH.@"4";
pub const D2D1_CHANNEL_DEPTH_FORCE_DWORD = D2D1_CHANNEL_DEPTH.FORCE_DWORD;
pub const D2D1_FILTER = enum(u32) {
MIN_MAG_MIP_POINT = 0,
MIN_MAG_POINT_MIP_LINEAR = 1,
MIN_POINT_MAG_LINEAR_MIP_POINT = 4,
MIN_POINT_MAG_MIP_LINEAR = 5,
MIN_LINEAR_MAG_MIP_POINT = 16,
MIN_LINEAR_MAG_POINT_MIP_LINEAR = 17,
MIN_MAG_LINEAR_MIP_POINT = 20,
MIN_MAG_MIP_LINEAR = 21,
ANISOTROPIC = 85,
FORCE_DWORD = 4294967295,
};
pub const D2D1_FILTER_MIN_MAG_MIP_POINT = D2D1_FILTER.MIN_MAG_MIP_POINT;
pub const D2D1_FILTER_MIN_MAG_POINT_MIP_LINEAR = D2D1_FILTER.MIN_MAG_POINT_MIP_LINEAR;
pub const D2D1_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = D2D1_FILTER.MIN_POINT_MAG_LINEAR_MIP_POINT;
pub const D2D1_FILTER_MIN_POINT_MAG_MIP_LINEAR = D2D1_FILTER.MIN_POINT_MAG_MIP_LINEAR;
pub const D2D1_FILTER_MIN_LINEAR_MAG_MIP_POINT = D2D1_FILTER.MIN_LINEAR_MAG_MIP_POINT;
pub const D2D1_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = D2D1_FILTER.MIN_LINEAR_MAG_POINT_MIP_LINEAR;
pub const D2D1_FILTER_MIN_MAG_LINEAR_MIP_POINT = D2D1_FILTER.MIN_MAG_LINEAR_MIP_POINT;
pub const D2D1_FILTER_MIN_MAG_MIP_LINEAR = D2D1_FILTER.MIN_MAG_MIP_LINEAR;
pub const D2D1_FILTER_ANISOTROPIC = D2D1_FILTER.ANISOTROPIC;
pub const D2D1_FILTER_FORCE_DWORD = D2D1_FILTER.FORCE_DWORD;
pub const D2D1_FEATURE = enum(u32) {
DOUBLES = 0,
D3D10_X_HARDWARE_OPTIONS = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_FEATURE_DOUBLES = D2D1_FEATURE.DOUBLES;
pub const D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS = D2D1_FEATURE.D3D10_X_HARDWARE_OPTIONS;
pub const D2D1_FEATURE_FORCE_DWORD = D2D1_FEATURE.FORCE_DWORD;
pub const D2D1_PROPERTY_BINDING = extern struct {
propertyName: ?[*:0]const u16,
setFunction: ?PD2D1_PROPERTY_SET_FUNCTION,
getFunction: ?PD2D1_PROPERTY_GET_FUNCTION,
};
pub const D2D1_RESOURCE_TEXTURE_PROPERTIES = extern struct {
extents: ?*const u32,
dimensions: u32,
bufferPrecision: D2D1_BUFFER_PRECISION,
channelDepth: D2D1_CHANNEL_DEPTH,
filter: D2D1_FILTER,
extendModes: ?*const D2D1_EXTEND_MODE,
};
pub const D2D1_INPUT_ELEMENT_DESC = extern struct {
semanticName: ?[*:0]const u8,
semanticIndex: u32,
format: DXGI_FORMAT,
inputSlot: u32,
alignedByteOffset: u32,
};
pub const D2D1_VERTEX_BUFFER_PROPERTIES = extern struct {
inputCount: u32,
usage: D2D1_VERTEX_USAGE,
data: ?*const u8,
byteWidth: u32,
};
pub const D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES = extern struct {
shaderBufferWithInputSignature: ?*const u8,
shaderBufferSize: u32,
inputElements: ?*const D2D1_INPUT_ELEMENT_DESC,
elementCount: u32,
stride: u32,
};
pub const D2D1_VERTEX_RANGE = extern struct {
startVertex: u32,
vertexCount: u32,
};
pub const D2D1_BLEND_DESCRIPTION = extern struct {
sourceBlend: D2D1_BLEND,
destinationBlend: D2D1_BLEND,
blendOperation: D2D1_BLEND_OPERATION,
sourceBlendAlpha: D2D1_BLEND,
destinationBlendAlpha: D2D1_BLEND,
blendOperationAlpha: D2D1_BLEND_OPERATION,
blendFactor: [4]f32,
};
pub const D2D1_INPUT_DESCRIPTION = extern struct {
filter: D2D1_FILTER,
levelOfDetailCount: u32,
};
pub const D2D1_FEATURE_DATA_DOUBLES = extern struct {
doublePrecisionFloatShaderOps: BOOL,
};
pub const D2D1_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS = extern struct {
computeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x: BOOL,
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1VertexBuffer_Value = @import("../zig.zig").Guid.initString("9b8b1336-00a5-4668-92b7-ced5d8bf9b7b");
pub const IID_ID2D1VertexBuffer = &IID_ID2D1VertexBuffer_Value;
pub const ID2D1VertexBuffer = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Map: fn(
self: *const ID2D1VertexBuffer,
data: ?*?*u8,
bufferSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unmap: fn(
self: *const ID2D1VertexBuffer,
) 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 ID2D1VertexBuffer_Map(self: *const T, data: ?*?*u8, bufferSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1VertexBuffer.VTable, self.vtable).Map(@ptrCast(*const ID2D1VertexBuffer, self), data, bufferSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1VertexBuffer_Unmap(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1VertexBuffer.VTable, self.vtable).Unmap(@ptrCast(*const ID2D1VertexBuffer, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ResourceTexture_Value = @import("../zig.zig").Guid.initString("688d15c3-02b0-438d-b13a-d1b44c32c39a");
pub const IID_ID2D1ResourceTexture = &IID_ID2D1ResourceTexture_Value;
pub const ID2D1ResourceTexture = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Update: fn(
self: *const ID2D1ResourceTexture,
minimumExtents: ?[*]const u32,
maximimumExtents: ?[*]const u32,
strides: ?*const u32,
dimensions: u32,
data: [*:0]const u8,
dataCount: 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 ID2D1ResourceTexture_Update(self: *const T, minimumExtents: ?[*]const u32, maximimumExtents: ?[*]const u32, strides: ?*const u32, dimensions: u32, data: [*:0]const u8, dataCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ResourceTexture.VTable, self.vtable).Update(@ptrCast(*const ID2D1ResourceTexture, self), minimumExtents, maximimumExtents, strides, dimensions, data, dataCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1RenderInfo_Value = @import("../zig.zig").Guid.initString("519ae1bd-d19a-420d-b849-364f594776b7");
pub const IID_ID2D1RenderInfo = &IID_ID2D1RenderInfo_Value;
pub const ID2D1RenderInfo = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetInputDescription: fn(
self: *const ID2D1RenderInfo,
inputIndex: u32,
inputDescription: D2D1_INPUT_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOutputBuffer: fn(
self: *const ID2D1RenderInfo,
bufferPrecision: D2D1_BUFFER_PRECISION,
channelDepth: D2D1_CHANNEL_DEPTH,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCached: fn(
self: *const ID2D1RenderInfo,
isCached: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
SetInstructionCountHint: fn(
self: *const ID2D1RenderInfo,
instructionCount: u32,
) callconv(@import("std").os.windows.WINAPI) void,
};
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 ID2D1RenderInfo_SetInputDescription(self: *const T, inputIndex: u32, inputDescription: D2D1_INPUT_DESCRIPTION) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderInfo.VTable, self.vtable).SetInputDescription(@ptrCast(*const ID2D1RenderInfo, self), inputIndex, inputDescription);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderInfo_SetOutputBuffer(self: *const T, bufferPrecision: D2D1_BUFFER_PRECISION, channelDepth: D2D1_CHANNEL_DEPTH) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1RenderInfo.VTable, self.vtable).SetOutputBuffer(@ptrCast(*const ID2D1RenderInfo, self), bufferPrecision, channelDepth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderInfo_SetCached(self: *const T, isCached: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderInfo.VTable, self.vtable).SetCached(@ptrCast(*const ID2D1RenderInfo, self), isCached);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1RenderInfo_SetInstructionCountHint(self: *const T, instructionCount: u32) callconv(.Inline) void {
return @ptrCast(*const ID2D1RenderInfo.VTable, self.vtable).SetInstructionCountHint(@ptrCast(*const ID2D1RenderInfo, self), instructionCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1DrawInfo_Value = @import("../zig.zig").Guid.initString("693ce632-7f2f-45de-93fe-18d88b37aa21");
pub const IID_ID2D1DrawInfo = &IID_ID2D1DrawInfo_Value;
pub const ID2D1DrawInfo = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderInfo.VTable,
SetPixelShaderConstantBuffer: fn(
self: *const ID2D1DrawInfo,
buffer: [*:0]const u8,
bufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetResourceTexture: fn(
self: *const ID2D1DrawInfo,
textureIndex: u32,
resourceTexture: ?*ID2D1ResourceTexture,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetVertexShaderConstantBuffer: fn(
self: *const ID2D1DrawInfo,
buffer: [*:0]const u8,
bufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPixelShader: fn(
self: *const ID2D1DrawInfo,
shaderId: ?*const Guid,
pixelOptions: D2D1_PIXEL_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetVertexProcessing: fn(
self: *const ID2D1DrawInfo,
vertexBuffer: ?*ID2D1VertexBuffer,
vertexOptions: D2D1_VERTEX_OPTIONS,
blendDescription: ?*const D2D1_BLEND_DESCRIPTION,
vertexRange: ?*const D2D1_VERTEX_RANGE,
vertexShader: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderInfo.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawInfo_SetPixelShaderConstantBuffer(self: *const T, buffer: [*:0]const u8, bufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawInfo.VTable, self.vtable).SetPixelShaderConstantBuffer(@ptrCast(*const ID2D1DrawInfo, self), buffer, bufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawInfo_SetResourceTexture(self: *const T, textureIndex: u32, resourceTexture: ?*ID2D1ResourceTexture) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawInfo.VTable, self.vtable).SetResourceTexture(@ptrCast(*const ID2D1DrawInfo, self), textureIndex, resourceTexture);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawInfo_SetVertexShaderConstantBuffer(self: *const T, buffer: [*:0]const u8, bufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawInfo.VTable, self.vtable).SetVertexShaderConstantBuffer(@ptrCast(*const ID2D1DrawInfo, self), buffer, bufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawInfo_SetPixelShader(self: *const T, shaderId: ?*const Guid, pixelOptions: D2D1_PIXEL_OPTIONS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawInfo.VTable, self.vtable).SetPixelShader(@ptrCast(*const ID2D1DrawInfo, self), shaderId, pixelOptions);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawInfo_SetVertexProcessing(self: *const T, vertexBuffer: ?*ID2D1VertexBuffer, vertexOptions: D2D1_VERTEX_OPTIONS, blendDescription: ?*const D2D1_BLEND_DESCRIPTION, vertexRange: ?*const D2D1_VERTEX_RANGE, vertexShader: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawInfo.VTable, self.vtable).SetVertexProcessing(@ptrCast(*const ID2D1DrawInfo, self), vertexBuffer, vertexOptions, blendDescription, vertexRange, vertexShader);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ComputeInfo_Value = @import("../zig.zig").Guid.initString("5598b14b-9fd7-48b7-9bdb-8f0964eb38bc");
pub const IID_ID2D1ComputeInfo = &IID_ID2D1ComputeInfo_Value;
pub const ID2D1ComputeInfo = extern struct {
pub const VTable = extern struct {
base: ID2D1RenderInfo.VTable,
SetComputeShaderConstantBuffer: fn(
self: *const ID2D1ComputeInfo,
buffer: [*:0]const u8,
bufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetComputeShader: fn(
self: *const ID2D1ComputeInfo,
shaderId: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetResourceTexture: fn(
self: *const ID2D1ComputeInfo,
textureIndex: u32,
resourceTexture: ?*ID2D1ResourceTexture,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1RenderInfo.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ComputeInfo_SetComputeShaderConstantBuffer(self: *const T, buffer: [*:0]const u8, bufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ComputeInfo.VTable, self.vtable).SetComputeShaderConstantBuffer(@ptrCast(*const ID2D1ComputeInfo, self), buffer, bufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ComputeInfo_SetComputeShader(self: *const T, shaderId: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ComputeInfo.VTable, self.vtable).SetComputeShader(@ptrCast(*const ID2D1ComputeInfo, self), shaderId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ComputeInfo_SetResourceTexture(self: *const T, textureIndex: u32, resourceTexture: ?*ID2D1ResourceTexture) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ComputeInfo.VTable, self.vtable).SetResourceTexture(@ptrCast(*const ID2D1ComputeInfo, self), textureIndex, resourceTexture);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1TransformNode_Value = @import("../zig.zig").Guid.initString("b2efe1e7-729f-4102-949f-505fa21bf666");
pub const IID_ID2D1TransformNode = &IID_ID2D1TransformNode_Value;
pub const ID2D1TransformNode = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetInputCount: fn(
self: *const ID2D1TransformNode,
) 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 ID2D1TransformNode_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1TransformNode.VTable, self.vtable).GetInputCount(@ptrCast(*const ID2D1TransformNode, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1TransformGraph_Value = @import("../zig.zig").Guid.initString("13d29038-c3e6-4034-9081-13b53a417992");
pub const IID_ID2D1TransformGraph = &IID_ID2D1TransformGraph_Value;
pub const ID2D1TransformGraph = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetInputCount: fn(
self: *const ID2D1TransformGraph,
) callconv(@import("std").os.windows.WINAPI) u32,
SetSingleTransformNode: fn(
self: *const ID2D1TransformGraph,
node: ?*ID2D1TransformNode,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddNode: fn(
self: *const ID2D1TransformGraph,
node: ?*ID2D1TransformNode,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveNode: fn(
self: *const ID2D1TransformGraph,
node: ?*ID2D1TransformNode,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOutputNode: fn(
self: *const ID2D1TransformGraph,
node: ?*ID2D1TransformNode,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConnectNode: fn(
self: *const ID2D1TransformGraph,
fromNode: ?*ID2D1TransformNode,
toNode: ?*ID2D1TransformNode,
toNodeInputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConnectToEffectInput: fn(
self: *const ID2D1TransformGraph,
toEffectInputIndex: u32,
node: ?*ID2D1TransformNode,
toNodeInputIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clear: fn(
self: *const ID2D1TransformGraph,
) callconv(@import("std").os.windows.WINAPI) void,
SetPassthroughGraph: fn(
self: *const ID2D1TransformGraph,
effectInputIndex: 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 ID2D1TransformGraph_GetInputCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).GetInputCount(@ptrCast(*const ID2D1TransformGraph, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_SetSingleTransformNode(self: *const T, node: ?*ID2D1TransformNode) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).SetSingleTransformNode(@ptrCast(*const ID2D1TransformGraph, self), node);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_AddNode(self: *const T, node: ?*ID2D1TransformNode) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).AddNode(@ptrCast(*const ID2D1TransformGraph, self), node);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_RemoveNode(self: *const T, node: ?*ID2D1TransformNode) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).RemoveNode(@ptrCast(*const ID2D1TransformGraph, self), node);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_SetOutputNode(self: *const T, node: ?*ID2D1TransformNode) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).SetOutputNode(@ptrCast(*const ID2D1TransformGraph, self), node);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_ConnectNode(self: *const T, fromNode: ?*ID2D1TransformNode, toNode: ?*ID2D1TransformNode, toNodeInputIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).ConnectNode(@ptrCast(*const ID2D1TransformGraph, self), fromNode, toNode, toNodeInputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_ConnectToEffectInput(self: *const T, toEffectInputIndex: u32, node: ?*ID2D1TransformNode, toNodeInputIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).ConnectToEffectInput(@ptrCast(*const ID2D1TransformGraph, self), toEffectInputIndex, node, toNodeInputIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_Clear(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).Clear(@ptrCast(*const ID2D1TransformGraph, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformGraph_SetPassthroughGraph(self: *const T, effectInputIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1TransformGraph.VTable, self.vtable).SetPassthroughGraph(@ptrCast(*const ID2D1TransformGraph, self), effectInputIndex);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1Transform_Value = @import("../zig.zig").Guid.initString("ef1a287d-342a-4f76-8fdb-da0d6ea9f92b");
pub const IID_ID2D1Transform = &IID_ID2D1Transform_Value;
pub const ID2D1Transform = extern struct {
pub const VTable = extern struct {
base: ID2D1TransformNode.VTable,
MapOutputRectToInputRects: fn(
self: *const ID2D1Transform,
outputRect: ?*const RECT,
inputRects: [*]RECT,
inputRectsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MapInputRectsToOutputRect: fn(
self: *const ID2D1Transform,
inputRects: [*]const RECT,
inputOpaqueSubRects: [*]const RECT,
inputRectCount: u32,
outputRect: ?*RECT,
outputOpaqueSubRect: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MapInvalidRect: fn(
self: *const ID2D1Transform,
inputIndex: u32,
invalidInputRect: RECT,
invalidOutputRect: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1TransformNode.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Transform_MapOutputRectToInputRects(self: *const T, outputRect: ?*const RECT, inputRects: [*]RECT, inputRectsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Transform.VTable, self.vtable).MapOutputRectToInputRects(@ptrCast(*const ID2D1Transform, self), outputRect, inputRects, inputRectsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Transform_MapInputRectsToOutputRect(self: *const T, inputRects: [*]const RECT, inputOpaqueSubRects: [*]const RECT, inputRectCount: u32, outputRect: ?*RECT, outputOpaqueSubRect: ?*RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Transform.VTable, self.vtable).MapInputRectsToOutputRect(@ptrCast(*const ID2D1Transform, self), inputRects, inputOpaqueSubRects, inputRectCount, outputRect, outputOpaqueSubRect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Transform_MapInvalidRect(self: *const T, inputIndex: u32, invalidInputRect: RECT, invalidOutputRect: ?*RECT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Transform.VTable, self.vtable).MapInvalidRect(@ptrCast(*const ID2D1Transform, self), inputIndex, invalidInputRect, invalidOutputRect);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1DrawTransform_Value = @import("../zig.zig").Guid.initString("36bfdcb6-9739-435d-a30d-a653beff6a6f");
pub const IID_ID2D1DrawTransform = &IID_ID2D1DrawTransform_Value;
pub const ID2D1DrawTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1Transform.VTable,
SetDrawInfo: fn(
self: *const ID2D1DrawTransform,
drawInfo: ?*ID2D1DrawInfo,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Transform.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DrawTransform_SetDrawInfo(self: *const T, drawInfo: ?*ID2D1DrawInfo) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DrawTransform.VTable, self.vtable).SetDrawInfo(@ptrCast(*const ID2D1DrawTransform, self), drawInfo);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ComputeTransform_Value = @import("../zig.zig").Guid.initString("0d85573c-01e3-4f7d-bfd9-0d60608bf3c3");
pub const IID_ID2D1ComputeTransform = &IID_ID2D1ComputeTransform_Value;
pub const ID2D1ComputeTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1Transform.VTable,
SetComputeInfo: fn(
self: *const ID2D1ComputeTransform,
computeInfo: ?*ID2D1ComputeInfo,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CalculateThreadgroups: fn(
self: *const ID2D1ComputeTransform,
outputRect: ?*const RECT,
dimensionX: ?*u32,
dimensionY: ?*u32,
dimensionZ: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Transform.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ComputeTransform_SetComputeInfo(self: *const T, computeInfo: ?*ID2D1ComputeInfo) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ComputeTransform.VTable, self.vtable).SetComputeInfo(@ptrCast(*const ID2D1ComputeTransform, self), computeInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ComputeTransform_CalculateThreadgroups(self: *const T, outputRect: ?*const RECT, dimensionX: ?*u32, dimensionY: ?*u32, dimensionZ: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ComputeTransform.VTable, self.vtable).CalculateThreadgroups(@ptrCast(*const ID2D1ComputeTransform, self), outputRect, dimensionX, dimensionY, dimensionZ);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1AnalysisTransform_Value = @import("../zig.zig").Guid.initString("0359dc30-95e6-4568-9055-27720d130e93");
pub const IID_ID2D1AnalysisTransform = &IID_ID2D1AnalysisTransform_Value;
pub const ID2D1AnalysisTransform = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ProcessAnalysisResults: fn(
self: *const ID2D1AnalysisTransform,
analysisData: [*:0]const u8,
analysisDataCount: 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 ID2D1AnalysisTransform_ProcessAnalysisResults(self: *const T, analysisData: [*:0]const u8, analysisDataCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1AnalysisTransform.VTable, self.vtable).ProcessAnalysisResults(@ptrCast(*const ID2D1AnalysisTransform, self), analysisData, analysisDataCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1SourceTransform_Value = @import("../zig.zig").Guid.initString("db1800dd-0c34-4cf9-be90-31cc0a5653e1");
pub const IID_ID2D1SourceTransform = &IID_ID2D1SourceTransform_Value;
pub const ID2D1SourceTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1Transform.VTable,
SetRenderInfo: fn(
self: *const ID2D1SourceTransform,
renderInfo: ?*ID2D1RenderInfo,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Draw: fn(
self: *const ID2D1SourceTransform,
target: ?*ID2D1Bitmap1,
drawRect: ?*const RECT,
targetOrigin: D2D_POINT_2U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Transform.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SourceTransform_SetRenderInfo(self: *const T, renderInfo: ?*ID2D1RenderInfo) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SourceTransform.VTable, self.vtable).SetRenderInfo(@ptrCast(*const ID2D1SourceTransform, self), renderInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SourceTransform_Draw(self: *const T, target: ?*ID2D1Bitmap1, drawRect: ?*const RECT, targetOrigin: D2D_POINT_2U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SourceTransform.VTable, self.vtable).Draw(@ptrCast(*const ID2D1SourceTransform, self), target, drawRect, targetOrigin);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1ConcreteTransform_Value = @import("../zig.zig").Guid.initString("1a799d8a-69f7-4e4c-9fed-437ccc6684cc");
pub const IID_ID2D1ConcreteTransform = &IID_ID2D1ConcreteTransform_Value;
pub const ID2D1ConcreteTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1TransformNode.VTable,
SetOutputBuffer: fn(
self: *const ID2D1ConcreteTransform,
bufferPrecision: D2D1_BUFFER_PRECISION,
channelDepth: D2D1_CHANNEL_DEPTH,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCached: fn(
self: *const ID2D1ConcreteTransform,
isCached: BOOL,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1TransformNode.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ConcreteTransform_SetOutputBuffer(self: *const T, bufferPrecision: D2D1_BUFFER_PRECISION, channelDepth: D2D1_CHANNEL_DEPTH) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ConcreteTransform.VTable, self.vtable).SetOutputBuffer(@ptrCast(*const ID2D1ConcreteTransform, self), bufferPrecision, channelDepth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ConcreteTransform_SetCached(self: *const T, isCached: BOOL) callconv(.Inline) void {
return @ptrCast(*const ID2D1ConcreteTransform.VTable, self.vtable).SetCached(@ptrCast(*const ID2D1ConcreteTransform, self), isCached);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1BlendTransform_Value = @import("../zig.zig").Guid.initString("63ac0b32-ba44-450f-8806-7f4ca1ff2f1b");
pub const IID_ID2D1BlendTransform = &IID_ID2D1BlendTransform_Value;
pub const ID2D1BlendTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1ConcreteTransform.VTable,
SetDescription: fn(
self: *const ID2D1BlendTransform,
description: ?*const D2D1_BLEND_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) void,
GetDescription: fn(
self: *const ID2D1BlendTransform,
description: ?*D2D1_BLEND_DESCRIPTION,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1ConcreteTransform.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BlendTransform_SetDescription(self: *const T, description: ?*const D2D1_BLEND_DESCRIPTION) callconv(.Inline) void {
return @ptrCast(*const ID2D1BlendTransform.VTable, self.vtable).SetDescription(@ptrCast(*const ID2D1BlendTransform, self), description);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BlendTransform_GetDescription(self: *const T, description: ?*D2D1_BLEND_DESCRIPTION) callconv(.Inline) void {
return @ptrCast(*const ID2D1BlendTransform.VTable, self.vtable).GetDescription(@ptrCast(*const ID2D1BlendTransform, self), description);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1BorderTransform_Value = @import("../zig.zig").Guid.initString("4998735c-3a19-473c-9781-656847e3a347");
pub const IID_ID2D1BorderTransform = &IID_ID2D1BorderTransform_Value;
pub const ID2D1BorderTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1ConcreteTransform.VTable,
SetExtendModeX: fn(
self: *const ID2D1BorderTransform,
extendMode: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
SetExtendModeY: fn(
self: *const ID2D1BorderTransform,
extendMode: D2D1_EXTEND_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetExtendModeX: fn(
self: *const ID2D1BorderTransform,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
GetExtendModeY: fn(
self: *const ID2D1BorderTransform,
) callconv(@import("std").os.windows.WINAPI) D2D1_EXTEND_MODE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1ConcreteTransform.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BorderTransform_SetExtendModeX(self: *const T, extendMode: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BorderTransform.VTable, self.vtable).SetExtendModeX(@ptrCast(*const ID2D1BorderTransform, self), extendMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BorderTransform_SetExtendModeY(self: *const T, extendMode: D2D1_EXTEND_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1BorderTransform.VTable, self.vtable).SetExtendModeY(@ptrCast(*const ID2D1BorderTransform, self), extendMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BorderTransform_GetExtendModeX(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1BorderTransform.VTable, self.vtable).GetExtendModeX(@ptrCast(*const ID2D1BorderTransform, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BorderTransform_GetExtendModeY(self: *const T) callconv(.Inline) D2D1_EXTEND_MODE {
return @ptrCast(*const ID2D1BorderTransform.VTable, self.vtable).GetExtendModeY(@ptrCast(*const ID2D1BorderTransform, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1OffsetTransform_Value = @import("../zig.zig").Guid.initString("3fe6adea-7643-4f53-bd14-a0ce63f24042");
pub const IID_ID2D1OffsetTransform = &IID_ID2D1OffsetTransform_Value;
pub const ID2D1OffsetTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1TransformNode.VTable,
SetOffset: fn(
self: *const ID2D1OffsetTransform,
offset: POINT,
) callconv(@import("std").os.windows.WINAPI) void,
GetOffset: fn(
self: *const ID2D1OffsetTransform,
) callconv(@import("std").os.windows.WINAPI) POINT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1TransformNode.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1OffsetTransform_SetOffset(self: *const T, offset: POINT) callconv(.Inline) void {
return @ptrCast(*const ID2D1OffsetTransform.VTable, self.vtable).SetOffset(@ptrCast(*const ID2D1OffsetTransform, self), offset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1OffsetTransform_GetOffset(self: *const T) callconv(.Inline) POINT {
return @ptrCast(*const ID2D1OffsetTransform.VTable, self.vtable).GetOffset(@ptrCast(*const ID2D1OffsetTransform, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1BoundsAdjustmentTransform_Value = @import("../zig.zig").Guid.initString("90f732e2-5092-4606-a819-8651970baccd");
pub const IID_ID2D1BoundsAdjustmentTransform = &IID_ID2D1BoundsAdjustmentTransform_Value;
pub const ID2D1BoundsAdjustmentTransform = extern struct {
pub const VTable = extern struct {
base: ID2D1TransformNode.VTable,
SetOutputBounds: fn(
self: *const ID2D1BoundsAdjustmentTransform,
outputBounds: ?*const RECT,
) callconv(@import("std").os.windows.WINAPI) void,
GetOutputBounds: fn(
self: *const ID2D1BoundsAdjustmentTransform,
outputBounds: ?*RECT,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1TransformNode.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BoundsAdjustmentTransform_SetOutputBounds(self: *const T, outputBounds: ?*const RECT) callconv(.Inline) void {
return @ptrCast(*const ID2D1BoundsAdjustmentTransform.VTable, self.vtable).SetOutputBounds(@ptrCast(*const ID2D1BoundsAdjustmentTransform, self), outputBounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1BoundsAdjustmentTransform_GetOutputBounds(self: *const T, outputBounds: ?*RECT) callconv(.Inline) void {
return @ptrCast(*const ID2D1BoundsAdjustmentTransform.VTable, self.vtable).GetOutputBounds(@ptrCast(*const ID2D1BoundsAdjustmentTransform, self), outputBounds);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1EffectImpl_Value = @import("../zig.zig").Guid.initString("a248fd3f-3e6c-4e63-9f03-7f68ecc91db9");
pub const IID_ID2D1EffectImpl = &IID_ID2D1EffectImpl_Value;
pub const ID2D1EffectImpl = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const ID2D1EffectImpl,
effectContext: ?*ID2D1EffectContext,
transformGraph: ?*ID2D1TransformGraph,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PrepareForRender: fn(
self: *const ID2D1EffectImpl,
changeType: D2D1_CHANGE_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetGraph: fn(
self: *const ID2D1EffectImpl,
transformGraph: ?*ID2D1TransformGraph,
) 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 ID2D1EffectImpl_Initialize(self: *const T, effectContext: ?*ID2D1EffectContext, transformGraph: ?*ID2D1TransformGraph) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectImpl.VTable, self.vtable).Initialize(@ptrCast(*const ID2D1EffectImpl, self), effectContext, transformGraph);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectImpl_PrepareForRender(self: *const T, changeType: D2D1_CHANGE_TYPE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectImpl.VTable, self.vtable).PrepareForRender(@ptrCast(*const ID2D1EffectImpl, self), changeType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectImpl_SetGraph(self: *const T, transformGraph: ?*ID2D1TransformGraph) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectImpl.VTable, self.vtable).SetGraph(@ptrCast(*const ID2D1EffectImpl, self), transformGraph);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_ID2D1EffectContext_Value = @import("../zig.zig").Guid.initString("3d9f916b-27dc-4ad7-b4f1-64945340f563");
pub const IID_ID2D1EffectContext = &IID_ID2D1EffectContext_Value;
pub const ID2D1EffectContext = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDpi: fn(
self: *const ID2D1EffectContext,
dpiX: ?*f32,
dpiY: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void,
CreateEffect: fn(
self: *const ID2D1EffectContext,
effectId: ?*const Guid,
effect: ?*?*ID2D1Effect,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMaximumSupportedFeatureLevel: fn(
self: *const ID2D1EffectContext,
featureLevels: [*]const D3D_FEATURE_LEVEL,
featureLevelsCount: u32,
maximumSupportedFeatureLevel: ?*D3D_FEATURE_LEVEL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateTransformNodeFromEffect: fn(
self: *const ID2D1EffectContext,
effect: ?*ID2D1Effect,
transformNode: ?*?*ID2D1TransformNode,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBlendTransform: fn(
self: *const ID2D1EffectContext,
numInputs: u32,
blendDescription: ?*const D2D1_BLEND_DESCRIPTION,
transform: ?*?*ID2D1BlendTransform,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBorderTransform: fn(
self: *const ID2D1EffectContext,
extendModeX: D2D1_EXTEND_MODE,
extendModeY: D2D1_EXTEND_MODE,
transform: ?*?*ID2D1BorderTransform,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateOffsetTransform: fn(
self: *const ID2D1EffectContext,
offset: POINT,
transform: ?*?*ID2D1OffsetTransform,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBoundsAdjustmentTransform: fn(
self: *const ID2D1EffectContext,
outputRectangle: ?*const RECT,
transform: ?*?*ID2D1BoundsAdjustmentTransform,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LoadPixelShader: fn(
self: *const ID2D1EffectContext,
shaderId: ?*const Guid,
shaderBuffer: [*:0]const u8,
shaderBufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LoadVertexShader: fn(
self: *const ID2D1EffectContext,
resourceId: ?*const Guid,
shaderBuffer: [*:0]const u8,
shaderBufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LoadComputeShader: fn(
self: *const ID2D1EffectContext,
resourceId: ?*const Guid,
shaderBuffer: [*:0]const u8,
shaderBufferCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsShaderLoaded: fn(
self: *const ID2D1EffectContext,
shaderId: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) BOOL,
CreateResourceTexture: fn(
self: *const ID2D1EffectContext,
resourceId: ?*const Guid,
resourceTextureProperties: ?*const D2D1_RESOURCE_TEXTURE_PROPERTIES,
data: ?[*:0]const u8,
strides: ?*const u32,
dataSize: u32,
resourceTexture: ?*?*ID2D1ResourceTexture,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindResourceTexture: fn(
self: *const ID2D1EffectContext,
resourceId: ?*const Guid,
resourceTexture: ?*?*ID2D1ResourceTexture,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateVertexBuffer: fn(
self: *const ID2D1EffectContext,
vertexBufferProperties: ?*const D2D1_VERTEX_BUFFER_PROPERTIES,
resourceId: ?*const Guid,
customVertexBufferProperties: ?*const D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES,
buffer: ?*?*ID2D1VertexBuffer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FindVertexBuffer: fn(
self: *const ID2D1EffectContext,
resourceId: ?*const Guid,
buffer: ?*?*ID2D1VertexBuffer,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContext: fn(
self: *const ID2D1EffectContext,
space: D2D1_COLOR_SPACE,
profile: ?[*:0]const u8,
profileSize: u32,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromFilename: fn(
self: *const ID2D1EffectContext,
filename: ?[*:0]const u16,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromWicColorContext: fn(
self: *const ID2D1EffectContext,
wicColorContext: ?*IWICColorContext,
colorContext: ?*?*ID2D1ColorContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CheckFeatureSupport: fn(
self: *const ID2D1EffectContext,
feature: D2D1_FEATURE,
// TODO: what to do with BytesParamIndex 2?
featureSupportData: ?*anyopaque,
featureSupportDataSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsBufferPrecisionSupported: fn(
self: *const ID2D1EffectContext,
bufferPrecision: D2D1_BUFFER_PRECISION,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
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 ID2D1EffectContext_GetDpi(self: *const T, dpiX: ?*f32, dpiY: ?*f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).GetDpi(@ptrCast(*const ID2D1EffectContext, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateEffect(self: *const T, effectId: ?*const Guid, effect: ?*?*ID2D1Effect) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateEffect(@ptrCast(*const ID2D1EffectContext, self), effectId, effect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_GetMaximumSupportedFeatureLevel(self: *const T, featureLevels: [*]const D3D_FEATURE_LEVEL, featureLevelsCount: u32, maximumSupportedFeatureLevel: ?*D3D_FEATURE_LEVEL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).GetMaximumSupportedFeatureLevel(@ptrCast(*const ID2D1EffectContext, self), featureLevels, featureLevelsCount, maximumSupportedFeatureLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateTransformNodeFromEffect(self: *const T, effect: ?*ID2D1Effect, transformNode: ?*?*ID2D1TransformNode) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateTransformNodeFromEffect(@ptrCast(*const ID2D1EffectContext, self), effect, transformNode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateBlendTransform(self: *const T, numInputs: u32, blendDescription: ?*const D2D1_BLEND_DESCRIPTION, transform: ?*?*ID2D1BlendTransform) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateBlendTransform(@ptrCast(*const ID2D1EffectContext, self), numInputs, blendDescription, transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateBorderTransform(self: *const T, extendModeX: D2D1_EXTEND_MODE, extendModeY: D2D1_EXTEND_MODE, transform: ?*?*ID2D1BorderTransform) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateBorderTransform(@ptrCast(*const ID2D1EffectContext, self), extendModeX, extendModeY, transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateOffsetTransform(self: *const T, offset: POINT, transform: ?*?*ID2D1OffsetTransform) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateOffsetTransform(@ptrCast(*const ID2D1EffectContext, self), offset, transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateBoundsAdjustmentTransform(self: *const T, outputRectangle: ?*const RECT, transform: ?*?*ID2D1BoundsAdjustmentTransform) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateBoundsAdjustmentTransform(@ptrCast(*const ID2D1EffectContext, self), outputRectangle, transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_LoadPixelShader(self: *const T, shaderId: ?*const Guid, shaderBuffer: [*:0]const u8, shaderBufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).LoadPixelShader(@ptrCast(*const ID2D1EffectContext, self), shaderId, shaderBuffer, shaderBufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_LoadVertexShader(self: *const T, resourceId: ?*const Guid, shaderBuffer: [*:0]const u8, shaderBufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).LoadVertexShader(@ptrCast(*const ID2D1EffectContext, self), resourceId, shaderBuffer, shaderBufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_LoadComputeShader(self: *const T, resourceId: ?*const Guid, shaderBuffer: [*:0]const u8, shaderBufferCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).LoadComputeShader(@ptrCast(*const ID2D1EffectContext, self), resourceId, shaderBuffer, shaderBufferCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_IsShaderLoaded(self: *const T, shaderId: ?*const Guid) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).IsShaderLoaded(@ptrCast(*const ID2D1EffectContext, self), shaderId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateResourceTexture(self: *const T, resourceId: ?*const Guid, resourceTextureProperties: ?*const D2D1_RESOURCE_TEXTURE_PROPERTIES, data: ?[*:0]const u8, strides: ?*const u32, dataSize: u32, resourceTexture: ?*?*ID2D1ResourceTexture) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateResourceTexture(@ptrCast(*const ID2D1EffectContext, self), resourceId, resourceTextureProperties, data, strides, dataSize, resourceTexture);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_FindResourceTexture(self: *const T, resourceId: ?*const Guid, resourceTexture: ?*?*ID2D1ResourceTexture) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).FindResourceTexture(@ptrCast(*const ID2D1EffectContext, self), resourceId, resourceTexture);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateVertexBuffer(self: *const T, vertexBufferProperties: ?*const D2D1_VERTEX_BUFFER_PROPERTIES, resourceId: ?*const Guid, customVertexBufferProperties: ?*const D2D1_CUSTOM_VERTEX_BUFFER_PROPERTIES, buffer: ?*?*ID2D1VertexBuffer) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateVertexBuffer(@ptrCast(*const ID2D1EffectContext, self), vertexBufferProperties, resourceId, customVertexBufferProperties, buffer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_FindVertexBuffer(self: *const T, resourceId: ?*const Guid, buffer: ?*?*ID2D1VertexBuffer) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).FindVertexBuffer(@ptrCast(*const ID2D1EffectContext, self), resourceId, buffer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateColorContext(self: *const T, space: D2D1_COLOR_SPACE, profile: ?[*:0]const u8, profileSize: u32, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateColorContext(@ptrCast(*const ID2D1EffectContext, self), space, profile, profileSize, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateColorContextFromFilename(self: *const T, filename: ?[*:0]const u16, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateColorContextFromFilename(@ptrCast(*const ID2D1EffectContext, self), filename, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CreateColorContextFromWicColorContext(self: *const T, wicColorContext: ?*IWICColorContext, colorContext: ?*?*ID2D1ColorContext) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CreateColorContextFromWicColorContext(@ptrCast(*const ID2D1EffectContext, self), wicColorContext, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_CheckFeatureSupport(self: *const T, feature: D2D1_FEATURE, featureSupportData: ?*anyopaque, featureSupportDataSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).CheckFeatureSupport(@ptrCast(*const ID2D1EffectContext, self), feature, featureSupportData, featureSupportDataSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext_IsBufferPrecisionSupported(self: *const T, bufferPrecision: D2D1_BUFFER_PRECISION) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1EffectContext.VTable, self.vtable).IsBufferPrecisionSupported(@ptrCast(*const ID2D1EffectContext, self), bufferPrecision);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D2D1_YCBCR_PROP = enum(u32) {
CHROMA_SUBSAMPLING = 0,
TRANSFORM_MATRIX = 1,
INTERPOLATION_MODE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_YCBCR_PROP_CHROMA_SUBSAMPLING = D2D1_YCBCR_PROP.CHROMA_SUBSAMPLING;
pub const D2D1_YCBCR_PROP_TRANSFORM_MATRIX = D2D1_YCBCR_PROP.TRANSFORM_MATRIX;
pub const D2D1_YCBCR_PROP_INTERPOLATION_MODE = D2D1_YCBCR_PROP.INTERPOLATION_MODE;
pub const D2D1_YCBCR_PROP_FORCE_DWORD = D2D1_YCBCR_PROP.FORCE_DWORD;
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING = enum(u32) {
AUTO = 0,
@"420" = 1,
@"422" = 2,
@"444" = 3,
@"440" = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO = D2D1_YCBCR_CHROMA_SUBSAMPLING.AUTO;
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_420 = D2D1_YCBCR_CHROMA_SUBSAMPLING.@"420";
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_422 = D2D1_YCBCR_CHROMA_SUBSAMPLING.@"422";
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_444 = D2D1_YCBCR_CHROMA_SUBSAMPLING.@"444";
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_440 = D2D1_YCBCR_CHROMA_SUBSAMPLING.@"440";
pub const D2D1_YCBCR_CHROMA_SUBSAMPLING_FORCE_DWORD = D2D1_YCBCR_CHROMA_SUBSAMPLING.FORCE_DWORD;
pub const D2D1_YCBCR_INTERPOLATION_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
HIGH_QUALITY_CUBIC = 5,
FORCE_DWORD = 4294967295,
};
pub const D2D1_YCBCR_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_YCBCR_INTERPOLATION_MODE.NEAREST_NEIGHBOR;
pub const D2D1_YCBCR_INTERPOLATION_MODE_LINEAR = D2D1_YCBCR_INTERPOLATION_MODE.LINEAR;
pub const D2D1_YCBCR_INTERPOLATION_MODE_CUBIC = D2D1_YCBCR_INTERPOLATION_MODE.CUBIC;
pub const D2D1_YCBCR_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_YCBCR_INTERPOLATION_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_YCBCR_INTERPOLATION_MODE_ANISOTROPIC = D2D1_YCBCR_INTERPOLATION_MODE.ANISOTROPIC;
pub const D2D1_YCBCR_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_YCBCR_INTERPOLATION_MODE.HIGH_QUALITY_CUBIC;
pub const D2D1_YCBCR_INTERPOLATION_MODE_FORCE_DWORD = D2D1_YCBCR_INTERPOLATION_MODE.FORCE_DWORD;
pub const D2D1_CONTRAST_PROP = enum(u32) {
CONTRAST = 0,
CLAMP_INPUT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CONTRAST_PROP_CONTRAST = D2D1_CONTRAST_PROP.CONTRAST;
pub const D2D1_CONTRAST_PROP_CLAMP_INPUT = D2D1_CONTRAST_PROP.CLAMP_INPUT;
pub const D2D1_CONTRAST_PROP_FORCE_DWORD = D2D1_CONTRAST_PROP.FORCE_DWORD;
pub const D2D1_RGBTOHUE_PROP = enum(u32) {
OUTPUT_COLOR_SPACE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE = D2D1_RGBTOHUE_PROP.OUTPUT_COLOR_SPACE;
pub const D2D1_RGBTOHUE_PROP_FORCE_DWORD = D2D1_RGBTOHUE_PROP.FORCE_DWORD;
pub const D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE = enum(u32) {
HUE_SATURATION_VALUE = 0,
HUE_SATURATION_LIGHTNESS = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE = D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE.HUE_SATURATION_VALUE;
pub const D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS = D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE.HUE_SATURATION_LIGHTNESS;
pub const D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_FORCE_DWORD = D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE.FORCE_DWORD;
pub const D2D1_HUETORGB_PROP = enum(u32) {
INPUT_COLOR_SPACE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE = D2D1_HUETORGB_PROP.INPUT_COLOR_SPACE;
pub const D2D1_HUETORGB_PROP_FORCE_DWORD = D2D1_HUETORGB_PROP.FORCE_DWORD;
pub const D2D1_HUETORGB_INPUT_COLOR_SPACE = enum(u32) {
HUE_SATURATION_VALUE = 0,
HUE_SATURATION_LIGHTNESS = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_VALUE = D2D1_HUETORGB_INPUT_COLOR_SPACE.HUE_SATURATION_VALUE;
pub const D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS = D2D1_HUETORGB_INPUT_COLOR_SPACE.HUE_SATURATION_LIGHTNESS;
pub const D2D1_HUETORGB_INPUT_COLOR_SPACE_FORCE_DWORD = D2D1_HUETORGB_INPUT_COLOR_SPACE.FORCE_DWORD;
pub const D2D1_CHROMAKEY_PROP = enum(u32) {
COLOR = 0,
TOLERANCE = 1,
INVERT_ALPHA = 2,
FEATHER = 3,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CHROMAKEY_PROP_COLOR = D2D1_CHROMAKEY_PROP.COLOR;
pub const D2D1_CHROMAKEY_PROP_TOLERANCE = D2D1_CHROMAKEY_PROP.TOLERANCE;
pub const D2D1_CHROMAKEY_PROP_INVERT_ALPHA = D2D1_CHROMAKEY_PROP.INVERT_ALPHA;
pub const D2D1_CHROMAKEY_PROP_FEATHER = D2D1_CHROMAKEY_PROP.FEATHER;
pub const D2D1_CHROMAKEY_PROP_FORCE_DWORD = D2D1_CHROMAKEY_PROP.FORCE_DWORD;
pub const D2D1_EMBOSS_PROP = enum(u32) {
HEIGHT = 0,
DIRECTION = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_EMBOSS_PROP_HEIGHT = D2D1_EMBOSS_PROP.HEIGHT;
pub const D2D1_EMBOSS_PROP_DIRECTION = D2D1_EMBOSS_PROP.DIRECTION;
pub const D2D1_EMBOSS_PROP_FORCE_DWORD = D2D1_EMBOSS_PROP.FORCE_DWORD;
pub const D2D1_EXPOSURE_PROP = enum(u32) {
EXPOSURE_VALUE = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_EXPOSURE_PROP_EXPOSURE_VALUE = D2D1_EXPOSURE_PROP.EXPOSURE_VALUE;
pub const D2D1_EXPOSURE_PROP_FORCE_DWORD = D2D1_EXPOSURE_PROP.FORCE_DWORD;
pub const D2D1_POSTERIZE_PROP = enum(u32) {
RED_VALUE_COUNT = 0,
GREEN_VALUE_COUNT = 1,
BLUE_VALUE_COUNT = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_POSTERIZE_PROP_RED_VALUE_COUNT = D2D1_POSTERIZE_PROP.RED_VALUE_COUNT;
pub const D2D1_POSTERIZE_PROP_GREEN_VALUE_COUNT = D2D1_POSTERIZE_PROP.GREEN_VALUE_COUNT;
pub const D2D1_POSTERIZE_PROP_BLUE_VALUE_COUNT = D2D1_POSTERIZE_PROP.BLUE_VALUE_COUNT;
pub const D2D1_POSTERIZE_PROP_FORCE_DWORD = D2D1_POSTERIZE_PROP.FORCE_DWORD;
pub const D2D1_SEPIA_PROP = enum(u32) {
INTENSITY = 0,
ALPHA_MODE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SEPIA_PROP_INTENSITY = D2D1_SEPIA_PROP.INTENSITY;
pub const D2D1_SEPIA_PROP_ALPHA_MODE = D2D1_SEPIA_PROP.ALPHA_MODE;
pub const D2D1_SEPIA_PROP_FORCE_DWORD = D2D1_SEPIA_PROP.FORCE_DWORD;
pub const D2D1_SHARPEN_PROP = enum(u32) {
SHARPNESS = 0,
THRESHOLD = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SHARPEN_PROP_SHARPNESS = D2D1_SHARPEN_PROP.SHARPNESS;
pub const D2D1_SHARPEN_PROP_THRESHOLD = D2D1_SHARPEN_PROP.THRESHOLD;
pub const D2D1_SHARPEN_PROP_FORCE_DWORD = D2D1_SHARPEN_PROP.FORCE_DWORD;
pub const D2D1_STRAIGHTEN_PROP = enum(u32) {
ANGLE = 0,
MAINTAIN_SIZE = 1,
SCALE_MODE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_STRAIGHTEN_PROP_ANGLE = D2D1_STRAIGHTEN_PROP.ANGLE;
pub const D2D1_STRAIGHTEN_PROP_MAINTAIN_SIZE = D2D1_STRAIGHTEN_PROP.MAINTAIN_SIZE;
pub const D2D1_STRAIGHTEN_PROP_SCALE_MODE = D2D1_STRAIGHTEN_PROP.SCALE_MODE;
pub const D2D1_STRAIGHTEN_PROP_FORCE_DWORD = D2D1_STRAIGHTEN_PROP.FORCE_DWORD;
pub const D2D1_STRAIGHTEN_SCALE_MODE = enum(u32) {
NEAREST_NEIGHBOR = 0,
LINEAR = 1,
CUBIC = 2,
MULTI_SAMPLE_LINEAR = 3,
ANISOTROPIC = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_STRAIGHTEN_SCALE_MODE_NEAREST_NEIGHBOR = D2D1_STRAIGHTEN_SCALE_MODE.NEAREST_NEIGHBOR;
pub const D2D1_STRAIGHTEN_SCALE_MODE_LINEAR = D2D1_STRAIGHTEN_SCALE_MODE.LINEAR;
pub const D2D1_STRAIGHTEN_SCALE_MODE_CUBIC = D2D1_STRAIGHTEN_SCALE_MODE.CUBIC;
pub const D2D1_STRAIGHTEN_SCALE_MODE_MULTI_SAMPLE_LINEAR = D2D1_STRAIGHTEN_SCALE_MODE.MULTI_SAMPLE_LINEAR;
pub const D2D1_STRAIGHTEN_SCALE_MODE_ANISOTROPIC = D2D1_STRAIGHTEN_SCALE_MODE.ANISOTROPIC;
pub const D2D1_STRAIGHTEN_SCALE_MODE_FORCE_DWORD = D2D1_STRAIGHTEN_SCALE_MODE.FORCE_DWORD;
pub const D2D1_TEMPERATUREANDTINT_PROP = enum(u32) {
TEMPERATURE = 0,
TINT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TEMPERATUREANDTINT_PROP_TEMPERATURE = D2D1_TEMPERATUREANDTINT_PROP.TEMPERATURE;
pub const D2D1_TEMPERATUREANDTINT_PROP_TINT = D2D1_TEMPERATUREANDTINT_PROP.TINT;
pub const D2D1_TEMPERATUREANDTINT_PROP_FORCE_DWORD = D2D1_TEMPERATUREANDTINT_PROP.FORCE_DWORD;
pub const D2D1_VIGNETTE_PROP = enum(u32) {
COLOR = 0,
TRANSITION_SIZE = 1,
STRENGTH = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_VIGNETTE_PROP_COLOR = D2D1_VIGNETTE_PROP.COLOR;
pub const D2D1_VIGNETTE_PROP_TRANSITION_SIZE = D2D1_VIGNETTE_PROP.TRANSITION_SIZE;
pub const D2D1_VIGNETTE_PROP_STRENGTH = D2D1_VIGNETTE_PROP.STRENGTH;
pub const D2D1_VIGNETTE_PROP_FORCE_DWORD = D2D1_VIGNETTE_PROP.FORCE_DWORD;
pub const D2D1_EDGEDETECTION_PROP = enum(u32) {
STRENGTH = 0,
BLUR_RADIUS = 1,
MODE = 2,
OVERLAY_EDGES = 3,
ALPHA_MODE = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_EDGEDETECTION_PROP_STRENGTH = D2D1_EDGEDETECTION_PROP.STRENGTH;
pub const D2D1_EDGEDETECTION_PROP_BLUR_RADIUS = D2D1_EDGEDETECTION_PROP.BLUR_RADIUS;
pub const D2D1_EDGEDETECTION_PROP_MODE = D2D1_EDGEDETECTION_PROP.MODE;
pub const D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES = D2D1_EDGEDETECTION_PROP.OVERLAY_EDGES;
pub const D2D1_EDGEDETECTION_PROP_ALPHA_MODE = D2D1_EDGEDETECTION_PROP.ALPHA_MODE;
pub const D2D1_EDGEDETECTION_PROP_FORCE_DWORD = D2D1_EDGEDETECTION_PROP.FORCE_DWORD;
pub const D2D1_EDGEDETECTION_MODE = enum(u32) {
SOBEL = 0,
PREWITT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_EDGEDETECTION_MODE_SOBEL = D2D1_EDGEDETECTION_MODE.SOBEL;
pub const D2D1_EDGEDETECTION_MODE_PREWITT = D2D1_EDGEDETECTION_MODE.PREWITT;
pub const D2D1_EDGEDETECTION_MODE_FORCE_DWORD = D2D1_EDGEDETECTION_MODE.FORCE_DWORD;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP = enum(u32) {
HIGHLIGHTS = 0,
SHADOWS = 1,
CLARITY = 2,
INPUT_GAMMA = 3,
MASK_BLUR_RADIUS = 4,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS = D2D1_HIGHLIGHTSANDSHADOWS_PROP.HIGHLIGHTS;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS = D2D1_HIGHLIGHTSANDSHADOWS_PROP.SHADOWS;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY = D2D1_HIGHLIGHTSANDSHADOWS_PROP.CLARITY;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA = D2D1_HIGHLIGHTSANDSHADOWS_PROP.INPUT_GAMMA;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS = D2D1_HIGHLIGHTSANDSHADOWS_PROP.MASK_BLUR_RADIUS;
pub const D2D1_HIGHLIGHTSANDSHADOWS_PROP_FORCE_DWORD = D2D1_HIGHLIGHTSANDSHADOWS_PROP.FORCE_DWORD;
pub const D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA = enum(u32) {
LINEAR = 0,
SRGB = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR = D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA.LINEAR;
pub const D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_SRGB = D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA.SRGB;
pub const D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_FORCE_DWORD = D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA.FORCE_DWORD;
pub const D2D1_LOOKUPTABLE3D_PROP = enum(u32) {
LUT = 0,
ALPHA_MODE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_LOOKUPTABLE3D_PROP_LUT = D2D1_LOOKUPTABLE3D_PROP.LUT;
pub const D2D1_LOOKUPTABLE3D_PROP_ALPHA_MODE = D2D1_LOOKUPTABLE3D_PROP.ALPHA_MODE;
pub const D2D1_LOOKUPTABLE3D_PROP_FORCE_DWORD = D2D1_LOOKUPTABLE3D_PROP.FORCE_DWORD;
pub const D2D1_OPACITY_PROP = enum(u32) {
OPACITY = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_OPACITY_PROP_OPACITY = D2D1_OPACITY_PROP.OPACITY;
pub const D2D1_OPACITY_PROP_FORCE_DWORD = D2D1_OPACITY_PROP.FORCE_DWORD;
pub const D2D1_CROSSFADE_PROP = enum(u32) {
WEIGHT = 0,
FORCE_DWORD = 4294967295,
};
pub const D2D1_CROSSFADE_PROP_WEIGHT = D2D1_CROSSFADE_PROP.WEIGHT;
pub const D2D1_CROSSFADE_PROP_FORCE_DWORD = D2D1_CROSSFADE_PROP.FORCE_DWORD;
pub const D2D1_TINT_PROP = enum(u32) {
COLOR = 0,
CLAMP_OUTPUT = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_TINT_PROP_COLOR = D2D1_TINT_PROP.COLOR;
pub const D2D1_TINT_PROP_CLAMP_OUTPUT = D2D1_TINT_PROP.CLAMP_OUTPUT;
pub const D2D1_TINT_PROP_FORCE_DWORD = D2D1_TINT_PROP.FORCE_DWORD;
pub const D2D1_WHITELEVELADJUSTMENT_PROP = enum(u32) {
INPUT_WHITE_LEVEL = 0,
OUTPUT_WHITE_LEVEL = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_WHITELEVELADJUSTMENT_PROP_INPUT_WHITE_LEVEL = D2D1_WHITELEVELADJUSTMENT_PROP.INPUT_WHITE_LEVEL;
pub const D2D1_WHITELEVELADJUSTMENT_PROP_OUTPUT_WHITE_LEVEL = D2D1_WHITELEVELADJUSTMENT_PROP.OUTPUT_WHITE_LEVEL;
pub const D2D1_WHITELEVELADJUSTMENT_PROP_FORCE_DWORD = D2D1_WHITELEVELADJUSTMENT_PROP.FORCE_DWORD;
pub const D2D1_HDRTONEMAP_PROP = enum(u32) {
INPUT_MAX_LUMINANCE = 0,
OUTPUT_MAX_LUMINANCE = 1,
DISPLAY_MODE = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HDRTONEMAP_PROP_INPUT_MAX_LUMINANCE = D2D1_HDRTONEMAP_PROP.INPUT_MAX_LUMINANCE;
pub const D2D1_HDRTONEMAP_PROP_OUTPUT_MAX_LUMINANCE = D2D1_HDRTONEMAP_PROP.OUTPUT_MAX_LUMINANCE;
pub const D2D1_HDRTONEMAP_PROP_DISPLAY_MODE = D2D1_HDRTONEMAP_PROP.DISPLAY_MODE;
pub const D2D1_HDRTONEMAP_PROP_FORCE_DWORD = D2D1_HDRTONEMAP_PROP.FORCE_DWORD;
pub const D2D1_HDRTONEMAP_DISPLAY_MODE = enum(u32) {
SDR = 0,
HDR = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_HDRTONEMAP_DISPLAY_MODE_SDR = D2D1_HDRTONEMAP_DISPLAY_MODE.SDR;
pub const D2D1_HDRTONEMAP_DISPLAY_MODE_HDR = D2D1_HDRTONEMAP_DISPLAY_MODE.HDR;
pub const D2D1_HDRTONEMAP_DISPLAY_MODE_FORCE_DWORD = D2D1_HDRTONEMAP_DISPLAY_MODE.FORCE_DWORD;
pub const D2D1_RENDERING_PRIORITY = enum(u32) {
NORMAL = 0,
LOW = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_RENDERING_PRIORITY_NORMAL = D2D1_RENDERING_PRIORITY.NORMAL;
pub const D2D1_RENDERING_PRIORITY_LOW = D2D1_RENDERING_PRIORITY.LOW;
pub const D2D1_RENDERING_PRIORITY_FORCE_DWORD = D2D1_RENDERING_PRIORITY.FORCE_DWORD;
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1GeometryRealization_Value = @import("../zig.zig").Guid.initString("a16907d7-bc02-4801-99e8-8cf7f485f774");
pub const IID_ID2D1GeometryRealization = &IID_ID2D1GeometryRealization_Value;
pub const ID2D1GeometryRealization = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1DeviceContext1_Value = @import("../zig.zig").Guid.initString("d37f57e4-6908-459f-a199-e72f24f79987");
pub const IID_ID2D1DeviceContext1 = &IID_ID2D1DeviceContext1_Value;
pub const ID2D1DeviceContext1 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext.VTable,
CreateFilledGeometryRealization: fn(
self: *const ID2D1DeviceContext1,
geometry: ?*ID2D1Geometry,
flatteningTolerance: f32,
geometryRealization: ?*?*ID2D1GeometryRealization,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStrokedGeometryRealization: fn(
self: *const ID2D1DeviceContext1,
geometry: ?*ID2D1Geometry,
flatteningTolerance: f32,
strokeWidth: f32,
strokeStyle: ?*ID2D1StrokeStyle,
geometryRealization: ?*?*ID2D1GeometryRealization,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGeometryRealization: fn(
self: *const ID2D1DeviceContext1,
geometryRealization: ?*ID2D1GeometryRealization,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext1_CreateFilledGeometryRealization(self: *const T, geometry: ?*ID2D1Geometry, flatteningTolerance: f32, geometryRealization: ?*?*ID2D1GeometryRealization) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext1.VTable, self.vtable).CreateFilledGeometryRealization(@ptrCast(*const ID2D1DeviceContext1, self), geometry, flatteningTolerance, geometryRealization);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext1_CreateStrokedGeometryRealization(self: *const T, geometry: ?*ID2D1Geometry, flatteningTolerance: f32, strokeWidth: f32, strokeStyle: ?*ID2D1StrokeStyle, geometryRealization: ?*?*ID2D1GeometryRealization) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext1.VTable, self.vtable).CreateStrokedGeometryRealization(@ptrCast(*const ID2D1DeviceContext1, self), geometry, flatteningTolerance, strokeWidth, strokeStyle, geometryRealization);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext1_DrawGeometryRealization(self: *const T, geometryRealization: ?*ID2D1GeometryRealization, brush: ?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext1.VTable, self.vtable).DrawGeometryRealization(@ptrCast(*const ID2D1DeviceContext1, self), geometryRealization, brush);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1Device1_Value = @import("../zig.zig").Guid.initString("d21768e1-23a4-4823-a14b-7c3eba85d658");
pub const IID_ID2D1Device1 = &IID_ID2D1Device1_Value;
pub const ID2D1Device1 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device.VTable,
GetRenderingPriority: fn(
self: *const ID2D1Device1,
) callconv(@import("std").os.windows.WINAPI) D2D1_RENDERING_PRIORITY,
SetRenderingPriority: fn(
self: *const ID2D1Device1,
renderingPriority: D2D1_RENDERING_PRIORITY,
) callconv(@import("std").os.windows.WINAPI) void,
CreateDeviceContext: fn(
self: *const ID2D1Device1,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext1: ?*?*ID2D1DeviceContext1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device1_GetRenderingPriority(self: *const T) callconv(.Inline) D2D1_RENDERING_PRIORITY {
return @ptrCast(*const ID2D1Device1.VTable, self.vtable).GetRenderingPriority(@ptrCast(*const ID2D1Device1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device1_SetRenderingPriority(self: *const T, renderingPriority: D2D1_RENDERING_PRIORITY) callconv(.Inline) void {
return @ptrCast(*const ID2D1Device1.VTable, self.vtable).SetRenderingPriority(@ptrCast(*const ID2D1Device1, self), renderingPriority);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device1_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext1: ?*?*ID2D1DeviceContext1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device1.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device1, self), options, deviceContext1);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1Factory2_Value = @import("../zig.zig").Guid.initString("94f81a73-9212-4376-9c58-b16a3a0d3992");
pub const IID_ID2D1Factory2 = &IID_ID2D1Factory2_Value;
pub const ID2D1Factory2 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory1.VTable,
CreateDevice: fn(
self: *const ID2D1Factory2,
dxgiDevice: ?*IDXGIDevice,
d2dDevice1: ?*?*ID2D1Device1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory2_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice1: ?*?*ID2D1Device1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory2.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory2, self), dxgiDevice, d2dDevice1);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1CommandSink1_Value = @import("../zig.zig").Guid.initString("9eb767fd-4269-4467-b8c2-eb30cb305743");
pub const IID_ID2D1CommandSink1 = &IID_ID2D1CommandSink1_Value;
pub const ID2D1CommandSink1 = extern struct {
pub const VTable = extern struct {
base: ID2D1CommandSink.VTable,
SetPrimitiveBlend1: fn(
self: *const ID2D1CommandSink1,
primitiveBlend: D2D1_PRIMITIVE_BLEND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1CommandSink.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink1_SetPrimitiveBlend1(self: *const T, primitiveBlend: D2D1_PRIMITIVE_BLEND) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink1.VTable, self.vtable).SetPrimitiveBlend1(@ptrCast(*const ID2D1CommandSink1, self), primitiveBlend);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D2D1_SVG_PAINT_TYPE = enum(u32) {
NONE = 0,
COLOR = 1,
CURRENT_COLOR = 2,
URI = 3,
URI_NONE = 4,
URI_COLOR = 5,
URI_CURRENT_COLOR = 6,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_PAINT_TYPE_NONE = D2D1_SVG_PAINT_TYPE.NONE;
pub const D2D1_SVG_PAINT_TYPE_COLOR = D2D1_SVG_PAINT_TYPE.COLOR;
pub const D2D1_SVG_PAINT_TYPE_CURRENT_COLOR = D2D1_SVG_PAINT_TYPE.CURRENT_COLOR;
pub const D2D1_SVG_PAINT_TYPE_URI = D2D1_SVG_PAINT_TYPE.URI;
pub const D2D1_SVG_PAINT_TYPE_URI_NONE = D2D1_SVG_PAINT_TYPE.URI_NONE;
pub const D2D1_SVG_PAINT_TYPE_URI_COLOR = D2D1_SVG_PAINT_TYPE.URI_COLOR;
pub const D2D1_SVG_PAINT_TYPE_URI_CURRENT_COLOR = D2D1_SVG_PAINT_TYPE.URI_CURRENT_COLOR;
pub const D2D1_SVG_PAINT_TYPE_FORCE_DWORD = D2D1_SVG_PAINT_TYPE.FORCE_DWORD;
pub const D2D1_SVG_LENGTH_UNITS = enum(u32) {
NUMBER = 0,
PERCENTAGE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_LENGTH_UNITS_NUMBER = D2D1_SVG_LENGTH_UNITS.NUMBER;
pub const D2D1_SVG_LENGTH_UNITS_PERCENTAGE = D2D1_SVG_LENGTH_UNITS.PERCENTAGE;
pub const D2D1_SVG_LENGTH_UNITS_FORCE_DWORD = D2D1_SVG_LENGTH_UNITS.FORCE_DWORD;
pub const D2D1_SVG_DISPLAY = enum(u32) {
INLINE = 0,
NONE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_DISPLAY_INLINE = D2D1_SVG_DISPLAY.INLINE;
pub const D2D1_SVG_DISPLAY_NONE = D2D1_SVG_DISPLAY.NONE;
pub const D2D1_SVG_DISPLAY_FORCE_DWORD = D2D1_SVG_DISPLAY.FORCE_DWORD;
pub const D2D1_SVG_VISIBILITY = enum(u32) {
VISIBLE = 0,
HIDDEN = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_VISIBILITY_VISIBLE = D2D1_SVG_VISIBILITY.VISIBLE;
pub const D2D1_SVG_VISIBILITY_HIDDEN = D2D1_SVG_VISIBILITY.HIDDEN;
pub const D2D1_SVG_VISIBILITY_FORCE_DWORD = D2D1_SVG_VISIBILITY.FORCE_DWORD;
pub const D2D1_SVG_OVERFLOW = enum(u32) {
VISIBLE = 0,
HIDDEN = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_OVERFLOW_VISIBLE = D2D1_SVG_OVERFLOW.VISIBLE;
pub const D2D1_SVG_OVERFLOW_HIDDEN = D2D1_SVG_OVERFLOW.HIDDEN;
pub const D2D1_SVG_OVERFLOW_FORCE_DWORD = D2D1_SVG_OVERFLOW.FORCE_DWORD;
pub const D2D1_SVG_LINE_CAP = enum(u32) {
BUTT = 0,
SQUARE = 1,
ROUND = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_LINE_CAP_BUTT = D2D1_SVG_LINE_CAP.BUTT;
pub const D2D1_SVG_LINE_CAP_SQUARE = D2D1_SVG_LINE_CAP.SQUARE;
pub const D2D1_SVG_LINE_CAP_ROUND = D2D1_SVG_LINE_CAP.ROUND;
pub const D2D1_SVG_LINE_CAP_FORCE_DWORD = D2D1_SVG_LINE_CAP.FORCE_DWORD;
pub const D2D1_SVG_LINE_JOIN = enum(u32) {
BEVEL = 1,
MITER = 3,
ROUND = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_LINE_JOIN_BEVEL = D2D1_SVG_LINE_JOIN.BEVEL;
pub const D2D1_SVG_LINE_JOIN_MITER = D2D1_SVG_LINE_JOIN.MITER;
pub const D2D1_SVG_LINE_JOIN_ROUND = D2D1_SVG_LINE_JOIN.ROUND;
pub const D2D1_SVG_LINE_JOIN_FORCE_DWORD = D2D1_SVG_LINE_JOIN.FORCE_DWORD;
pub const D2D1_SVG_ASPECT_ALIGN = enum(u32) {
NONE = 0,
X_MIN_Y_MIN = 1,
X_MID_Y_MIN = 2,
X_MAX_Y_MIN = 3,
X_MIN_Y_MID = 4,
X_MID_Y_MID = 5,
X_MAX_Y_MID = 6,
X_MIN_Y_MAX = 7,
X_MID_Y_MAX = 8,
X_MAX_Y_MAX = 9,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_ASPECT_ALIGN_NONE = D2D1_SVG_ASPECT_ALIGN.NONE;
pub const D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MIN = D2D1_SVG_ASPECT_ALIGN.X_MIN_Y_MIN;
pub const D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MIN = D2D1_SVG_ASPECT_ALIGN.X_MID_Y_MIN;
pub const D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MIN = D2D1_SVG_ASPECT_ALIGN.X_MAX_Y_MIN;
pub const D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MID = D2D1_SVG_ASPECT_ALIGN.X_MIN_Y_MID;
pub const D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MID = D2D1_SVG_ASPECT_ALIGN.X_MID_Y_MID;
pub const D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MID = D2D1_SVG_ASPECT_ALIGN.X_MAX_Y_MID;
pub const D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MAX = D2D1_SVG_ASPECT_ALIGN.X_MIN_Y_MAX;
pub const D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MAX = D2D1_SVG_ASPECT_ALIGN.X_MID_Y_MAX;
pub const D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MAX = D2D1_SVG_ASPECT_ALIGN.X_MAX_Y_MAX;
pub const D2D1_SVG_ASPECT_ALIGN_FORCE_DWORD = D2D1_SVG_ASPECT_ALIGN.FORCE_DWORD;
pub const D2D1_SVG_ASPECT_SCALING = enum(u32) {
MEET = 0,
SLICE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_ASPECT_SCALING_MEET = D2D1_SVG_ASPECT_SCALING.MEET;
pub const D2D1_SVG_ASPECT_SCALING_SLICE = D2D1_SVG_ASPECT_SCALING.SLICE;
pub const D2D1_SVG_ASPECT_SCALING_FORCE_DWORD = D2D1_SVG_ASPECT_SCALING.FORCE_DWORD;
pub const D2D1_SVG_PATH_COMMAND = enum(u32) {
CLOSE_PATH = 0,
MOVE_ABSOLUTE = 1,
MOVE_RELATIVE = 2,
LINE_ABSOLUTE = 3,
LINE_RELATIVE = 4,
CUBIC_ABSOLUTE = 5,
CUBIC_RELATIVE = 6,
QUADRADIC_ABSOLUTE = 7,
QUADRADIC_RELATIVE = 8,
ARC_ABSOLUTE = 9,
ARC_RELATIVE = 10,
HORIZONTAL_ABSOLUTE = 11,
HORIZONTAL_RELATIVE = 12,
VERTICAL_ABSOLUTE = 13,
VERTICAL_RELATIVE = 14,
CUBIC_SMOOTH_ABSOLUTE = 15,
CUBIC_SMOOTH_RELATIVE = 16,
QUADRADIC_SMOOTH_ABSOLUTE = 17,
QUADRADIC_SMOOTH_RELATIVE = 18,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_PATH_COMMAND_CLOSE_PATH = D2D1_SVG_PATH_COMMAND.CLOSE_PATH;
pub const D2D1_SVG_PATH_COMMAND_MOVE_ABSOLUTE = D2D1_SVG_PATH_COMMAND.MOVE_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_MOVE_RELATIVE = D2D1_SVG_PATH_COMMAND.MOVE_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_LINE_ABSOLUTE = D2D1_SVG_PATH_COMMAND.LINE_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_LINE_RELATIVE = D2D1_SVG_PATH_COMMAND.LINE_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_CUBIC_ABSOLUTE = D2D1_SVG_PATH_COMMAND.CUBIC_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_CUBIC_RELATIVE = D2D1_SVG_PATH_COMMAND.CUBIC_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_QUADRADIC_ABSOLUTE = D2D1_SVG_PATH_COMMAND.QUADRADIC_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_QUADRADIC_RELATIVE = D2D1_SVG_PATH_COMMAND.QUADRADIC_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_ARC_ABSOLUTE = D2D1_SVG_PATH_COMMAND.ARC_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_ARC_RELATIVE = D2D1_SVG_PATH_COMMAND.ARC_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_HORIZONTAL_ABSOLUTE = D2D1_SVG_PATH_COMMAND.HORIZONTAL_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_HORIZONTAL_RELATIVE = D2D1_SVG_PATH_COMMAND.HORIZONTAL_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_VERTICAL_ABSOLUTE = D2D1_SVG_PATH_COMMAND.VERTICAL_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_VERTICAL_RELATIVE = D2D1_SVG_PATH_COMMAND.VERTICAL_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_ABSOLUTE = D2D1_SVG_PATH_COMMAND.CUBIC_SMOOTH_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_RELATIVE = D2D1_SVG_PATH_COMMAND.CUBIC_SMOOTH_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_ABSOLUTE = D2D1_SVG_PATH_COMMAND.QUADRADIC_SMOOTH_ABSOLUTE;
pub const D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_RELATIVE = D2D1_SVG_PATH_COMMAND.QUADRADIC_SMOOTH_RELATIVE;
pub const D2D1_SVG_PATH_COMMAND_FORCE_DWORD = D2D1_SVG_PATH_COMMAND.FORCE_DWORD;
pub const D2D1_SVG_UNIT_TYPE = enum(u32) {
USER_SPACE_ON_USE = 0,
OBJECT_BOUNDING_BOX = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_UNIT_TYPE_USER_SPACE_ON_USE = D2D1_SVG_UNIT_TYPE.USER_SPACE_ON_USE;
pub const D2D1_SVG_UNIT_TYPE_OBJECT_BOUNDING_BOX = D2D1_SVG_UNIT_TYPE.OBJECT_BOUNDING_BOX;
pub const D2D1_SVG_UNIT_TYPE_FORCE_DWORD = D2D1_SVG_UNIT_TYPE.FORCE_DWORD;
pub const D2D1_SVG_ATTRIBUTE_STRING_TYPE = enum(u32) {
SVG = 0,
ID = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_ATTRIBUTE_STRING_TYPE_SVG = D2D1_SVG_ATTRIBUTE_STRING_TYPE.SVG;
pub const D2D1_SVG_ATTRIBUTE_STRING_TYPE_ID = D2D1_SVG_ATTRIBUTE_STRING_TYPE.ID;
pub const D2D1_SVG_ATTRIBUTE_STRING_TYPE_FORCE_DWORD = D2D1_SVG_ATTRIBUTE_STRING_TYPE.FORCE_DWORD;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE = enum(u32) {
FLOAT = 0,
COLOR = 1,
FILL_MODE = 2,
DISPLAY = 3,
OVERFLOW = 4,
LINE_CAP = 5,
LINE_JOIN = 6,
VISIBILITY = 7,
MATRIX = 8,
UNIT_TYPE = 9,
EXTEND_MODE = 10,
PRESERVE_ASPECT_RATIO = 11,
VIEWBOX = 12,
LENGTH = 13,
FORCE_DWORD = 4294967295,
};
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_FLOAT = D2D1_SVG_ATTRIBUTE_POD_TYPE.FLOAT;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_COLOR = D2D1_SVG_ATTRIBUTE_POD_TYPE.COLOR;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_FILL_MODE = D2D1_SVG_ATTRIBUTE_POD_TYPE.FILL_MODE;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_DISPLAY = D2D1_SVG_ATTRIBUTE_POD_TYPE.DISPLAY;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_OVERFLOW = D2D1_SVG_ATTRIBUTE_POD_TYPE.OVERFLOW;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_CAP = D2D1_SVG_ATTRIBUTE_POD_TYPE.LINE_CAP;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_JOIN = D2D1_SVG_ATTRIBUTE_POD_TYPE.LINE_JOIN;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_VISIBILITY = D2D1_SVG_ATTRIBUTE_POD_TYPE.VISIBILITY;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_MATRIX = D2D1_SVG_ATTRIBUTE_POD_TYPE.MATRIX;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_UNIT_TYPE = D2D1_SVG_ATTRIBUTE_POD_TYPE.UNIT_TYPE;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_EXTEND_MODE = D2D1_SVG_ATTRIBUTE_POD_TYPE.EXTEND_MODE;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_PRESERVE_ASPECT_RATIO = D2D1_SVG_ATTRIBUTE_POD_TYPE.PRESERVE_ASPECT_RATIO;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_VIEWBOX = D2D1_SVG_ATTRIBUTE_POD_TYPE.VIEWBOX;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_LENGTH = D2D1_SVG_ATTRIBUTE_POD_TYPE.LENGTH;
pub const D2D1_SVG_ATTRIBUTE_POD_TYPE_FORCE_DWORD = D2D1_SVG_ATTRIBUTE_POD_TYPE.FORCE_DWORD;
pub const D2D1_SVG_LENGTH = extern struct {
value: f32,
units: D2D1_SVG_LENGTH_UNITS,
};
pub const D2D1_SVG_PRESERVE_ASPECT_RATIO = extern struct {
@"defer": BOOL,
@"align": D2D1_SVG_ASPECT_ALIGN,
meetOrSlice: D2D1_SVG_ASPECT_SCALING,
};
pub const D2D1_SVG_VIEWBOX = extern struct {
x: f32,
y: f32,
width: f32,
height: f32,
};
const IID_ID2D1SvgAttribute_Value = @import("../zig.zig").Guid.initString("c9cdb0dd-f8c9-4e70-b7c2-301c80292c5e");
pub const IID_ID2D1SvgAttribute = &IID_ID2D1SvgAttribute_Value;
pub const ID2D1SvgAttribute = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetElement: fn(
self: *const ID2D1SvgAttribute,
element: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) void,
Clone: fn(
self: *const ID2D1SvgAttribute,
attribute: ?*?*ID2D1SvgAttribute,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgAttribute_GetElement(self: *const T, element: ?*?*ID2D1SvgElement) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgAttribute.VTable, self.vtable).GetElement(@ptrCast(*const ID2D1SvgAttribute, self), element);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgAttribute_Clone(self: *const T, attribute: ?*?*ID2D1SvgAttribute) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgAttribute.VTable, self.vtable).Clone(@ptrCast(*const ID2D1SvgAttribute, self), attribute);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgPaint_Value = @import("../zig.zig").Guid.initString("d59bab0a-68a2-455b-a5dc-9eb2854e2490");
pub const IID_ID2D1SvgPaint = &IID_ID2D1SvgPaint_Value;
pub const ID2D1SvgPaint = extern struct {
pub const VTable = extern struct {
base: ID2D1SvgAttribute.VTable,
SetPaintType: fn(
self: *const ID2D1SvgPaint,
paintType: D2D1_SVG_PAINT_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPaintType: fn(
self: *const ID2D1SvgPaint,
) callconv(@import("std").os.windows.WINAPI) D2D1_SVG_PAINT_TYPE,
SetColor: fn(
self: *const ID2D1SvgPaint,
color: ?*const D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetColor: fn(
self: *const ID2D1SvgPaint,
color: ?*D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) void,
SetId: fn(
self: *const ID2D1SvgPaint,
id: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetId: fn(
self: *const ID2D1SvgPaint,
id: [*:0]u16,
idCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIdLength: fn(
self: *const ID2D1SvgPaint,
) callconv(@import("std").os.windows.WINAPI) u32,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1SvgAttribute.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_SetPaintType(self: *const T, paintType: D2D1_SVG_PAINT_TYPE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).SetPaintType(@ptrCast(*const ID2D1SvgPaint, self), paintType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_GetPaintType(self: *const T) callconv(.Inline) D2D1_SVG_PAINT_TYPE {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).GetPaintType(@ptrCast(*const ID2D1SvgPaint, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_SetColor(self: *const T, color: ?*const D2D1_COLOR_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).SetColor(@ptrCast(*const ID2D1SvgPaint, self), color);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_GetColor(self: *const T, color: ?*D2D1_COLOR_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).GetColor(@ptrCast(*const ID2D1SvgPaint, self), color);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_SetId(self: *const T, id: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).SetId(@ptrCast(*const ID2D1SvgPaint, self), id);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_GetId(self: *const T, id: [*:0]u16, idCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).GetId(@ptrCast(*const ID2D1SvgPaint, self), id, idCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPaint_GetIdLength(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgPaint.VTable, self.vtable).GetIdLength(@ptrCast(*const ID2D1SvgPaint, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgStrokeDashArray_Value = @import("../zig.zig").Guid.initString("f1c0ca52-92a3-4f00-b4ce-f35691efd9d9");
pub const IID_ID2D1SvgStrokeDashArray = &IID_ID2D1SvgStrokeDashArray_Value;
pub const ID2D1SvgStrokeDashArray = extern struct {
pub const VTable = extern struct {
base: ID2D1SvgAttribute.VTable,
RemoveDashesAtEnd: fn(
self: *const ID2D1SvgStrokeDashArray,
dashesCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UpdateDashes: fn(
self: *const ID2D1SvgStrokeDashArray,
dashes: [*]const D2D1_SVG_LENGTH,
dashesCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UpdateDashes1: fn(
self: *const ID2D1SvgStrokeDashArray,
dashes: [*]const f32,
dashesCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDashes: fn(
self: *const ID2D1SvgStrokeDashArray,
dashes: [*]D2D1_SVG_LENGTH,
dashesCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDashes1: fn(
self: *const ID2D1SvgStrokeDashArray,
dashes: [*]f32,
dashesCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDashesCount: fn(
self: *const ID2D1SvgStrokeDashArray,
) callconv(@import("std").os.windows.WINAPI) u32,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1SvgAttribute.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_RemoveDashesAtEnd(self: *const T, dashesCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).RemoveDashesAtEnd(@ptrCast(*const ID2D1SvgStrokeDashArray, self), dashesCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_UpdateDashes(self: *const T, dashes: [*]const D2D1_SVG_LENGTH, dashesCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).UpdateDashes(@ptrCast(*const ID2D1SvgStrokeDashArray, self), dashes, dashesCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_UpdateDashes1(self: *const T, dashes: [*]const f32, dashesCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).UpdateDashes(@ptrCast(*const ID2D1SvgStrokeDashArray, self), dashes, dashesCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_GetDashes(self: *const T, dashes: [*]D2D1_SVG_LENGTH, dashesCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).GetDashes(@ptrCast(*const ID2D1SvgStrokeDashArray, self), dashes, dashesCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_GetDashes1(self: *const T, dashes: [*]f32, dashesCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).GetDashes(@ptrCast(*const ID2D1SvgStrokeDashArray, self), dashes, dashesCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgStrokeDashArray_GetDashesCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgStrokeDashArray.VTable, self.vtable).GetDashesCount(@ptrCast(*const ID2D1SvgStrokeDashArray, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgPointCollection_Value = @import("../zig.zig").Guid.initString("9dbe4c0d-3572-4dd9-9825-5530813bb712");
pub const IID_ID2D1SvgPointCollection = &IID_ID2D1SvgPointCollection_Value;
pub const ID2D1SvgPointCollection = extern struct {
pub const VTable = extern struct {
base: ID2D1SvgAttribute.VTable,
RemovePointsAtEnd: fn(
self: *const ID2D1SvgPointCollection,
pointsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UpdatePoints: fn(
self: *const ID2D1SvgPointCollection,
points: [*]const D2D_POINT_2F,
pointsCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPoints: fn(
self: *const ID2D1SvgPointCollection,
points: [*]D2D_POINT_2F,
pointsCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPointsCount: fn(
self: *const ID2D1SvgPointCollection,
) callconv(@import("std").os.windows.WINAPI) u32,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1SvgAttribute.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPointCollection_RemovePointsAtEnd(self: *const T, pointsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPointCollection.VTable, self.vtable).RemovePointsAtEnd(@ptrCast(*const ID2D1SvgPointCollection, self), pointsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPointCollection_UpdatePoints(self: *const T, points: [*]const D2D_POINT_2F, pointsCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPointCollection.VTable, self.vtable).UpdatePoints(@ptrCast(*const ID2D1SvgPointCollection, self), points, pointsCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPointCollection_GetPoints(self: *const T, points: [*]D2D_POINT_2F, pointsCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPointCollection.VTable, self.vtable).GetPoints(@ptrCast(*const ID2D1SvgPointCollection, self), points, pointsCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPointCollection_GetPointsCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgPointCollection.VTable, self.vtable).GetPointsCount(@ptrCast(*const ID2D1SvgPointCollection, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgPathData_Value = @import("../zig.zig").Guid.initString("c095e4f4-bb98-43d6-9745-4d1b84ec9888");
pub const IID_ID2D1SvgPathData = &IID_ID2D1SvgPathData_Value;
pub const ID2D1SvgPathData = extern struct {
pub const VTable = extern struct {
base: ID2D1SvgAttribute.VTable,
RemoveSegmentDataAtEnd: fn(
self: *const ID2D1SvgPathData,
dataCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UpdateSegmentData: fn(
self: *const ID2D1SvgPathData,
data: [*]const f32,
dataCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSegmentData: fn(
self: *const ID2D1SvgPathData,
data: [*]f32,
dataCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSegmentDataCount: fn(
self: *const ID2D1SvgPathData,
) callconv(@import("std").os.windows.WINAPI) u32,
RemoveCommandsAtEnd: fn(
self: *const ID2D1SvgPathData,
commandsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UpdateCommands: fn(
self: *const ID2D1SvgPathData,
commands: [*]const D2D1_SVG_PATH_COMMAND,
commandsCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCommands: fn(
self: *const ID2D1SvgPathData,
commands: [*]D2D1_SVG_PATH_COMMAND,
commandsCount: u32,
startIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCommandsCount: fn(
self: *const ID2D1SvgPathData,
) callconv(@import("std").os.windows.WINAPI) u32,
CreatePathGeometry: fn(
self: *const ID2D1SvgPathData,
fillMode: D2D1_FILL_MODE,
pathGeometry: ?*?*ID2D1PathGeometry1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1SvgAttribute.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_RemoveSegmentDataAtEnd(self: *const T, dataCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).RemoveSegmentDataAtEnd(@ptrCast(*const ID2D1SvgPathData, self), dataCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_UpdateSegmentData(self: *const T, data: [*]const f32, dataCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).UpdateSegmentData(@ptrCast(*const ID2D1SvgPathData, self), data, dataCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_GetSegmentData(self: *const T, data: [*]f32, dataCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).GetSegmentData(@ptrCast(*const ID2D1SvgPathData, self), data, dataCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_GetSegmentDataCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).GetSegmentDataCount(@ptrCast(*const ID2D1SvgPathData, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_RemoveCommandsAtEnd(self: *const T, commandsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).RemoveCommandsAtEnd(@ptrCast(*const ID2D1SvgPathData, self), commandsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_UpdateCommands(self: *const T, commands: [*]const D2D1_SVG_PATH_COMMAND, commandsCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).UpdateCommands(@ptrCast(*const ID2D1SvgPathData, self), commands, commandsCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_GetCommands(self: *const T, commands: [*]D2D1_SVG_PATH_COMMAND, commandsCount: u32, startIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).GetCommands(@ptrCast(*const ID2D1SvgPathData, self), commands, commandsCount, startIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_GetCommandsCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).GetCommandsCount(@ptrCast(*const ID2D1SvgPathData, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgPathData_CreatePathGeometry(self: *const T, fillMode: D2D1_FILL_MODE, pathGeometry: ?*?*ID2D1PathGeometry1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgPathData.VTable, self.vtable).CreatePathGeometry(@ptrCast(*const ID2D1SvgPathData, self), fillMode, pathGeometry);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgElement_Value = @import("../zig.zig").Guid.initString("ac7b67a6-183e-49c1-a823-0ebe40b0db29");
pub const IID_ID2D1SvgElement = &IID_ID2D1SvgElement_Value;
pub const ID2D1SvgElement = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetDocument: fn(
self: *const ID2D1SvgElement,
document: ?*?*ID2D1SvgDocument,
) callconv(@import("std").os.windows.WINAPI) void,
GetTagName: fn(
self: *const ID2D1SvgElement,
name: [*:0]u16,
nameCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTagNameLength: fn(
self: *const ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) u32,
IsTextContent: fn(
self: *const ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetParent: fn(
self: *const ID2D1SvgElement,
parent: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) void,
HasChildren: fn(
self: *const ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetFirstChild: fn(
self: *const ID2D1SvgElement,
child: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) void,
GetLastChild: fn(
self: *const ID2D1SvgElement,
child: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) void,
GetPreviousChild: fn(
self: *const ID2D1SvgElement,
referenceChild: ?*ID2D1SvgElement,
previousChild: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNextChild: fn(
self: *const ID2D1SvgElement,
referenceChild: ?*ID2D1SvgElement,
nextChild: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InsertChildBefore: fn(
self: *const ID2D1SvgElement,
newChild: ?*ID2D1SvgElement,
referenceChild: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AppendChild: fn(
self: *const ID2D1SvgElement,
newChild: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReplaceChild: fn(
self: *const ID2D1SvgElement,
newChild: ?*ID2D1SvgElement,
oldChild: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveChild: fn(
self: *const ID2D1SvgElement,
oldChild: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateChild: fn(
self: *const ID2D1SvgElement,
tagName: ?[*:0]const u16,
newChild: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsAttributeSpecified: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
inherited: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL,
GetSpecifiedAttributeCount: fn(
self: *const ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) u32,
GetSpecifiedAttributeName: fn(
self: *const ID2D1SvgElement,
index: u32,
name: [*:0]u16,
nameCount: u32,
inherited: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpecifiedAttributeNameLength: fn(
self: *const ID2D1SvgElement,
index: u32,
nameLength: ?*u32,
inherited: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAttribute: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetTextValue: fn(
self: *const ID2D1SvgElement,
name: [*:0]const u16,
nameCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTextValue: fn(
self: *const ID2D1SvgElement,
name: [*:0]u16,
nameCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetTextValueLength: fn(
self: *const ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) u32,
SetAttributeValue: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
value: ?*ID2D1SvgAttribute,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAttributeValue1: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
type: D2D1_SVG_ATTRIBUTE_POD_TYPE,
// TODO: what to do with BytesParamIndex 3?
value: ?*const anyopaque,
valueSizeInBytes: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAttributeValue2: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
type: D2D1_SVG_ATTRIBUTE_STRING_TYPE,
value: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributeValue: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
riid: ?*const Guid,
value: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributeValue1: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
type: D2D1_SVG_ATTRIBUTE_POD_TYPE,
// TODO: what to do with BytesParamIndex 3?
value: ?*anyopaque,
valueSizeInBytes: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributeValue2: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
type: D2D1_SVG_ATTRIBUTE_STRING_TYPE,
value: [*:0]u16,
valueCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAttributeValueLength: fn(
self: *const ID2D1SvgElement,
name: ?[*:0]const u16,
type: D2D1_SVG_ATTRIBUTE_STRING_TYPE,
valueLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetDocument(self: *const T, document: ?*?*ID2D1SvgDocument) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetDocument(@ptrCast(*const ID2D1SvgElement, self), document);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetTagName(self: *const T, name: [*:0]u16, nameCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetTagName(@ptrCast(*const ID2D1SvgElement, self), name, nameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetTagNameLength(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetTagNameLength(@ptrCast(*const ID2D1SvgElement, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_IsTextContent(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).IsTextContent(@ptrCast(*const ID2D1SvgElement, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetParent(self: *const T, parent: ?*?*ID2D1SvgElement) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetParent(@ptrCast(*const ID2D1SvgElement, self), parent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_HasChildren(self: *const T) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).HasChildren(@ptrCast(*const ID2D1SvgElement, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetFirstChild(self: *const T, child: ?*?*ID2D1SvgElement) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetFirstChild(@ptrCast(*const ID2D1SvgElement, self), child);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetLastChild(self: *const T, child: ?*?*ID2D1SvgElement) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetLastChild(@ptrCast(*const ID2D1SvgElement, self), child);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetPreviousChild(self: *const T, referenceChild: ?*ID2D1SvgElement, previousChild: ?*?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetPreviousChild(@ptrCast(*const ID2D1SvgElement, self), referenceChild, previousChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetNextChild(self: *const T, referenceChild: ?*ID2D1SvgElement, nextChild: ?*?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetNextChild(@ptrCast(*const ID2D1SvgElement, self), referenceChild, nextChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_InsertChildBefore(self: *const T, newChild: ?*ID2D1SvgElement, referenceChild: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).InsertChildBefore(@ptrCast(*const ID2D1SvgElement, self), newChild, referenceChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_AppendChild(self: *const T, newChild: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).AppendChild(@ptrCast(*const ID2D1SvgElement, self), newChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_ReplaceChild(self: *const T, newChild: ?*ID2D1SvgElement, oldChild: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).ReplaceChild(@ptrCast(*const ID2D1SvgElement, self), newChild, oldChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_RemoveChild(self: *const T, oldChild: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).RemoveChild(@ptrCast(*const ID2D1SvgElement, self), oldChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_CreateChild(self: *const T, tagName: ?[*:0]const u16, newChild: ?*?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).CreateChild(@ptrCast(*const ID2D1SvgElement, self), tagName, newChild);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_IsAttributeSpecified(self: *const T, name: ?[*:0]const u16, inherited: ?*BOOL) callconv(.Inline) BOOL {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).IsAttributeSpecified(@ptrCast(*const ID2D1SvgElement, self), name, inherited);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetSpecifiedAttributeCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetSpecifiedAttributeCount(@ptrCast(*const ID2D1SvgElement, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetSpecifiedAttributeName(self: *const T, index: u32, name: [*:0]u16, nameCount: u32, inherited: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetSpecifiedAttributeName(@ptrCast(*const ID2D1SvgElement, self), index, name, nameCount, inherited);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetSpecifiedAttributeNameLength(self: *const T, index: u32, nameLength: ?*u32, inherited: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetSpecifiedAttributeNameLength(@ptrCast(*const ID2D1SvgElement, self), index, nameLength, inherited);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_RemoveAttribute(self: *const T, name: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).RemoveAttribute(@ptrCast(*const ID2D1SvgElement, self), name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_SetTextValue(self: *const T, name: [*:0]const u16, nameCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).SetTextValue(@ptrCast(*const ID2D1SvgElement, self), name, nameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetTextValue(self: *const T, name: [*:0]u16, nameCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetTextValue(@ptrCast(*const ID2D1SvgElement, self), name, nameCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetTextValueLength(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetTextValueLength(@ptrCast(*const ID2D1SvgElement, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_SetAttributeValue(self: *const T, name: ?[*:0]const u16, value: ?*ID2D1SvgAttribute) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).SetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_SetAttributeValue1(self: *const T, name: ?[*:0]const u16, type_: D2D1_SVG_ATTRIBUTE_POD_TYPE, value: ?*const anyopaque, valueSizeInBytes: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).SetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, type_, value, valueSizeInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_SetAttributeValue2(self: *const T, name: ?[*:0]const u16, type_: D2D1_SVG_ATTRIBUTE_STRING_TYPE, value: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).SetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, type_, value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetAttributeValue(self: *const T, name: ?[*:0]const u16, riid: ?*const Guid, value: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, riid, value);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetAttributeValue1(self: *const T, name: ?[*:0]const u16, type_: D2D1_SVG_ATTRIBUTE_POD_TYPE, value: ?*anyopaque, valueSizeInBytes: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, type_, value, valueSizeInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetAttributeValue2(self: *const T, name: ?[*:0]const u16, type_: D2D1_SVG_ATTRIBUTE_STRING_TYPE, value: [*:0]u16, valueCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetAttributeValue(@ptrCast(*const ID2D1SvgElement, self), name, type_, value, valueCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgElement_GetAttributeValueLength(self: *const T, name: ?[*:0]const u16, type_: D2D1_SVG_ATTRIBUTE_STRING_TYPE, valueLength: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgElement.VTable, self.vtable).GetAttributeValueLength(@ptrCast(*const ID2D1SvgElement, self), name, type_, valueLength);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgDocument_Value = @import("../zig.zig").Guid.initString("86b88e4d-afa4-4d7b-88e4-68a51c4a0aec");
pub const IID_ID2D1SvgDocument = &IID_ID2D1SvgDocument_Value;
pub const ID2D1SvgDocument = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
SetViewportSize: fn(
self: *const ID2D1SvgDocument,
viewportSize: D2D_SIZE_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetViewportSize: fn(
self: *const ID2D1SvgDocument,
) callconv(@import("std").os.windows.WINAPI) D2D_SIZE_F,
SetRoot: fn(
self: *const ID2D1SvgDocument,
root: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRoot: fn(
self: *const ID2D1SvgDocument,
root: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) void,
FindElementById: fn(
self: *const ID2D1SvgDocument,
id: ?[*:0]const u16,
svgElement: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Serialize: fn(
self: *const ID2D1SvgDocument,
outputXmlStream: ?*IStream,
subtree: ?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Deserialize: fn(
self: *const ID2D1SvgDocument,
inputXmlStream: ?*IStream,
subtree: ?*?*ID2D1SvgElement,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePaint: fn(
self: *const ID2D1SvgDocument,
paintType: D2D1_SVG_PAINT_TYPE,
color: ?*const D2D1_COLOR_F,
id: ?[*:0]const u16,
paint: ?*?*ID2D1SvgPaint,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateStrokeDashArray: fn(
self: *const ID2D1SvgDocument,
dashes: ?[*]const D2D1_SVG_LENGTH,
dashesCount: u32,
strokeDashArray: ?*?*ID2D1SvgStrokeDashArray,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePointCollection: fn(
self: *const ID2D1SvgDocument,
points: ?[*]const D2D_POINT_2F,
pointsCount: u32,
pointCollection: ?*?*ID2D1SvgPointCollection,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreatePathData: fn(
self: *const ID2D1SvgDocument,
segmentData: ?[*]const f32,
segmentDataCount: u32,
commands: ?[*]const D2D1_SVG_PATH_COMMAND,
commandsCount: u32,
pathData: ?*?*ID2D1SvgPathData,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_SetViewportSize(self: *const T, viewportSize: D2D_SIZE_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).SetViewportSize(@ptrCast(*const ID2D1SvgDocument, self), viewportSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_GetViewportSize(self: *const T) callconv(.Inline) D2D_SIZE_F {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).GetViewportSize(@ptrCast(*const ID2D1SvgDocument, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_SetRoot(self: *const T, root: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).SetRoot(@ptrCast(*const ID2D1SvgDocument, self), root);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_GetRoot(self: *const T, root: ?*?*ID2D1SvgElement) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).GetRoot(@ptrCast(*const ID2D1SvgDocument, self), root);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_FindElementById(self: *const T, id: ?[*:0]const u16, svgElement: ?*?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).FindElementById(@ptrCast(*const ID2D1SvgDocument, self), id, svgElement);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_Serialize(self: *const T, outputXmlStream: ?*IStream, subtree: ?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).Serialize(@ptrCast(*const ID2D1SvgDocument, self), outputXmlStream, subtree);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_Deserialize(self: *const T, inputXmlStream: ?*IStream, subtree: ?*?*ID2D1SvgElement) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).Deserialize(@ptrCast(*const ID2D1SvgDocument, self), inputXmlStream, subtree);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_CreatePaint(self: *const T, paintType: D2D1_SVG_PAINT_TYPE, color: ?*const D2D1_COLOR_F, id: ?[*:0]const u16, paint: ?*?*ID2D1SvgPaint) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).CreatePaint(@ptrCast(*const ID2D1SvgDocument, self), paintType, color, id, paint);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_CreateStrokeDashArray(self: *const T, dashes: ?[*]const D2D1_SVG_LENGTH, dashesCount: u32, strokeDashArray: ?*?*ID2D1SvgStrokeDashArray) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).CreateStrokeDashArray(@ptrCast(*const ID2D1SvgDocument, self), dashes, dashesCount, strokeDashArray);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_CreatePointCollection(self: *const T, points: ?[*]const D2D_POINT_2F, pointsCount: u32, pointCollection: ?*?*ID2D1SvgPointCollection) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).CreatePointCollection(@ptrCast(*const ID2D1SvgDocument, self), points, pointsCount, pointCollection);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgDocument_CreatePathData(self: *const T, segmentData: ?[*]const f32, segmentDataCount: u32, commands: ?[*]const D2D1_SVG_PATH_COMMAND, commandsCount: u32, pathData: ?*?*ID2D1SvgPathData) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgDocument.VTable, self.vtable).CreatePathData(@ptrCast(*const ID2D1SvgDocument, self), segmentData, segmentDataCount, commands, commandsCount, pathData);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const D2D1_INK_NIB_SHAPE = enum(u32) {
ROUND = 0,
SQUARE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_INK_NIB_SHAPE_ROUND = D2D1_INK_NIB_SHAPE.ROUND;
pub const D2D1_INK_NIB_SHAPE_SQUARE = D2D1_INK_NIB_SHAPE.SQUARE;
pub const D2D1_INK_NIB_SHAPE_FORCE_DWORD = D2D1_INK_NIB_SHAPE.FORCE_DWORD;
pub const D2D1_ORIENTATION = enum(u32) {
DEFAULT = 1,
FLIP_HORIZONTAL = 2,
ROTATE_CLOCKWISE180 = 3,
ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = 4,
ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = 5,
ROTATE_CLOCKWISE270 = 6,
ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = 7,
ROTATE_CLOCKWISE90 = 8,
FORCE_DWORD = 4294967295,
};
pub const D2D1_ORIENTATION_DEFAULT = D2D1_ORIENTATION.DEFAULT;
pub const D2D1_ORIENTATION_FLIP_HORIZONTAL = D2D1_ORIENTATION.FLIP_HORIZONTAL;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE180 = D2D1_ORIENTATION.ROTATE_CLOCKWISE180;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = D2D1_ORIENTATION.ROTATE_CLOCKWISE180_FLIP_HORIZONTAL;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = D2D1_ORIENTATION.ROTATE_CLOCKWISE90_FLIP_HORIZONTAL;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE270 = D2D1_ORIENTATION.ROTATE_CLOCKWISE270;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = D2D1_ORIENTATION.ROTATE_CLOCKWISE270_FLIP_HORIZONTAL;
pub const D2D1_ORIENTATION_ROTATE_CLOCKWISE90 = D2D1_ORIENTATION.ROTATE_CLOCKWISE90;
pub const D2D1_ORIENTATION_FORCE_DWORD = D2D1_ORIENTATION.FORCE_DWORD;
pub const D2D1_IMAGE_SOURCE_LOADING_OPTIONS = enum(u32) {
NONE = 0,
RELEASE_SOURCE = 1,
CACHE_ON_DEMAND = 2,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
RELEASE_SOURCE: u1 = 0,
CACHE_ON_DEMAND: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_IMAGE_SOURCE_LOADING_OPTIONS {
return @intToEnum(D2D1_IMAGE_SOURCE_LOADING_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_IMAGE_SOURCE_LOADING_OPTIONS.NONE) else 0)
| (if (o.RELEASE_SOURCE == 1) @enumToInt(D2D1_IMAGE_SOURCE_LOADING_OPTIONS.RELEASE_SOURCE) else 0)
| (if (o.CACHE_ON_DEMAND == 1) @enumToInt(D2D1_IMAGE_SOURCE_LOADING_OPTIONS.CACHE_ON_DEMAND) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_IMAGE_SOURCE_LOADING_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_IMAGE_SOURCE_LOADING_OPTIONS_NONE = D2D1_IMAGE_SOURCE_LOADING_OPTIONS.NONE;
pub const D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE = D2D1_IMAGE_SOURCE_LOADING_OPTIONS.RELEASE_SOURCE;
pub const D2D1_IMAGE_SOURCE_LOADING_OPTIONS_CACHE_ON_DEMAND = D2D1_IMAGE_SOURCE_LOADING_OPTIONS.CACHE_ON_DEMAND;
pub const D2D1_IMAGE_SOURCE_LOADING_OPTIONS_FORCE_DWORD = D2D1_IMAGE_SOURCE_LOADING_OPTIONS.FORCE_DWORD;
pub const D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS = enum(u32) {
NONE = 0,
LOW_QUALITY_PRIMARY_CONVERSION = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
LOW_QUALITY_PRIMARY_CONVERSION: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS {
return @intToEnum(D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.NONE) else 0)
| (if (o.LOW_QUALITY_PRIMARY_CONVERSION == 1) @enumToInt(D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.LOW_QUALITY_PRIMARY_CONVERSION) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_NONE = D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.NONE;
pub const D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_LOW_QUALITY_PRIMARY_CONVERSION = D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.LOW_QUALITY_PRIMARY_CONVERSION;
pub const D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_FORCE_DWORD = D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS.FORCE_DWORD;
pub const D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS = enum(u32) {
NONE = 0,
DISABLE_DPI_SCALE = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
DISABLE_DPI_SCALE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS {
return @intToEnum(D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.NONE) else 0)
| (if (o.DISABLE_DPI_SCALE == 1) @enumToInt(D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.DISABLE_DPI_SCALE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_NONE = D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.NONE;
pub const D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_DISABLE_DPI_SCALE = D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.DISABLE_DPI_SCALE;
pub const D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_FORCE_DWORD = D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS.FORCE_DWORD;
pub const D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES = extern struct {
orientation: D2D1_ORIENTATION,
scaleX: f32,
scaleY: f32,
interpolationMode: D2D1_INTERPOLATION_MODE,
options: D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS,
};
pub const D2D1_INK_POINT = extern struct {
x: f32,
y: f32,
radius: f32,
};
pub const D2D1_INK_BEZIER_SEGMENT = extern struct {
point1: D2D1_INK_POINT,
point2: D2D1_INK_POINT,
point3: D2D1_INK_POINT,
};
pub const D2D1_INK_STYLE_PROPERTIES = extern struct {
nibShape: D2D1_INK_NIB_SHAPE,
nibTransform: D2D_MATRIX_3X2_F,
};
pub const D2D1_PATCH_EDGE_MODE = enum(u32) {
ALIASED = 0,
ANTIALIASED = 1,
ALIASED_INFLATED = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_PATCH_EDGE_MODE_ALIASED = D2D1_PATCH_EDGE_MODE.ALIASED;
pub const D2D1_PATCH_EDGE_MODE_ANTIALIASED = D2D1_PATCH_EDGE_MODE.ANTIALIASED;
pub const D2D1_PATCH_EDGE_MODE_ALIASED_INFLATED = D2D1_PATCH_EDGE_MODE.ALIASED_INFLATED;
pub const D2D1_PATCH_EDGE_MODE_FORCE_DWORD = D2D1_PATCH_EDGE_MODE.FORCE_DWORD;
pub const D2D1_GRADIENT_MESH_PATCH = extern struct {
point00: D2D_POINT_2F,
point01: D2D_POINT_2F,
point02: D2D_POINT_2F,
point03: D2D_POINT_2F,
point10: D2D_POINT_2F,
point11: D2D_POINT_2F,
point12: D2D_POINT_2F,
point13: D2D_POINT_2F,
point20: D2D_POINT_2F,
point21: D2D_POINT_2F,
point22: D2D_POINT_2F,
point23: D2D_POINT_2F,
point30: D2D_POINT_2F,
point31: D2D_POINT_2F,
point32: D2D_POINT_2F,
point33: D2D_POINT_2F,
color00: D2D1_COLOR_F,
color03: D2D1_COLOR_F,
color30: D2D1_COLOR_F,
color33: D2D1_COLOR_F,
topEdgeMode: D2D1_PATCH_EDGE_MODE,
leftEdgeMode: D2D1_PATCH_EDGE_MODE,
bottomEdgeMode: D2D1_PATCH_EDGE_MODE,
rightEdgeMode: D2D1_PATCH_EDGE_MODE,
};
pub const D2D1_SPRITE_OPTIONS = enum(u32) {
NONE = 0,
CLAMP_TO_SOURCE_RECTANGLE = 1,
FORCE_DWORD = 4294967295,
_,
pub fn initFlags(o: struct {
NONE: u1 = 0,
CLAMP_TO_SOURCE_RECTANGLE: u1 = 0,
FORCE_DWORD: u1 = 0,
}) D2D1_SPRITE_OPTIONS {
return @intToEnum(D2D1_SPRITE_OPTIONS,
(if (o.NONE == 1) @enumToInt(D2D1_SPRITE_OPTIONS.NONE) else 0)
| (if (o.CLAMP_TO_SOURCE_RECTANGLE == 1) @enumToInt(D2D1_SPRITE_OPTIONS.CLAMP_TO_SOURCE_RECTANGLE) else 0)
| (if (o.FORCE_DWORD == 1) @enumToInt(D2D1_SPRITE_OPTIONS.FORCE_DWORD) else 0)
);
}
};
pub const D2D1_SPRITE_OPTIONS_NONE = D2D1_SPRITE_OPTIONS.NONE;
pub const D2D1_SPRITE_OPTIONS_CLAMP_TO_SOURCE_RECTANGLE = D2D1_SPRITE_OPTIONS.CLAMP_TO_SOURCE_RECTANGLE;
pub const D2D1_SPRITE_OPTIONS_FORCE_DWORD = D2D1_SPRITE_OPTIONS.FORCE_DWORD;
pub const D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION = enum(u32) {
DEFAULT = 0,
DISABLE = 1,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT = D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION.DEFAULT;
pub const D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DISABLE = D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION.DISABLE;
pub const D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_FORCE_DWORD = D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION.FORCE_DWORD;
pub const D2D1_GAMMA1 = enum(u32) {
G22 = 0,
G10 = 1,
G2084 = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_GAMMA1_G22 = D2D1_GAMMA1.G22;
pub const D2D1_GAMMA1_G10 = D2D1_GAMMA1.G10;
pub const D2D1_GAMMA1_G2084 = D2D1_GAMMA1.G2084;
pub const D2D1_GAMMA1_FORCE_DWORD = D2D1_GAMMA1.FORCE_DWORD;
pub const D2D1_SIMPLE_COLOR_PROFILE = extern struct {
redPrimary: D2D_POINT_2F,
greenPrimary: D2D_POINT_2F,
bluePrimary: D2D_POINT_2F,
whitePointXZ: D2D_POINT_2F,
gamma: D2D1_GAMMA1,
};
pub const D2D1_COLOR_CONTEXT_TYPE = enum(u32) {
ICC = 0,
SIMPLE = 1,
DXGI = 2,
FORCE_DWORD = 4294967295,
};
pub const D2D1_COLOR_CONTEXT_TYPE_ICC = D2D1_COLOR_CONTEXT_TYPE.ICC;
pub const D2D1_COLOR_CONTEXT_TYPE_SIMPLE = D2D1_COLOR_CONTEXT_TYPE.SIMPLE;
pub const D2D1_COLOR_CONTEXT_TYPE_DXGI = D2D1_COLOR_CONTEXT_TYPE.DXGI;
pub const D2D1_COLOR_CONTEXT_TYPE_FORCE_DWORD = D2D1_COLOR_CONTEXT_TYPE.FORCE_DWORD;
const IID_ID2D1InkStyle_Value = @import("../zig.zig").Guid.initString("bae8b344-23fc-4071-8cb5-d05d6f073848");
pub const IID_ID2D1InkStyle = &IID_ID2D1InkStyle_Value;
pub const ID2D1InkStyle = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
SetNibTransform: fn(
self: *const ID2D1InkStyle,
transform: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
GetNibTransform: fn(
self: *const ID2D1InkStyle,
transform: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void,
SetNibShape: fn(
self: *const ID2D1InkStyle,
nibShape: D2D1_INK_NIB_SHAPE,
) callconv(@import("std").os.windows.WINAPI) void,
GetNibShape: fn(
self: *const ID2D1InkStyle,
) callconv(@import("std").os.windows.WINAPI) D2D1_INK_NIB_SHAPE,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1InkStyle_SetNibTransform(self: *const T, transform: ?*const D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1InkStyle.VTable, self.vtable).SetNibTransform(@ptrCast(*const ID2D1InkStyle, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1InkStyle_GetNibTransform(self: *const T, transform: ?*D2D_MATRIX_3X2_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1InkStyle.VTable, self.vtable).GetNibTransform(@ptrCast(*const ID2D1InkStyle, self), transform);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1InkStyle_SetNibShape(self: *const T, nibShape: D2D1_INK_NIB_SHAPE) callconv(.Inline) void {
return @ptrCast(*const ID2D1InkStyle.VTable, self.vtable).SetNibShape(@ptrCast(*const ID2D1InkStyle, self), nibShape);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1InkStyle_GetNibShape(self: *const T) callconv(.Inline) D2D1_INK_NIB_SHAPE {
return @ptrCast(*const ID2D1InkStyle.VTable, self.vtable).GetNibShape(@ptrCast(*const ID2D1InkStyle, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Ink_Value = @import("../zig.zig").Guid.initString("b499923b-7029-478f-a8b3-432c7c5f5312");
pub const IID_ID2D1Ink = &IID_ID2D1Ink_Value;
pub const ID2D1Ink = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
SetStartPoint: fn(
self: *const ID2D1Ink,
startPoint: ?*const D2D1_INK_POINT,
) callconv(@import("std").os.windows.WINAPI) void,
GetStartPoint: fn(
self: *const ID2D1Ink,
) callconv(@import("std").os.windows.WINAPI) D2D1_INK_POINT,
AddSegments: fn(
self: *const ID2D1Ink,
segments: [*]const D2D1_INK_BEZIER_SEGMENT,
segmentsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveSegmentsAtEnd: fn(
self: *const ID2D1Ink,
segmentsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSegments: fn(
self: *const ID2D1Ink,
startSegment: u32,
segments: [*]const D2D1_INK_BEZIER_SEGMENT,
segmentsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSegmentAtEnd: fn(
self: *const ID2D1Ink,
segment: ?*const D2D1_INK_BEZIER_SEGMENT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSegmentCount: fn(
self: *const ID2D1Ink,
) callconv(@import("std").os.windows.WINAPI) u32,
GetSegments: fn(
self: *const ID2D1Ink,
startSegment: u32,
segments: [*]D2D1_INK_BEZIER_SEGMENT,
segmentsCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
StreamAsGeometry: fn(
self: *const ID2D1Ink,
inkStyle: ?*ID2D1InkStyle,
worldTransform: ?*const D2D_MATRIX_3X2_F,
flatteningTolerance: f32,
geometrySink: ?*ID2D1SimplifiedGeometrySink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetBounds: fn(
self: *const ID2D1Ink,
inkStyle: ?*ID2D1InkStyle,
worldTransform: ?*const D2D_MATRIX_3X2_F,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_SetStartPoint(self: *const T, startPoint: ?*const D2D1_INK_POINT) callconv(.Inline) void {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).SetStartPoint(@ptrCast(*const ID2D1Ink, self), startPoint);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_GetStartPoint(self: *const T) callconv(.Inline) D2D1_INK_POINT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).GetStartPoint(@ptrCast(*const ID2D1Ink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_AddSegments(self: *const T, segments: [*]const D2D1_INK_BEZIER_SEGMENT, segmentsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).AddSegments(@ptrCast(*const ID2D1Ink, self), segments, segmentsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_RemoveSegmentsAtEnd(self: *const T, segmentsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).RemoveSegmentsAtEnd(@ptrCast(*const ID2D1Ink, self), segmentsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_SetSegments(self: *const T, startSegment: u32, segments: [*]const D2D1_INK_BEZIER_SEGMENT, segmentsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).SetSegments(@ptrCast(*const ID2D1Ink, self), startSegment, segments, segmentsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_SetSegmentAtEnd(self: *const T, segment: ?*const D2D1_INK_BEZIER_SEGMENT) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).SetSegmentAtEnd(@ptrCast(*const ID2D1Ink, self), segment);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_GetSegmentCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).GetSegmentCount(@ptrCast(*const ID2D1Ink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_GetSegments(self: *const T, startSegment: u32, segments: [*]D2D1_INK_BEZIER_SEGMENT, segmentsCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).GetSegments(@ptrCast(*const ID2D1Ink, self), startSegment, segments, segmentsCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_StreamAsGeometry(self: *const T, inkStyle: ?*ID2D1InkStyle, worldTransform: ?*const D2D_MATRIX_3X2_F, flatteningTolerance: f32, geometrySink: ?*ID2D1SimplifiedGeometrySink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).StreamAsGeometry(@ptrCast(*const ID2D1Ink, self), inkStyle, worldTransform, flatteningTolerance, geometrySink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Ink_GetBounds(self: *const T, inkStyle: ?*ID2D1InkStyle, worldTransform: ?*const D2D_MATRIX_3X2_F, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Ink.VTable, self.vtable).GetBounds(@ptrCast(*const ID2D1Ink, self), inkStyle, worldTransform, bounds);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1GradientMesh_Value = @import("../zig.zig").Guid.initString("f292e401-c050-4cde-83d7-04962d3b23c2");
pub const IID_ID2D1GradientMesh = &IID_ID2D1GradientMesh_Value;
pub const ID2D1GradientMesh = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
GetPatchCount: fn(
self: *const ID2D1GradientMesh,
) callconv(@import("std").os.windows.WINAPI) u32,
GetPatches: fn(
self: *const ID2D1GradientMesh,
startIndex: u32,
patches: [*]D2D1_GRADIENT_MESH_PATCH,
patchesCount: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientMesh_GetPatchCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1GradientMesh.VTable, self.vtable).GetPatchCount(@ptrCast(*const ID2D1GradientMesh, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GradientMesh_GetPatches(self: *const T, startIndex: u32, patches: [*]D2D1_GRADIENT_MESH_PATCH, patchesCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GradientMesh.VTable, self.vtable).GetPatches(@ptrCast(*const ID2D1GradientMesh, self), startIndex, patches, patchesCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_ID2D1ImageSource_Value = @import("../zig.zig").Guid.initString("c9b664e5-74a1-4378-9ac2-eefc37a3f4d8");
pub const IID_ID2D1ImageSource = &IID_ID2D1ImageSource_Value;
pub const ID2D1ImageSource = extern struct {
pub const VTable = extern struct {
base: ID2D1Image.VTable,
OfferResources: fn(
self: *const ID2D1ImageSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TryReclaimResources: fn(
self: *const ID2D1ImageSource,
resourcesDiscarded: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Image.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageSource_OfferResources(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ImageSource.VTable, self.vtable).OfferResources(@ptrCast(*const ID2D1ImageSource, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageSource_TryReclaimResources(self: *const T, resourcesDiscarded: ?*BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ImageSource.VTable, self.vtable).TryReclaimResources(@ptrCast(*const ID2D1ImageSource, self), resourcesDiscarded);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1ImageSourceFromWic_Value = @import("../zig.zig").Guid.initString("77395441-1c8f-4555-8683-f50dab0fe792");
pub const IID_ID2D1ImageSourceFromWic = &IID_ID2D1ImageSourceFromWic_Value;
pub const ID2D1ImageSourceFromWic = extern struct {
pub const VTable = extern struct {
base: ID2D1ImageSource.VTable,
EnsureCached: fn(
self: *const ID2D1ImageSourceFromWic,
rectangleToFill: ?*const D2D_RECT_U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TrimCache: fn(
self: *const ID2D1ImageSourceFromWic,
rectangleToPreserve: ?*const D2D_RECT_U,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSource: fn(
self: *const ID2D1ImageSourceFromWic,
wicBitmapSource: ?*?*IWICBitmapSource,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1ImageSource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageSourceFromWic_EnsureCached(self: *const T, rectangleToFill: ?*const D2D_RECT_U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ImageSourceFromWic.VTable, self.vtable).EnsureCached(@ptrCast(*const ID2D1ImageSourceFromWic, self), rectangleToFill);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageSourceFromWic_TrimCache(self: *const T, rectangleToPreserve: ?*const D2D_RECT_U) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ImageSourceFromWic.VTable, self.vtable).TrimCache(@ptrCast(*const ID2D1ImageSourceFromWic, self), rectangleToPreserve);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ImageSourceFromWic_GetSource(self: *const T, wicBitmapSource: ?*?*IWICBitmapSource) callconv(.Inline) void {
return @ptrCast(*const ID2D1ImageSourceFromWic.VTable, self.vtable).GetSource(@ptrCast(*const ID2D1ImageSourceFromWic, self), wicBitmapSource);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1TransformedImageSource_Value = @import("../zig.zig").Guid.initString("7f1f79e5-2796-416c-8f55-700f911445e5");
pub const IID_ID2D1TransformedImageSource = &IID_ID2D1TransformedImageSource_Value;
pub const ID2D1TransformedImageSource = extern struct {
pub const VTable = extern struct {
base: ID2D1Image.VTable,
GetSource: fn(
self: *const ID2D1TransformedImageSource,
imageSource: ?*?*ID2D1ImageSource,
) callconv(@import("std").os.windows.WINAPI) void,
GetProperties: fn(
self: *const ID2D1TransformedImageSource,
properties: ?*D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Image.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformedImageSource_GetSource(self: *const T, imageSource: ?*?*ID2D1ImageSource) callconv(.Inline) void {
return @ptrCast(*const ID2D1TransformedImageSource.VTable, self.vtable).GetSource(@ptrCast(*const ID2D1TransformedImageSource, self), imageSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1TransformedImageSource_GetProperties(self: *const T, properties: ?*D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES) callconv(.Inline) void {
return @ptrCast(*const ID2D1TransformedImageSource.VTable, self.vtable).GetProperties(@ptrCast(*const ID2D1TransformedImageSource, self), properties);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1LookupTable3D_Value = @import("../zig.zig").Guid.initString("53dd9855-a3b0-4d5b-82e1-26e25c5e5797");
pub const IID_ID2D1LookupTable3D = &IID_ID2D1LookupTable3D_Value;
pub const ID2D1LookupTable3D = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_ID2D1DeviceContext2_Value = @import("../zig.zig").Guid.initString("394ea6a3-0c34-4321-950b-6ca20f0be6c7");
pub const IID_ID2D1DeviceContext2 = &IID_ID2D1DeviceContext2_Value;
pub const ID2D1DeviceContext2 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext1.VTable,
CreateInk: fn(
self: *const ID2D1DeviceContext2,
startPoint: ?*const D2D1_INK_POINT,
ink: ?*?*ID2D1Ink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateInkStyle: fn(
self: *const ID2D1DeviceContext2,
inkStyleProperties: ?*const D2D1_INK_STYLE_PROPERTIES,
inkStyle: ?*?*ID2D1InkStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateGradientMesh: fn(
self: *const ID2D1DeviceContext2,
patches: [*]const D2D1_GRADIENT_MESH_PATCH,
patchesCount: u32,
gradientMesh: ?*?*ID2D1GradientMesh,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateImageSourceFromWic: fn(
self: *const ID2D1DeviceContext2,
wicBitmapSource: ?*IWICBitmapSource,
loadingOptions: D2D1_IMAGE_SOURCE_LOADING_OPTIONS,
alphaMode: D2D1_ALPHA_MODE,
imageSource: ?*?*ID2D1ImageSourceFromWic,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateLookupTable3D: fn(
self: *const ID2D1DeviceContext2,
precision: D2D1_BUFFER_PRECISION,
extents: *[3]u32,
data: [*:0]const u8,
dataCount: u32,
strides: *[2]u32,
lookupTable: ?*?*ID2D1LookupTable3D,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateImageSourceFromDxgi: fn(
self: *const ID2D1DeviceContext2,
surfaces: [*]?*IDXGISurface,
surfaceCount: u32,
colorSpace: DXGI_COLOR_SPACE_TYPE,
options: D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS,
imageSource: ?*?*ID2D1ImageSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGradientMeshWorldBounds: fn(
self: *const ID2D1DeviceContext2,
gradientMesh: ?*ID2D1GradientMesh,
pBounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawInk: fn(
self: *const ID2D1DeviceContext2,
ink: ?*ID2D1Ink,
brush: ?*ID2D1Brush,
inkStyle: ?*ID2D1InkStyle,
) callconv(@import("std").os.windows.WINAPI) void,
DrawGradientMesh: fn(
self: *const ID2D1DeviceContext2,
gradientMesh: ?*ID2D1GradientMesh,
) callconv(@import("std").os.windows.WINAPI) void,
DrawGdiMetafile: fn(
self: *const ID2D1DeviceContext2,
gdiMetafile: ?*ID2D1GdiMetafile,
destinationRectangle: ?*const D2D_RECT_F,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) void,
CreateTransformedImageSource: fn(
self: *const ID2D1DeviceContext2,
imageSource: ?*ID2D1ImageSource,
properties: ?*const D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES,
transformedImageSource: ?*?*ID2D1TransformedImageSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateInk(self: *const T, startPoint: ?*const D2D1_INK_POINT, ink: ?*?*ID2D1Ink) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateInk(@ptrCast(*const ID2D1DeviceContext2, self), startPoint, ink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateInkStyle(self: *const T, inkStyleProperties: ?*const D2D1_INK_STYLE_PROPERTIES, inkStyle: ?*?*ID2D1InkStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateInkStyle(@ptrCast(*const ID2D1DeviceContext2, self), inkStyleProperties, inkStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateGradientMesh(self: *const T, patches: [*]const D2D1_GRADIENT_MESH_PATCH, patchesCount: u32, gradientMesh: ?*?*ID2D1GradientMesh) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateGradientMesh(@ptrCast(*const ID2D1DeviceContext2, self), patches, patchesCount, gradientMesh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateImageSourceFromWic(self: *const T, wicBitmapSource: ?*IWICBitmapSource, loadingOptions: D2D1_IMAGE_SOURCE_LOADING_OPTIONS, alphaMode: D2D1_ALPHA_MODE, imageSource: ?*?*ID2D1ImageSourceFromWic) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateImageSourceFromWic(@ptrCast(*const ID2D1DeviceContext2, self), wicBitmapSource, loadingOptions, alphaMode, imageSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateLookupTable3D(self: *const T, precision: D2D1_BUFFER_PRECISION, extents: *[3]u32, data: [*:0]const u8, dataCount: u32, strides: *[2]u32, lookupTable: ?*?*ID2D1LookupTable3D) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateLookupTable3D(@ptrCast(*const ID2D1DeviceContext2, self), precision, extents, data, dataCount, strides, lookupTable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateImageSourceFromDxgi(self: *const T, surfaces: [*]?*IDXGISurface, surfaceCount: u32, colorSpace: DXGI_COLOR_SPACE_TYPE, options: D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS, imageSource: ?*?*ID2D1ImageSource) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateImageSourceFromDxgi(@ptrCast(*const ID2D1DeviceContext2, self), surfaces, surfaceCount, colorSpace, options, imageSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_GetGradientMeshWorldBounds(self: *const T, gradientMesh: ?*ID2D1GradientMesh, pBounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).GetGradientMeshWorldBounds(@ptrCast(*const ID2D1DeviceContext2, self), gradientMesh, pBounds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_DrawInk(self: *const T, ink: ?*ID2D1Ink, brush: ?*ID2D1Brush, inkStyle: ?*ID2D1InkStyle) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).DrawInk(@ptrCast(*const ID2D1DeviceContext2, self), ink, brush, inkStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_DrawGradientMesh(self: *const T, gradientMesh: ?*ID2D1GradientMesh) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).DrawGradientMesh(@ptrCast(*const ID2D1DeviceContext2, self), gradientMesh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_DrawGdiMetafile(self: *const T, gdiMetafile: ?*ID2D1GdiMetafile, destinationRectangle: ?*const D2D_RECT_F, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).DrawGdiMetafile(@ptrCast(*const ID2D1DeviceContext2, self), gdiMetafile, destinationRectangle, sourceRectangle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext2_CreateTransformedImageSource(self: *const T, imageSource: ?*ID2D1ImageSource, properties: ?*const D2D1_TRANSFORMED_IMAGE_SOURCE_PROPERTIES, transformedImageSource: ?*?*ID2D1TransformedImageSource) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext2.VTable, self.vtable).CreateTransformedImageSource(@ptrCast(*const ID2D1DeviceContext2, self), imageSource, properties, transformedImageSource);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Device2_Value = @import("../zig.zig").Guid.initString("a44472e1-8dfb-4e60-8492-6e2861c9ca8b");
pub const IID_ID2D1Device2 = &IID_ID2D1Device2_Value;
pub const ID2D1Device2 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device1.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device2,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext2: ?*?*ID2D1DeviceContext2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FlushDeviceContexts: fn(
self: *const ID2D1Device2,
bitmap: ?*ID2D1Bitmap,
) callconv(@import("std").os.windows.WINAPI) void,
GetDxgiDevice: fn(
self: *const ID2D1Device2,
dxgiDevice: ?*?*IDXGIDevice,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device2_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext2: ?*?*ID2D1DeviceContext2) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device2.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device2, self), options, deviceContext2);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device2_FlushDeviceContexts(self: *const T, bitmap: ?*ID2D1Bitmap) callconv(.Inline) void {
return @ptrCast(*const ID2D1Device2.VTable, self.vtable).FlushDeviceContexts(@ptrCast(*const ID2D1Device2, self), bitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device2_GetDxgiDevice(self: *const T, dxgiDevice: ?*?*IDXGIDevice) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device2.VTable, self.vtable).GetDxgiDevice(@ptrCast(*const ID2D1Device2, self), dxgiDevice);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Factory3_Value = @import("../zig.zig").Guid.initString("0869759f-4f00-413f-b03e-2bda45404d0f");
pub const IID_ID2D1Factory3 = &IID_ID2D1Factory3_Value;
pub const ID2D1Factory3 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory2.VTable,
CreateDevice: fn(
self: *const ID2D1Factory3,
dxgiDevice: ?*IDXGIDevice,
d2dDevice2: ?*?*ID2D1Device2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory3_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice2: ?*?*ID2D1Device2) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory3.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory3, self), dxgiDevice, d2dDevice2);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.1'
const IID_ID2D1CommandSink2_Value = @import("../zig.zig").Guid.initString("3bab440e-417e-47df-a2e2-bc0be6a00916");
pub const IID_ID2D1CommandSink2 = &IID_ID2D1CommandSink2_Value;
pub const ID2D1CommandSink2 = extern struct {
pub const VTable = extern struct {
base: ID2D1CommandSink1.VTable,
DrawInk: fn(
self: *const ID2D1CommandSink2,
ink: ?*ID2D1Ink,
brush: ?*ID2D1Brush,
inkStyle: ?*ID2D1InkStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGradientMesh: fn(
self: *const ID2D1CommandSink2,
gradientMesh: ?*ID2D1GradientMesh,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawGdiMetafile: fn(
self: *const ID2D1CommandSink2,
gdiMetafile: ?*ID2D1GdiMetafile,
destinationRectangle: ?*const D2D_RECT_F,
sourceRectangle: ?*const D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1CommandSink1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink2_DrawInk(self: *const T, ink: ?*ID2D1Ink, brush: ?*ID2D1Brush, inkStyle: ?*ID2D1InkStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink2.VTable, self.vtable).DrawInk(@ptrCast(*const ID2D1CommandSink2, self), ink, brush, inkStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink2_DrawGradientMesh(self: *const T, gradientMesh: ?*ID2D1GradientMesh) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink2.VTable, self.vtable).DrawGradientMesh(@ptrCast(*const ID2D1CommandSink2, self), gradientMesh);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink2_DrawGdiMetafile(self: *const T, gdiMetafile: ?*ID2D1GdiMetafile, destinationRectangle: ?*const D2D_RECT_F, sourceRectangle: ?*const D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink2.VTable, self.vtable).DrawGdiMetafile(@ptrCast(*const ID2D1CommandSink2, self), gdiMetafile, destinationRectangle, sourceRectangle);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_ID2D1GdiMetafile1_Value = @import("../zig.zig").Guid.initString("2e69f9e8-dd3f-4bf9-95ba-c04f49d788df");
pub const IID_ID2D1GdiMetafile1 = &IID_ID2D1GdiMetafile1_Value;
pub const ID2D1GdiMetafile1 = extern struct {
pub const VTable = extern struct {
base: ID2D1GdiMetafile.VTable,
GetDpi: fn(
self: *const ID2D1GdiMetafile1,
dpiX: ?*f32,
dpiY: ?*f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSourceBounds: fn(
self: *const ID2D1GdiMetafile1,
bounds: ?*D2D_RECT_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1GdiMetafile.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiMetafile1_GetDpi(self: *const T, dpiX: ?*f32, dpiY: ?*f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafile1.VTable, self.vtable).GetDpi(@ptrCast(*const ID2D1GdiMetafile1, self), dpiX, dpiY);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiMetafile1_GetSourceBounds(self: *const T, bounds: ?*D2D_RECT_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafile1.VTable, self.vtable).GetSourceBounds(@ptrCast(*const ID2D1GdiMetafile1, self), bounds);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows10.0.10240'
const IID_ID2D1GdiMetafileSink1_Value = @import("../zig.zig").Guid.initString("fd0ecb6b-91e6-411e-8655-395e760f91b4");
pub const IID_ID2D1GdiMetafileSink1 = &IID_ID2D1GdiMetafileSink1_Value;
pub const ID2D1GdiMetafileSink1 = extern struct {
pub const VTable = extern struct {
base: ID2D1GdiMetafileSink.VTable,
ProcessRecord: fn(
self: *const ID2D1GdiMetafileSink1,
recordType: u32,
recordData: ?*const anyopaque,
recordDataSize: u32,
flags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1GdiMetafileSink.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1GdiMetafileSink1_ProcessRecord(self: *const T, recordType: u32, recordData: ?*const anyopaque, recordDataSize: u32, flags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1GdiMetafileSink1.VTable, self.vtable).ProcessRecord(@ptrCast(*const ID2D1GdiMetafileSink1, self), recordType, recordData, recordDataSize, flags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SpriteBatch_Value = @import("../zig.zig").Guid.initString("4dc583bf-3a10-438a-8722-e9765224f1f1");
pub const IID_ID2D1SpriteBatch = &IID_ID2D1SpriteBatch_Value;
pub const ID2D1SpriteBatch = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
AddSprites: fn(
self: *const ID2D1SpriteBatch,
spriteCount: u32,
destinationRectangles: ?*const D2D_RECT_F,
sourceRectangles: ?*const D2D_RECT_U,
colors: ?*const D2D1_COLOR_F,
transforms: ?*const D2D_MATRIX_3X2_F,
destinationRectanglesStride: u32,
sourceRectanglesStride: u32,
colorsStride: u32,
transformsStride: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetSprites: fn(
self: *const ID2D1SpriteBatch,
startIndex: u32,
spriteCount: u32,
destinationRectangles: ?*const D2D_RECT_F,
sourceRectangles: ?*const D2D_RECT_U,
colors: ?*const D2D1_COLOR_F,
transforms: ?*const D2D_MATRIX_3X2_F,
destinationRectanglesStride: u32,
sourceRectanglesStride: u32,
colorsStride: u32,
transformsStride: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSprites: fn(
self: *const ID2D1SpriteBatch,
startIndex: u32,
spriteCount: u32,
destinationRectangles: ?[*]D2D_RECT_F,
sourceRectangles: ?[*]D2D_RECT_U,
colors: ?[*]D2D1_COLOR_F,
transforms: ?[*]D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSpriteCount: fn(
self: *const ID2D1SpriteBatch,
) callconv(@import("std").os.windows.WINAPI) u32,
Clear: fn(
self: *const ID2D1SpriteBatch,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SpriteBatch_AddSprites(self: *const T, spriteCount: u32, destinationRectangles: ?*const D2D_RECT_F, sourceRectangles: ?*const D2D_RECT_U, colors: ?*const D2D1_COLOR_F, transforms: ?*const D2D_MATRIX_3X2_F, destinationRectanglesStride: u32, sourceRectanglesStride: u32, colorsStride: u32, transformsStride: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SpriteBatch.VTable, self.vtable).AddSprites(@ptrCast(*const ID2D1SpriteBatch, self), spriteCount, destinationRectangles, sourceRectangles, colors, transforms, destinationRectanglesStride, sourceRectanglesStride, colorsStride, transformsStride);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SpriteBatch_SetSprites(self: *const T, startIndex: u32, spriteCount: u32, destinationRectangles: ?*const D2D_RECT_F, sourceRectangles: ?*const D2D_RECT_U, colors: ?*const D2D1_COLOR_F, transforms: ?*const D2D_MATRIX_3X2_F, destinationRectanglesStride: u32, sourceRectanglesStride: u32, colorsStride: u32, transformsStride: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SpriteBatch.VTable, self.vtable).SetSprites(@ptrCast(*const ID2D1SpriteBatch, self), startIndex, spriteCount, destinationRectangles, sourceRectangles, colors, transforms, destinationRectanglesStride, sourceRectanglesStride, colorsStride, transformsStride);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SpriteBatch_GetSprites(self: *const T, startIndex: u32, spriteCount: u32, destinationRectangles: ?[*]D2D_RECT_F, sourceRectangles: ?[*]D2D_RECT_U, colors: ?[*]D2D1_COLOR_F, transforms: ?[*]D2D_MATRIX_3X2_F) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SpriteBatch.VTable, self.vtable).GetSprites(@ptrCast(*const ID2D1SpriteBatch, self), startIndex, spriteCount, destinationRectangles, sourceRectangles, colors, transforms);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SpriteBatch_GetSpriteCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SpriteBatch.VTable, self.vtable).GetSpriteCount(@ptrCast(*const ID2D1SpriteBatch, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SpriteBatch_Clear(self: *const T) callconv(.Inline) void {
return @ptrCast(*const ID2D1SpriteBatch.VTable, self.vtable).Clear(@ptrCast(*const ID2D1SpriteBatch, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1DeviceContext3_Value = @import("../zig.zig").Guid.initString("235a7496-8351-414c-bcd4-6672ab2d8e00");
pub const IID_ID2D1DeviceContext3 = &IID_ID2D1DeviceContext3_Value;
pub const ID2D1DeviceContext3 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext2.VTable,
CreateSpriteBatch: fn(
self: *const ID2D1DeviceContext3,
spriteBatch: ?*?*ID2D1SpriteBatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawSpriteBatch: fn(
self: *const ID2D1DeviceContext3,
spriteBatch: ?*ID2D1SpriteBatch,
startIndex: u32,
spriteCount: u32,
bitmap: ?*ID2D1Bitmap,
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
spriteOptions: D2D1_SPRITE_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext3_CreateSpriteBatch(self: *const T, spriteBatch: ?*?*ID2D1SpriteBatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext3.VTable, self.vtable).CreateSpriteBatch(@ptrCast(*const ID2D1DeviceContext3, self), spriteBatch);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext3_DrawSpriteBatch(self: *const T, spriteBatch: ?*ID2D1SpriteBatch, startIndex: u32, spriteCount: u32, bitmap: ?*ID2D1Bitmap, interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE, spriteOptions: D2D1_SPRITE_OPTIONS) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext3.VTable, self.vtable).DrawSpriteBatch(@ptrCast(*const ID2D1DeviceContext3, self), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Device3_Value = @import("../zig.zig").Guid.initString("852f2087-802c-4037-ab60-ff2e7ee6fc01");
pub const IID_ID2D1Device3 = &IID_ID2D1Device3_Value;
pub const ID2D1Device3 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device2.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device3,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext3: ?*?*ID2D1DeviceContext3,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device3_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext3: ?*?*ID2D1DeviceContext3) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device3.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device3, self), options, deviceContext3);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Factory4_Value = @import("../zig.zig").Guid.initString("bd4ec2d2-0662-4bee-ba8e-6f29f032e096");
pub const IID_ID2D1Factory4 = &IID_ID2D1Factory4_Value;
pub const ID2D1Factory4 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory3.VTable,
CreateDevice: fn(
self: *const ID2D1Factory4,
dxgiDevice: ?*IDXGIDevice,
d2dDevice3: ?*?*ID2D1Device3,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory4_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice3: ?*?*ID2D1Device3) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory4.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory4, self), dxgiDevice, d2dDevice3);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1CommandSink3_Value = @import("../zig.zig").Guid.initString("18079135-4cf3-4868-bc8e-06067e6d242d");
pub const IID_ID2D1CommandSink3 = &IID_ID2D1CommandSink3_Value;
pub const ID2D1CommandSink3 = extern struct {
pub const VTable = extern struct {
base: ID2D1CommandSink2.VTable,
DrawSpriteBatch: fn(
self: *const ID2D1CommandSink3,
spriteBatch: ?*ID2D1SpriteBatch,
startIndex: u32,
spriteCount: u32,
bitmap: ?*ID2D1Bitmap,
interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE,
spriteOptions: D2D1_SPRITE_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1CommandSink2.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink3_DrawSpriteBatch(self: *const T, spriteBatch: ?*ID2D1SpriteBatch, startIndex: u32, spriteCount: u32, bitmap: ?*ID2D1Bitmap, interpolationMode: D2D1_BITMAP_INTERPOLATION_MODE, spriteOptions: D2D1_SPRITE_OPTIONS) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink3.VTable, self.vtable).DrawSpriteBatch(@ptrCast(*const ID2D1CommandSink3, self), spriteBatch, startIndex, spriteCount, bitmap, interpolationMode, spriteOptions);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1SvgGlyphStyle_Value = @import("../zig.zig").Guid.initString("af671749-d241-4db8-8e41-dcc2e5c1a438");
pub const IID_ID2D1SvgGlyphStyle = &IID_ID2D1SvgGlyphStyle_Value;
pub const ID2D1SvgGlyphStyle = extern struct {
pub const VTable = extern struct {
base: ID2D1Resource.VTable,
SetFill: fn(
self: *const ID2D1SvgGlyphStyle,
brush: ?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFill: fn(
self: *const ID2D1SvgGlyphStyle,
brush: ?*?*ID2D1Brush,
) callconv(@import("std").os.windows.WINAPI) void,
SetStroke: fn(
self: *const ID2D1SvgGlyphStyle,
brush: ?*ID2D1Brush,
strokeWidth: f32,
dashes: ?[*]const f32,
dashesCount: u32,
dashOffset: f32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStrokeDashesCount: fn(
self: *const ID2D1SvgGlyphStyle,
) callconv(@import("std").os.windows.WINAPI) u32,
GetStroke: fn(
self: *const ID2D1SvgGlyphStyle,
brush: ?*?*ID2D1Brush,
strokeWidth: ?*f32,
dashes: ?[*]f32,
dashesCount: u32,
dashOffset: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Resource.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgGlyphStyle_SetFill(self: *const T, brush: ?*ID2D1Brush) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgGlyphStyle.VTable, self.vtable).SetFill(@ptrCast(*const ID2D1SvgGlyphStyle, self), brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgGlyphStyle_GetFill(self: *const T, brush: ?*?*ID2D1Brush) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgGlyphStyle.VTable, self.vtable).GetFill(@ptrCast(*const ID2D1SvgGlyphStyle, self), brush);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgGlyphStyle_SetStroke(self: *const T, brush: ?*ID2D1Brush, strokeWidth: f32, dashes: ?[*]const f32, dashesCount: u32, dashOffset: f32) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1SvgGlyphStyle.VTable, self.vtable).SetStroke(@ptrCast(*const ID2D1SvgGlyphStyle, self), brush, strokeWidth, dashes, dashesCount, dashOffset);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgGlyphStyle_GetStrokeDashesCount(self: *const T) callconv(.Inline) u32 {
return @ptrCast(*const ID2D1SvgGlyphStyle.VTable, self.vtable).GetStrokeDashesCount(@ptrCast(*const ID2D1SvgGlyphStyle, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1SvgGlyphStyle_GetStroke(self: *const T, brush: ?*?*ID2D1Brush, strokeWidth: ?*f32, dashes: ?[*]f32, dashesCount: u32, dashOffset: ?*f32) callconv(.Inline) void {
return @ptrCast(*const ID2D1SvgGlyphStyle.VTable, self.vtable).GetStroke(@ptrCast(*const ID2D1SvgGlyphStyle, self), brush, strokeWidth, dashes, dashesCount, dashOffset);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1DeviceContext4_Value = @import("../zig.zig").Guid.initString("8c427831-3d90-4476-b647-c4fae349e4db");
pub const IID_ID2D1DeviceContext4 = &IID_ID2D1DeviceContext4_Value;
pub const ID2D1DeviceContext4 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext3.VTable,
CreateSvgGlyphStyle: fn(
self: *const ID2D1DeviceContext4,
svgGlyphStyle: ?*?*ID2D1SvgGlyphStyle,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawText: fn(
self: *const ID2D1DeviceContext4,
string: [*:0]const u16,
stringLength: u32,
textFormat: ?*IDWriteTextFormat,
layoutRect: ?*const D2D_RECT_F,
defaultFillBrush: ?*ID2D1Brush,
svgGlyphStyle: ?*ID2D1SvgGlyphStyle,
colorPaletteIndex: u32,
options: D2D1_DRAW_TEXT_OPTIONS,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
DrawTextLayout: fn(
self: *const ID2D1DeviceContext4,
origin: D2D_POINT_2F,
textLayout: ?*IDWriteTextLayout,
defaultFillBrush: ?*ID2D1Brush,
svgGlyphStyle: ?*ID2D1SvgGlyphStyle,
colorPaletteIndex: u32,
options: D2D1_DRAW_TEXT_OPTIONS,
) callconv(@import("std").os.windows.WINAPI) void,
DrawColorBitmapGlyphRun: fn(
self: *const ID2D1DeviceContext4,
glyphImageFormat: DWRITE_GLYPH_IMAGE_FORMATS,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
measuringMode: DWRITE_MEASURING_MODE,
bitmapSnapOption: D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION,
) callconv(@import("std").os.windows.WINAPI) void,
DrawSvgGlyphRun: fn(
self: *const ID2D1DeviceContext4,
baselineOrigin: D2D_POINT_2F,
glyphRun: ?*const DWRITE_GLYPH_RUN,
defaultFillBrush: ?*ID2D1Brush,
svgGlyphStyle: ?*ID2D1SvgGlyphStyle,
colorPaletteIndex: u32,
measuringMode: DWRITE_MEASURING_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
GetColorBitmapGlyphImage: fn(
self: *const ID2D1DeviceContext4,
glyphImageFormat: DWRITE_GLYPH_IMAGE_FORMATS,
glyphOrigin: D2D_POINT_2F,
fontFace: ?*IDWriteFontFace,
fontEmSize: f32,
glyphIndex: u16,
isSideways: BOOL,
worldTransform: ?*const D2D_MATRIX_3X2_F,
dpiX: f32,
dpiY: f32,
glyphTransform: ?*D2D_MATRIX_3X2_F,
glyphImage: ?*?*ID2D1Image,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetSvgGlyphImage: fn(
self: *const ID2D1DeviceContext4,
glyphOrigin: D2D_POINT_2F,
fontFace: ?*IDWriteFontFace,
fontEmSize: f32,
glyphIndex: u16,
isSideways: BOOL,
worldTransform: ?*const D2D_MATRIX_3X2_F,
defaultFillBrush: ?*ID2D1Brush,
svgGlyphStyle: ?*ID2D1SvgGlyphStyle,
colorPaletteIndex: u32,
glyphTransform: ?*D2D_MATRIX_3X2_F,
glyphImage: ?*?*ID2D1CommandList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_CreateSvgGlyphStyle(self: *const T, svgGlyphStyle: ?*?*ID2D1SvgGlyphStyle) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).CreateSvgGlyphStyle(@ptrCast(*const ID2D1DeviceContext4, self), svgGlyphStyle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_DrawText(self: *const T, string: [*:0]const u16, stringLength: u32, textFormat: ?*IDWriteTextFormat, layoutRect: ?*const D2D_RECT_F, defaultFillBrush: ?*ID2D1Brush, svgGlyphStyle: ?*ID2D1SvgGlyphStyle, colorPaletteIndex: u32, options: D2D1_DRAW_TEXT_OPTIONS, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).DrawText(@ptrCast(*const ID2D1DeviceContext4, self), string, stringLength, textFormat, layoutRect, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_DrawTextLayout(self: *const T, origin: D2D_POINT_2F, textLayout: ?*IDWriteTextLayout, defaultFillBrush: ?*ID2D1Brush, svgGlyphStyle: ?*ID2D1SvgGlyphStyle, colorPaletteIndex: u32, options: D2D1_DRAW_TEXT_OPTIONS) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).DrawTextLayout(@ptrCast(*const ID2D1DeviceContext4, self), origin, textLayout, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, options);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_DrawColorBitmapGlyphRun(self: *const T, glyphImageFormat: DWRITE_GLYPH_IMAGE_FORMATS, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, measuringMode: DWRITE_MEASURING_MODE, bitmapSnapOption: D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).DrawColorBitmapGlyphRun(@ptrCast(*const ID2D1DeviceContext4, self), glyphImageFormat, baselineOrigin, glyphRun, measuringMode, bitmapSnapOption);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_DrawSvgGlyphRun(self: *const T, baselineOrigin: D2D_POINT_2F, glyphRun: ?*const DWRITE_GLYPH_RUN, defaultFillBrush: ?*ID2D1Brush, svgGlyphStyle: ?*ID2D1SvgGlyphStyle, colorPaletteIndex: u32, measuringMode: DWRITE_MEASURING_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).DrawSvgGlyphRun(@ptrCast(*const ID2D1DeviceContext4, self), baselineOrigin, glyphRun, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, measuringMode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_GetColorBitmapGlyphImage(self: *const T, glyphImageFormat: DWRITE_GLYPH_IMAGE_FORMATS, glyphOrigin: D2D_POINT_2F, fontFace: ?*IDWriteFontFace, fontEmSize: f32, glyphIndex: u16, isSideways: BOOL, worldTransform: ?*const D2D_MATRIX_3X2_F, dpiX: f32, dpiY: f32, glyphTransform: ?*D2D_MATRIX_3X2_F, glyphImage: ?*?*ID2D1Image) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).GetColorBitmapGlyphImage(@ptrCast(*const ID2D1DeviceContext4, self), glyphImageFormat, glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, dpiX, dpiY, glyphTransform, glyphImage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext4_GetSvgGlyphImage(self: *const T, glyphOrigin: D2D_POINT_2F, fontFace: ?*IDWriteFontFace, fontEmSize: f32, glyphIndex: u16, isSideways: BOOL, worldTransform: ?*const D2D_MATRIX_3X2_F, defaultFillBrush: ?*ID2D1Brush, svgGlyphStyle: ?*ID2D1SvgGlyphStyle, colorPaletteIndex: u32, glyphTransform: ?*D2D_MATRIX_3X2_F, glyphImage: ?*?*ID2D1CommandList) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext4.VTable, self.vtable).GetSvgGlyphImage(@ptrCast(*const ID2D1DeviceContext4, self), glyphOrigin, fontFace, fontEmSize, glyphIndex, isSideways, worldTransform, defaultFillBrush, svgGlyphStyle, colorPaletteIndex, glyphTransform, glyphImage);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Device4_Value = @import("../zig.zig").Guid.initString("d7bdb159-5683-4a46-bc9c-72dc720b858b");
pub const IID_ID2D1Device4 = &IID_ID2D1Device4_Value;
pub const ID2D1Device4 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device3.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device4,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext4: ?*?*ID2D1DeviceContext4,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMaximumColorGlyphCacheMemory: fn(
self: *const ID2D1Device4,
maximumInBytes: u64,
) callconv(@import("std").os.windows.WINAPI) void,
GetMaximumColorGlyphCacheMemory: fn(
self: *const ID2D1Device4,
) callconv(@import("std").os.windows.WINAPI) u64,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device4_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext4: ?*?*ID2D1DeviceContext4) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device4.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device4, self), options, deviceContext4);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device4_SetMaximumColorGlyphCacheMemory(self: *const T, maximumInBytes: u64) callconv(.Inline) void {
return @ptrCast(*const ID2D1Device4.VTable, self.vtable).SetMaximumColorGlyphCacheMemory(@ptrCast(*const ID2D1Device4, self), maximumInBytes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device4_GetMaximumColorGlyphCacheMemory(self: *const T) callconv(.Inline) u64 {
return @ptrCast(*const ID2D1Device4.VTable, self.vtable).GetMaximumColorGlyphCacheMemory(@ptrCast(*const ID2D1Device4, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Factory5_Value = @import("../zig.zig").Guid.initString("c4349994-838e-4b0f-8cab-44997d9eeacc");
pub const IID_ID2D1Factory5 = &IID_ID2D1Factory5_Value;
pub const ID2D1Factory5 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory4.VTable,
CreateDevice: fn(
self: *const ID2D1Factory5,
dxgiDevice: ?*IDXGIDevice,
d2dDevice4: ?*?*ID2D1Device4,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory5_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice4: ?*?*ID2D1Device4) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory5.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory5, self), dxgiDevice, d2dDevice4);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1CommandSink4_Value = @import("../zig.zig").Guid.initString("c78a6519-40d6-4218-b2de-beeeb744bb3e");
pub const IID_ID2D1CommandSink4 = &IID_ID2D1CommandSink4_Value;
pub const ID2D1CommandSink4 = extern struct {
pub const VTable = extern struct {
base: ID2D1CommandSink3.VTable,
SetPrimitiveBlend2: fn(
self: *const ID2D1CommandSink4,
primitiveBlend: D2D1_PRIMITIVE_BLEND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1CommandSink3.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink4_SetPrimitiveBlend2(self: *const T, primitiveBlend: D2D1_PRIMITIVE_BLEND) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink4.VTable, self.vtable).SetPrimitiveBlend2(@ptrCast(*const ID2D1CommandSink4, self), primitiveBlend);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1ColorContext1_Value = @import("../zig.zig").Guid.initString("1ab42875-c57f-4be9-bd85-9cd78d6f55ee");
pub const IID_ID2D1ColorContext1 = &IID_ID2D1ColorContext1_Value;
pub const ID2D1ColorContext1 = extern struct {
pub const VTable = extern struct {
base: ID2D1ColorContext.VTable,
GetColorContextType: fn(
self: *const ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_CONTEXT_TYPE,
GetDXGIColorSpace: fn(
self: *const ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) DXGI_COLOR_SPACE_TYPE,
GetSimpleColorProfile: fn(
self: *const ID2D1ColorContext1,
simpleProfile: ?*D2D1_SIMPLE_COLOR_PROFILE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1ColorContext.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext1_GetColorContextType(self: *const T) callconv(.Inline) D2D1_COLOR_CONTEXT_TYPE {
return @ptrCast(*const ID2D1ColorContext1.VTable, self.vtable).GetColorContextType(@ptrCast(*const ID2D1ColorContext1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext1_GetDXGIColorSpace(self: *const T) callconv(.Inline) DXGI_COLOR_SPACE_TYPE {
return @ptrCast(*const ID2D1ColorContext1.VTable, self.vtable).GetDXGIColorSpace(@ptrCast(*const ID2D1ColorContext1, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1ColorContext1_GetSimpleColorProfile(self: *const T, simpleProfile: ?*D2D1_SIMPLE_COLOR_PROFILE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1ColorContext1.VTable, self.vtable).GetSimpleColorProfile(@ptrCast(*const ID2D1ColorContext1, self), simpleProfile);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1DeviceContext5_Value = @import("../zig.zig").Guid.initString("7836d248-68cc-4df6-b9e8-de991bf62eb7");
pub const IID_ID2D1DeviceContext5 = &IID_ID2D1DeviceContext5_Value;
pub const ID2D1DeviceContext5 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext4.VTable,
CreateSvgDocument: fn(
self: *const ID2D1DeviceContext5,
inputXmlStream: ?*IStream,
viewportSize: D2D_SIZE_F,
svgDocument: ?*?*ID2D1SvgDocument,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DrawSvgDocument: fn(
self: *const ID2D1DeviceContext5,
svgDocument: ?*ID2D1SvgDocument,
) callconv(@import("std").os.windows.WINAPI) void,
CreateColorContextFromDxgiColorSpace: fn(
self: *const ID2D1DeviceContext5,
colorSpace: DXGI_COLOR_SPACE_TYPE,
colorContext: ?*?*ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromSimpleColorProfile: fn(
self: *const ID2D1DeviceContext5,
simpleProfile: ?*const D2D1_SIMPLE_COLOR_PROFILE,
colorContext: ?*?*ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext5_CreateSvgDocument(self: *const T, inputXmlStream: ?*IStream, viewportSize: D2D_SIZE_F, svgDocument: ?*?*ID2D1SvgDocument) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext5.VTable, self.vtable).CreateSvgDocument(@ptrCast(*const ID2D1DeviceContext5, self), inputXmlStream, viewportSize, svgDocument);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext5_DrawSvgDocument(self: *const T, svgDocument: ?*ID2D1SvgDocument) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext5.VTable, self.vtable).DrawSvgDocument(@ptrCast(*const ID2D1DeviceContext5, self), svgDocument);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext5_CreateColorContextFromDxgiColorSpace(self: *const T, colorSpace: DXGI_COLOR_SPACE_TYPE, colorContext: ?*?*ID2D1ColorContext1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext5.VTable, self.vtable).CreateColorContextFromDxgiColorSpace(@ptrCast(*const ID2D1DeviceContext5, self), colorSpace, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext5_CreateColorContextFromSimpleColorProfile(self: *const T, simpleProfile: ?*const D2D1_SIMPLE_COLOR_PROFILE, colorContext: ?*?*ID2D1ColorContext1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1DeviceContext5.VTable, self.vtable).CreateColorContextFromSimpleColorProfile(@ptrCast(*const ID2D1DeviceContext5, self), simpleProfile, colorContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Device5_Value = @import("../zig.zig").Guid.initString("d55ba0a4-6405-4694-aef5-08ee1a4358b4");
pub const IID_ID2D1Device5 = &IID_ID2D1Device5_Value;
pub const ID2D1Device5 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device4.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device5,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext5: ?*?*ID2D1DeviceContext5,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device5_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext5: ?*?*ID2D1DeviceContext5) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device5.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device5, self), options, deviceContext5);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Factory6_Value = @import("../zig.zig").Guid.initString("f9976f46-f642-44c1-97ca-da32ea2a2635");
pub const IID_ID2D1Factory6 = &IID_ID2D1Factory6_Value;
pub const ID2D1Factory6 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory5.VTable,
CreateDevice: fn(
self: *const ID2D1Factory6,
dxgiDevice: ?*IDXGIDevice,
d2dDevice5: ?*?*ID2D1Device5,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory5.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory6_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice5: ?*?*ID2D1Device5) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory6.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory6, self), dxgiDevice, d2dDevice5);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1CommandSink5_Value = @import("../zig.zig").Guid.initString("7047dd26-b1e7-44a7-959a-8349e2144fa8");
pub const IID_ID2D1CommandSink5 = &IID_ID2D1CommandSink5_Value;
pub const ID2D1CommandSink5 = extern struct {
pub const VTable = extern struct {
base: ID2D1CommandSink4.VTable,
BlendImage: fn(
self: *const ID2D1CommandSink5,
image: ?*ID2D1Image,
blendMode: D2D1_BLEND_MODE,
targetOffset: ?*const D2D_POINT_2F,
imageRectangle: ?*const D2D_RECT_F,
interpolationMode: D2D1_INTERPOLATION_MODE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1CommandSink4.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1CommandSink5_BlendImage(self: *const T, image: ?*ID2D1Image, blendMode: D2D1_BLEND_MODE, targetOffset: ?*const D2D_POINT_2F, imageRectangle: ?*const D2D_RECT_F, interpolationMode: D2D1_INTERPOLATION_MODE) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1CommandSink5.VTable, self.vtable).BlendImage(@ptrCast(*const ID2D1CommandSink5, self), image, blendMode, targetOffset, imageRectangle, interpolationMode);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1DeviceContext6_Value = @import("../zig.zig").Guid.initString("985f7e37-4ed0-4a19-98a3-15b0edfde306");
pub const IID_ID2D1DeviceContext6 = &IID_ID2D1DeviceContext6_Value;
pub const ID2D1DeviceContext6 = extern struct {
pub const VTable = extern struct {
base: ID2D1DeviceContext5.VTable,
BlendImage: fn(
self: *const ID2D1DeviceContext6,
image: ?*ID2D1Image,
blendMode: D2D1_BLEND_MODE,
targetOffset: ?*const D2D_POINT_2F,
imageRectangle: ?*const D2D_RECT_F,
interpolationMode: D2D1_INTERPOLATION_MODE,
) callconv(@import("std").os.windows.WINAPI) void,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1DeviceContext5.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1DeviceContext6_BlendImage(self: *const T, image: ?*ID2D1Image, blendMode: D2D1_BLEND_MODE, targetOffset: ?*const D2D_POINT_2F, imageRectangle: ?*const D2D_RECT_F, interpolationMode: D2D1_INTERPOLATION_MODE) callconv(.Inline) void {
return @ptrCast(*const ID2D1DeviceContext6.VTable, self.vtable).BlendImage(@ptrCast(*const ID2D1DeviceContext6, self), image, blendMode, targetOffset, imageRectangle, interpolationMode);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Device6_Value = @import("../zig.zig").Guid.initString("7bfef914-2d75-4bad-be87-e18ddb077b6d");
pub const IID_ID2D1Device6 = &IID_ID2D1Device6_Value;
pub const ID2D1Device6 = extern struct {
pub const VTable = extern struct {
base: ID2D1Device5.VTable,
CreateDeviceContext: fn(
self: *const ID2D1Device6,
options: D2D1_DEVICE_CONTEXT_OPTIONS,
deviceContext6: ?*?*ID2D1DeviceContext6,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Device5.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Device6_CreateDeviceContext(self: *const T, options: D2D1_DEVICE_CONTEXT_OPTIONS, deviceContext6: ?*?*ID2D1DeviceContext6) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Device6.VTable, self.vtable).CreateDeviceContext(@ptrCast(*const ID2D1Device6, self), options, deviceContext6);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1Factory7_Value = @import("../zig.zig").Guid.initString("bdc2bdd3-b96c-4de6-bdf7-99d4745454de");
pub const IID_ID2D1Factory7 = &IID_ID2D1Factory7_Value;
pub const ID2D1Factory7 = extern struct {
pub const VTable = extern struct {
base: ID2D1Factory6.VTable,
CreateDevice: fn(
self: *const ID2D1Factory7,
dxgiDevice: ?*IDXGIDevice,
d2dDevice6: ?*?*ID2D1Device6,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1Factory6.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1Factory7_CreateDevice(self: *const T, dxgiDevice: ?*IDXGIDevice, d2dDevice6: ?*?*ID2D1Device6) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1Factory7.VTable, self.vtable).CreateDevice(@ptrCast(*const ID2D1Factory7, self), dxgiDevice, d2dDevice6);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1EffectContext1_Value = @import("../zig.zig").Guid.initString("84ab595a-fc81-4546-bacd-e8ef4d8abe7a");
pub const IID_ID2D1EffectContext1 = &IID_ID2D1EffectContext1_Value;
pub const ID2D1EffectContext1 = extern struct {
pub const VTable = extern struct {
base: ID2D1EffectContext.VTable,
CreateLookupTable3D: fn(
self: *const ID2D1EffectContext1,
precision: D2D1_BUFFER_PRECISION,
extents: *[3]u32,
data: [*:0]const u8,
dataCount: u32,
strides: *[2]u32,
lookupTable: ?*?*ID2D1LookupTable3D,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1EffectContext.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext1_CreateLookupTable3D(self: *const T, precision: D2D1_BUFFER_PRECISION, extents: *[3]u32, data: [*:0]const u8, dataCount: u32, strides: *[2]u32, lookupTable: ?*?*ID2D1LookupTable3D) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext1.VTable, self.vtable).CreateLookupTable3D(@ptrCast(*const ID2D1EffectContext1, self), precision, extents, data, dataCount, strides, lookupTable);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ID2D1EffectContext2_Value = @import("../zig.zig").Guid.initString("577ad2a0-9fc7-4dda-8b18-dab810140052");
pub const IID_ID2D1EffectContext2 = &IID_ID2D1EffectContext2_Value;
pub const ID2D1EffectContext2 = extern struct {
pub const VTable = extern struct {
base: ID2D1EffectContext1.VTable,
CreateColorContextFromDxgiColorSpace: fn(
self: *const ID2D1EffectContext2,
colorSpace: DXGI_COLOR_SPACE_TYPE,
colorContext: ?*?*ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateColorContextFromSimpleColorProfile: fn(
self: *const ID2D1EffectContext2,
simpleProfile: ?*const D2D1_SIMPLE_COLOR_PROFILE,
colorContext: ?*?*ID2D1ColorContext1,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ID2D1EffectContext1.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext2_CreateColorContextFromDxgiColorSpace(self: *const T, colorSpace: DXGI_COLOR_SPACE_TYPE, colorContext: ?*?*ID2D1ColorContext1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext2.VTable, self.vtable).CreateColorContextFromDxgiColorSpace(@ptrCast(*const ID2D1EffectContext2, self), colorSpace, colorContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ID2D1EffectContext2_CreateColorContextFromSimpleColorProfile(self: *const T, simpleProfile: ?*const D2D1_SIMPLE_COLOR_PROFILE, colorContext: ?*?*ID2D1ColorContext1) callconv(.Inline) HRESULT {
return @ptrCast(*const ID2D1EffectContext2.VTable, self.vtable).CreateColorContextFromSimpleColorProfile(@ptrCast(*const ID2D1EffectContext2, self), simpleProfile, colorContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (13)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.1'
pub extern "d2d1" fn D2D1CreateFactory(
factoryType: D2D1_FACTORY_TYPE,
riid: ?*const Guid,
pFactoryOptions: ?*const D2D1_FACTORY_OPTIONS,
ppIFactory: **anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows6.1'
pub extern "d2d1" fn D2D1MakeRotateMatrix(
angle: f32,
center: D2D_POINT_2F,
matrix: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.1'
pub extern "d2d1" fn D2D1MakeSkewMatrix(
angleX: f32,
angleY: f32,
center: D2D_POINT_2F,
matrix: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) void;
// TODO: this type is limited to platform 'windows6.1'
pub extern "d2d1" fn D2D1IsMatrixInvertible(
matrix: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows6.1'
pub extern "d2d1" fn D2D1InvertMatrix(
matrix: ?*D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "d2d1" fn D2D1CreateDevice(
dxgiDevice: ?*IDXGIDevice,
creationProperties: ?*const D2D1_CREATION_PROPERTIES,
d2dDevice: ?*?*ID2D1Device,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
// TODO: this type is limited to platform 'windows8.0'
pub extern "d2d1" fn D2D1CreateDeviceContext(
dxgiSurface: ?*IDXGISurface,
creationProperties: ?*const D2D1_CREATION_PROPERTIES,
d2dDeviceContext: ?*?*ID2D1DeviceContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub extern "d2d1" fn D2D1ConvertColorSpace(
sourceColorSpace: D2D1_COLOR_SPACE,
destinationColorSpace: D2D1_COLOR_SPACE,
color: ?*const D2D1_COLOR_F,
) callconv(@import("std").os.windows.WINAPI) D2D1_COLOR_F;
pub extern "d2d1" fn D2D1SinCos(
angle: f32,
s: ?*f32,
c: ?*f32,
) callconv(@import("std").os.windows.WINAPI) void;
pub extern "d2d1" fn D2D1Tan(
angle: f32,
) callconv(@import("std").os.windows.WINAPI) f32;
pub extern "d2d1" fn D2D1Vec3Length(
x: f32,
y: f32,
z: f32,
) callconv(@import("std").os.windows.WINAPI) f32;
// TODO: this type is limited to platform 'windows8.1'
pub extern "d2d1" fn D2D1ComputeMaximumScaleFactor(
matrix: ?*const D2D_MATRIX_3X2_F,
) callconv(@import("std").os.windows.WINAPI) f32;
// TODO: this type is limited to platform 'windows10.0.10240'
pub extern "d2d1" fn D2D1GetGradientMeshInteriorPointsFromCoonsPatch(
pPoint0: ?*const D2D_POINT_2F,
pPoint1: ?*const D2D_POINT_2F,
pPoint2: ?*const D2D_POINT_2F,
pPoint3: ?*const D2D_POINT_2F,
pPoint4: ?*const D2D_POINT_2F,
pPoint5: ?*const D2D_POINT_2F,
pPoint6: ?*const D2D_POINT_2F,
pPoint7: ?*const D2D_POINT_2F,
pPoint8: ?*const D2D_POINT_2F,
pPoint9: ?*const D2D_POINT_2F,
pPoint10: ?*const D2D_POINT_2F,
pPoint11: ?*const D2D_POINT_2F,
pTensorPoint11: ?*D2D_POINT_2F,
pTensorPoint12: ?*D2D_POINT_2F,
pTensorPoint21: ?*D2D_POINT_2F,
pTensorPoint22: ?*D2D_POINT_2F,
) callconv(@import("std").os.windows.WINAPI) void;
//--------------------------------------------------------------------------------
// 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 (47)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const D2D1_ALPHA_MODE = @import("../graphics/direct2d/common.zig").D2D1_ALPHA_MODE;
const D2D1_BEZIER_SEGMENT = @import("../graphics/direct2d/common.zig").D2D1_BEZIER_SEGMENT;
const D2D1_BLEND_MODE = @import("../graphics/direct2d/common.zig").D2D1_BLEND_MODE;
const D2D1_COLOR_F = @import("../graphics/direct2d/common.zig").D2D1_COLOR_F;
const D2D1_COMPOSITE_MODE = @import("../graphics/direct2d/common.zig").D2D1_COMPOSITE_MODE;
const D2D1_FILL_MODE = @import("../graphics/direct2d/common.zig").D2D1_FILL_MODE;
const D2D1_PIXEL_FORMAT = @import("../graphics/direct2d/common.zig").D2D1_PIXEL_FORMAT;
const D2D_MATRIX_3X2_F = @import("../graphics/direct2d/common.zig").D2D_MATRIX_3X2_F;
const D2D_MATRIX_4X3_F = @import("../graphics/direct2d/common.zig").D2D_MATRIX_4X3_F;
const D2D_MATRIX_4X4_F = @import("../graphics/direct2d/common.zig").D2D_MATRIX_4X4_F;
const D2D_MATRIX_5X4_F = @import("../graphics/direct2d/common.zig").D2D_MATRIX_5X4_F;
const D2D_POINT_2F = @import("../graphics/direct2d/common.zig").D2D_POINT_2F;
const D2D_POINT_2U = @import("../graphics/direct2d/common.zig").D2D_POINT_2U;
const D2D_RECT_F = @import("../graphics/direct2d/common.zig").D2D_RECT_F;
const D2D_RECT_U = @import("../graphics/direct2d/common.zig").D2D_RECT_U;
const D2D_SIZE_F = @import("../graphics/direct2d/common.zig").D2D_SIZE_F;
const D2D_SIZE_U = @import("../graphics/direct2d/common.zig").D2D_SIZE_U;
const D3D_FEATURE_LEVEL = @import("../graphics/direct3d.zig").D3D_FEATURE_LEVEL;
const DWRITE_GLYPH_IMAGE_FORMATS = @import("../graphics/direct_write.zig").DWRITE_GLYPH_IMAGE_FORMATS;
const DWRITE_GLYPH_RUN = @import("../graphics/direct_write.zig").DWRITE_GLYPH_RUN;
const DWRITE_GLYPH_RUN_DESCRIPTION = @import("../graphics/direct_write.zig").DWRITE_GLYPH_RUN_DESCRIPTION;
const DWRITE_MEASURING_MODE = @import("../graphics/direct_write.zig").DWRITE_MEASURING_MODE;
const DXGI_COLOR_SPACE_TYPE = @import("../graphics/dxgi/common.zig").DXGI_COLOR_SPACE_TYPE;
const DXGI_FORMAT = @import("../graphics/dxgi/common.zig").DXGI_FORMAT;
const HDC = @import("../graphics/gdi.zig").HDC;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const ID2D1SimplifiedGeometrySink = @import("../graphics/direct2d/common.zig").ID2D1SimplifiedGeometrySink;
const IDWriteFontFace = @import("../graphics/direct_write.zig").IDWriteFontFace;
const IDWriteRenderingParams = @import("../graphics/direct_write.zig").IDWriteRenderingParams;
const IDWriteTextFormat = @import("../graphics/direct_write.zig").IDWriteTextFormat;
const IDWriteTextLayout = @import("../graphics/direct_write.zig").IDWriteTextLayout;
const IDXGIDevice = @import("../graphics/dxgi.zig").IDXGIDevice;
const IDXGISurface = @import("../graphics/dxgi.zig").IDXGISurface;
const IPrintDocumentPackageTarget = @import("../storage/xps/printing.zig").IPrintDocumentPackageTarget;
const IStream = @import("../system/com.zig").IStream;
const IUnknown = @import("../system/com.zig").IUnknown;
const IWICBitmap = @import("../graphics/imaging.zig").IWICBitmap;
const IWICBitmapSource = @import("../graphics/imaging.zig").IWICBitmapSource;
const IWICColorContext = @import("../graphics/imaging.zig").IWICColorContext;
const IWICImagingFactory = @import("../graphics/imaging.zig").IWICImagingFactory;
const POINT = @import("../foundation.zig").POINT;
const PSTR = @import("../foundation.zig").PSTR;
const PWSTR = @import("../foundation.zig").PWSTR;
const RECT = @import("../foundation.zig").RECT;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "PD2D1_EFFECT_FACTORY")) { _ = PD2D1_EFFECT_FACTORY; }
if (@hasDecl(@This(), "PD2D1_PROPERTY_SET_FUNCTION")) { _ = PD2D1_PROPERTY_SET_FUNCTION; }
if (@hasDecl(@This(), "PD2D1_PROPERTY_GET_FUNCTION")) { _ = PD2D1_PROPERTY_GET_FUNCTION; }
@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 (1)
//--------------------------------------------------------------------------------
pub const common = @import("direct2d/common.zig"); | win32/graphics/direct2d.zig |
const std = @import("std");
const testing = @import("testing.zig");
pub const Map = struct {
const Self = @This();
const MapType = std.StringHashMap([]const u8);
const MapEntry = MapType.Entry;
const Iterator = MapType.Iterator;
allocator: *std.mem.Allocator,
map: MapType,
pub fn init(allocator: *std.mem.Allocator) Self {
return Self{
.allocator = allocator,
.map = MapType.init(allocator),
};
}
pub fn put(self: *Self, key: []const u8, value: []const u8) !?MapEntry {
if (self.map.getEntry(key)) |kv| {
self.allocator.free(kv.value);
kv.value = value;
return kv.*;
} else {
return try self.map.fetchPut(key, value);
}
}
pub fn count(self: Self) usize {
return self.map.count();
}
pub fn iterator(self: Self) Iterator {
return self.map.iterator();
}
pub fn getEntry(self: Self, key: []const u8) ?*MapEntry {
return self.map.getEntry(key);
}
};
pub const Entry = struct {
key: []const u8,
value: []const u8,
};
const EntryList = []const []const u8;
pub const Multimap = struct {
const Self = @This();
const MapType = std.StringHashMap(EntryList);
map: MapType,
const KV = struct {
key: []const u8,
value: EntryList,
};
const Iterator = struct {
map_it: MapType.Iterator,
pub fn next(it: *Iterator) ?KV {
if (it.map_it.next()) |entry| {
return KV{
.key = entry.key,
.value = entry.value,
};
}
return null;
}
};
pub fn init(allocator: *std.mem.Allocator) Self {
return Self{
.map = std.StringHashMap(EntryList).init(allocator),
};
}
pub fn put(self: *Self, key: []const u8, values: []const []const u8) !void {
_ = try self.map.put(key, values);
}
pub fn get(self: Self, key: []const u8) ?[]const []const u8 {
if (self.map.getEntry(key)) |entry| {
return entry.value;
} else {
return null;
}
}
pub fn count(self: Self) usize {
return self.map.count();
}
pub fn iterator(self: Self) Iterator {
return Iterator{
.map_it = self.map.iterator(),
};
}
};
test "map" {
var arena = testing.arenaAllocator();
defer arena.deinit();
const allocator = &arena.allocator;
var m = Map.init(allocator);
{
const dupe = std.mem.dupe;
const k1 = try dupe(allocator, u8, "foo");
const k2 = try dupe(allocator, u8, "bar");
const v1 = try dupe(allocator, u8, "bar");
const v2 = try dupe(allocator, u8, "heo");
const v3 = try dupe(allocator, u8, "baz");
_ = try m.put(k1, v1);
_ = try m.put(k1, v2);
_ = try m.put(k2, v3);
}
testing.expectEqual(@as(usize, 2), m.count());
testing.expectEqualStrings("heo", m.getEntry("foo").?.value);
testing.expectEqualStrings("baz", m.getEntry("bar").?.value);
}
test "multimap" {
var arena = testing.arenaAllocator();
defer arena.deinit();
const allocator = &arena.allocator;
var m = Multimap.init(allocator);
const dupe = std.mem.dupe;
{
const k1 = try dupe(allocator, u8, "foo");
const v1 = &[_][]const u8{ "bar", "baz" };
_ = try m.put(k1, v1);
}
{
const k2 = try dupe(allocator, u8, "fou");
const v2 = &[_][]const u8{ "bar", "baz" };
_ = try m.put(k2, v2);
}
testing.expectEqual(@as(usize, 2), m.count());
var it = m.iterator();
while (it.next()) |entry| {
testing.expect(std.mem.eql(u8, "foo", entry.key) or std.mem.eql(u8, "fou", entry.key));
const slice = entry.value;
testing.expectEqualStrings("bar", slice[0]);
testing.expectEqualStrings("baz", slice[1]);
}
const slice = m.get("foo").?;
testing.expectEqualStrings("bar", slice[0]);
testing.expectEqualStrings("baz", slice[1]);
const slice2 = m.get("fou").?;
testing.expectEqualStrings("bar", slice[0]);
testing.expectEqualStrings("baz", slice[1]);
} | src/string_map.zig |
const std = @import("std");
const assert = std.debug.assert;
const warn = std.debug.warn;
const Token = @import("json_grammar.tokens.zig").Token;
pub const TokenIndex = *Token;
const FlatHash = @import("../zig-flat-hash/flat_hash.zig");
usingnamespace FlatHash;
pub const VariantList = std.ArrayList(*Variant);
pub const VariantMap = Dictionary(*Variant);
pub const Variant = struct {
id: Id,
pub const Id = enum {
Object,
Array,
IntegerLiteral,
StringLiteral,
BoolLiteral,
NullLiteral,
};
pub fn getByName(self: *Variant, name: []const u8) ?*Variant {
const obj = self.cast(Variant.Object) orelse return null;
return obj.getByName(name);
}
pub fn getString(self: *Variant) ?[]const u8 {
const obj = self.cast(Variant.StringLiteral) orelse return null;
return obj.value;
}
pub fn getInteger(self: *Variant) ?isize {
const obj = self.cast(Variant.IntegerLiteral) orelse return null;
return obj.value;
}
pub fn getBool(self: *Variant) ?bool {
const obj = self.cast(Variant.BoolLiteral) orelse return null;
return obj.value;
}
pub fn cast(base: *Variant, comptime T: type) ?*T {
if (base.id == comptime typeToId(T)) {
return @fieldParentPtr(T, "base", base);
}
return null;
}
pub fn unsafe_cast(base: *Variant, comptime T: type) *T {
return @fieldParentPtr(T, "base", base);
}
pub fn typeToId(comptime T: type) Id {
comptime var i = 0;
inline while (i < @memberCount(Id)) : (i += 1) {
if (T == @field(Variant, @memberName(Id, i))) {
return @field(Id, @memberName(Id, i));
}
}
unreachable;
}
fn indentation(n: usize) void {
var i: usize = 0;
while(i < n) : (i += 1)
warn(" ");
}
pub fn dump(self: *Variant, indent: usize) void {
switch(self.id) {
.NullLiteral => {
warn("null");
},
.BoolLiteral => {
if(self.unsafe_cast(Variant.BoolLiteral).value) warn("true") else warn("false");
},
.IntegerLiteral => {
warn("{}", self.unsafe_cast(Variant.IntegerLiteral).value);
},
.StringLiteral => {
warn("\"");
const slice = self.unsafe_cast(Variant.StringLiteral).value;
var i: usize = 0;
while(i < slice.len) : (i += 1) {
if(slice[i] == '"' or slice[i] == '\\') warn("\\");
warn("{}", slice[i..i+1]);
}
warn("\"");
},
.Object => {
warn("{}", "{");
var it = self.unsafe_cast(Variant.Object).fields.iterator();
var first: bool = true;
while(it.next()) |kv| {
if(!first) {
warn(",\n");
}
else {
warn("\n");
first = false;
}
indentation(indent+2);
warn("\"{}\" : ", kv.key);
kv.value.dump(indent+2);
}
if(!first) {
warn("\n");
indentation(indent);
}
warn("{}", "}");
},
.Array => {
warn("[");
var it = self.unsafe_cast(Variant.Array).elements.iterator();
var first: bool = true;
while(it.next()) |element| {
if(!first) {
warn(",\n");
}
else {
warn("\n");
first = false;
}
indentation(indent+2);
element.dump(indent+2);
}
if(!first) {
warn("\n");
indentation(indent);
}
warn("]");
}
}
}
pub const Object = struct {
base: Variant,
fields: VariantMap,
pub fn getByName(self: *Variant.Object, name: []const u8) ?*Variant {
const kv = self.fields.find(name) orelse return null;
return kv.value;
}
};
pub const Array = struct {
base: Variant,
elements: VariantList,
};
pub const StringLiteral = struct {
base: Variant,
value: []u8,
};
pub const IntegerLiteral = struct {
base: Variant,
value: i64,
};
pub const BoolLiteral = struct {
base: Variant,
value: bool,
};
pub const NullLiteral = struct {
base: Variant,
};
}; | json/json_grammar.types.zig |
const c_cast = @import("std").meta.cast;
const os_tag = @import("std").builtin.os.tag;
pub usingnamespace @cImport({
@cInclude("stdlib.h");
@cInclude("fcntl.h");
@cInclude("locale.h");
@cInclude("errno.h");
@cInclude("time.h");
@cInclude("unistd.h");
@cInclude("signal.h");
@cInclude("pwd.h");
@cInclude("sys/select.h");
@cInclude("sys/types.h");
@cInclude("X11/Xatom.h");
@cInclude("X11/Xlib.h");
@cInclude("X11/cursorfont.h");
@cInclude("X11/keysym.h");
@cInclude("X11/Xft/Xft.h");
@cInclude("X11/XKBlib.h");
switch (os_tag) {
.linux => @cInclude("pty.h"),
.openbsd, .netbsd => @cInclude("util.h"),
.freebsd, .dragonfly => @cInclude("libutil.h"),
else => if (os_tag.isDarwin()) @cInclude("util.h"),
}
});
pub inline fn _DisplayWidth(dpy: *Display, scr: c_int) c_int {
return _ScreenOfDisplay(dpy, scr).*.width;
}
pub inline fn _DisplayHeight(dpy: *Display, scr: c_int) c_int {
return _ScreenOfDisplay(dpy, scr).*.height;
}
pub inline fn _DefaultDepth(dpy: *Display, scr: c_int) c_int {
return _ScreenOfDisplay(dpy, scr).*.root_depth;
}
pub inline fn _ScreenOfDisplay(dpy: *Display, scr: c_int) *Screen {
return @ptrCast(*Screen, &c_cast(_XPrivDisplay, dpy).*.screens[@intCast(usize, scr)]);
}
pub inline fn _FD_MASK(fd: c_int) __fd_mask {
return @as(__fd_mask, 1) << @intCast(u6, @mod(fd, __NFDBITS));
}
pub inline fn _FD_ELT(fd: c_int) usize {
return @intCast(usize, @divTrunc(fd, __NFDBITS));
}
pub inline fn _FD_ZERO(fdset: *fd_set) void {
var __arr = fdset;
var __i: u32 = 0;
while (__i < @sizeOf(fd_set) / @sizeOf(__fd_mask)) : (__i += 1) {
__FDS_BITS(__arr)[__i] = 0;
}
}
pub inline fn _FD_SET(fd: anytype, fdset: *fd_set) void {
__FDS_BITS(fdset)[_FD_ELT(fd)] |= _FD_MASK(fd);
}
pub inline fn _FD_CLR(fd: anytype, fdset: *fd_set) void {
__FDS_BITS(fdset)[_FD_ELT(fd)] &= ~_FD_MASK(fd);
}
pub inline fn _FD_ISSET(fd: anytype, fdset: *fd_set) bool {
return (__FDS_BITS(fdset)[_FD_ELT(fd)] & _FD_MASK(fd)) != 0;
} | src/c.zig |
const std = @import("std");
const lib = @import("lib.zig");
const mem = std.mem;
const testing = std.testing;
const assert = std.debug.assert;
const Tokenizer = lib.Tokenizer;
const Linker = lib.Linker;
const Allocator = std.mem.Allocator;
const Instruction = lib.Instruction;
const Location = Tokenizer.Location;
const Parser = @This();
it: Tokenizer,
program: Instruction.List = .{},
symbols: Linker.Object.SymbolMap = .{},
adjacent: Linker.Object.AdjacentMap = .{},
files: Linker.Object.FileMap = .{},
location: Location = .{},
const Token = Tokenizer.Token;
const log = std.log.scoped(.parser);
pub fn deinit(p: *Parser, gpa: Allocator) void {
p.program.deinit(gpa);
for (p.symbols.values()) |*entry| entry.deinit(gpa);
p.symbols.deinit(gpa);
p.adjacent.deinit(gpa);
p.files.deinit(gpa);
p.* = undefined;
}
fn emitRet(
p: *Parser,
gpa: Allocator,
params: Instruction.Data.Ret,
) !void {
log.debug("emitting ret", .{});
try p.program.append(gpa, .{
.opcode = .ret,
.data = .{ .ret = params },
});
}
fn writeJmp(
p: *Parser,
location: u32,
params: Instruction.Data.Jmp,
) !void {
log.debug("writing jmp over {x:0>8} to {x:0>8}", .{
location,
params.address,
});
p.program.set(location, .{
.opcode = .jmp,
.data = .{ .jmp = params },
});
}
fn emitCall(
p: *Parser,
gpa: Allocator,
tag: []const u8,
params: Instruction.Data.Call,
) !void {
log.debug("emitting call to {s}", .{tag});
const result = try p.symbols.getOrPut(gpa, tag);
if (!result.found_existing) {
result.value_ptr.* = .{};
}
try result.value_ptr.append(gpa, @intCast(u32, p.program.len));
try p.program.append(gpa, .{
.opcode = .call,
.data = .{ .call = params },
});
}
fn emitShell(
p: *Parser,
gpa: Allocator,
params: Instruction.Data.Shell,
) !void {
log.debug("emitting shell command", .{});
try p.program.append(gpa, .{
.opcode = .shell,
.data = .{ .shell = params },
});
}
fn emitWrite(
p: *Parser,
gpa: Allocator,
params: Instruction.Data.Write,
) !void {
log.debug("emitting write {x:0>8} len {d} nl {d}", .{
params.start,
params.len,
params.nl,
});
try p.program.append(gpa, .{
.opcode = .write,
.data = .{ .write = params },
});
}
const Loc = std.builtin.SourceLocation;
pub fn eat(p: *Parser, tag: Token.Tag, loc: Loc) ?[]const u8 {
const state = p.it;
const token = p.it.next();
if (token.tag == tag) {
return token.slice(p.it.bytes);
} else {
log.debug("I'm starving for a '{s}' but this is a '{s}' ({s} {d}:{d})", .{
@tagName(tag),
@tagName(token.tag),
loc.fn_name,
loc.line,
loc.column,
});
p.it = state;
return null;
}
}
pub fn next(p: *Parser) ?Token {
const token = p.it.next();
if (token.tag != .eof) {
return token;
} else {
return null;
}
}
pub fn scan(p: *Parser, tag: Token.Tag) ?Token {
while (p.next()) |token| if (token.tag == tag) {
return token;
};
return null;
}
pub fn expect(p: *Parser, tag: Token.Tag, loc: Loc) ?void {
_ = p.eat(tag, loc) orelse {
log.debug("Wanted a {s}, but got nothing captain ({s} {d}:{d})", .{
@tagName(tag),
loc.fn_name,
loc.line,
loc.column,
});
return null;
};
}
pub fn slice(p: *Parser, from: usize, to: usize) []const u8 {
assert(from <= to);
return p.it.bytes[from..to];
}
pub fn match(p: *Parser, tag: Token.Tag, text: []const u8) ?void {
const state = p.it;
const token = p.it.next();
if (token.tag == tag and mem.eql(u8, token.slice(p.it.bytes), text)) {
return;
} else {
p.it = state;
return null;
}
}
const Header = struct {
language: []const u8,
delimiter: ?[]const u8,
resource: Slice,
type: Type,
pub const Slice = struct {
start: u32,
len: u16,
pub fn slice(self: Slice, text: []const u8) []const u8 {
return text[self.start .. self.start + self.len];
}
};
pub const Type = enum { file, tag };
};
const ParseHeaderError = error{
@"Expected a space between 'lang:' and the language name",
@"Expected a space after the language name",
@"Expected a space between 'esc:' and the delimiter specification",
@"Expected open delimiter",
@"Expected closing delimiter",
@"Expected matching closing angle bracket '>'",
@"Expected matching closing brace '}'",
@"Expected matching closing bracket ']'",
@"Expected matching closing paren ')'",
@"Expected opening and closing delimiter lengths to match",
@"Expected a space after delimiter specification",
@"Expected 'tag:' or 'file:' following delimiter specification",
@"Expected a space after 'file:'",
@"Expected a space after 'tag:'",
@"Expected a newline after the header",
@"Expected the dividing line to be indented by 4 spaces",
@"Expected a dividing line of '-' of the same length as the header",
@"Expected the division line to be of the same length as the header",
@"Expected at least one blank line after the division line",
@"Expected there to be only one space but more were given",
@"Missing language specification",
@"Missing ':' after 'lang'",
@"Missing language name",
@"Missing 'esc:' delimiter specification",
@"Missing ':' after 'esc'",
@"Missing ':' after 'file'",
@"Missing ':' after 'tag'",
@"Missing '#' after 'tag: '",
@"Missing file name",
@"Missing tag name",
@"Invalid delimiter, expected one of '<', '{', '[', '('",
@"Invalid delimiter, expected one of '>', '}', ']', ')'",
@"Invalid option given, expected 'tag:' or 'file:'",
@"Invalid file path, parent directory references '../' and '..\\' are not allowed within output paths",
@"Invalid file path, current directory references './' and '.\\' are not allowed within output paths",
};
fn parseHeaderLine(p: *Parser) ParseHeaderError!Header {
var header: Header = undefined;
const header_start = p.it.index;
p.match(.word, "lang") orelse return error.@"Missing language specification";
p.expect(.colon, @src()) orelse return error.@"Missing ':' after 'lang'";
if (p.eat(.space, @src())) |space| {
if (space.len != 1) return error.@"Expected there to be only one space but more were given";
} else {
return error.@"Expected a space between 'lang:' and the language name";
}
header.language = p.eat(.word, @src()) orelse return error.@"Missing language name";
p.expect(.space, @src()) orelse return error.@"Expected a space after the language name";
p.match(.word, "esc") orelse return error.@"Missing 'esc:' delimiter specification";
p.expect(.colon, @src()) orelse return error.@"Missing ':' after 'esc'";
if (p.eat(.space, @src())) |space| {
if (space.len != 1) return error.@"Expected there to be only one space but more were given";
} else {
return error.@"Expected a space between 'esc:' and the delimiter specification";
}
if (p.match(.word, "none") == null) {
const start = p.it.index;
const open = p.next() orelse return error.@"Expected open delimiter";
switch (open.tag) {
.l_angle, .l_brace, .l_bracket, .l_paren => {},
else => return error.@"Invalid delimiter, expected one of '<', '{', '[', '('",
}
const closed = p.next() orelse return error.@"Expected closing delimiter";
switch (closed.tag) {
.r_angle, .r_brace, .r_bracket, .r_paren => {},
else => return error.@"Invalid delimiter, expected one of '>', '}', ']', ')'",
}
if (open.tag == .l_angle and closed.tag != .r_angle) {
return error.@"Expected matching closing angle bracket '>'";
} else if (open.tag == .l_brace and closed.tag != .r_brace) {
return error.@"Expected matching closing brace '}'";
} else if (open.tag == .l_bracket and closed.tag != .r_bracket) {
return error.@"Expected matching closing bracket ']'";
} else if (open.tag == .l_paren and closed.tag != .r_paren) {
return error.@"Expected matching closing paren ')'";
}
if (open.len() != closed.len()) {
return error.@"Expected opening and closing delimiter lengths to match";
}
header.delimiter = p.slice(start, p.it.index);
} else {
header.delimiter = null;
}
if (p.eat(.space, @src())) |space| {
if (space.len != 1) return error.@"Expected there to be only one space but more were given";
} else {
return error.@"Expected a space after delimiter specification";
}
var start: usize = undefined;
const tag = p.eat(.word, @src()) orelse {
return error.@"Expected 'tag:' or 'file:' following delimiter specification";
};
if (mem.eql(u8, tag, "file")) {
p.expect(.colon, @src()) orelse return error.@"Missing ':' after 'file'";
if (p.eat(.space, @src())) |space| {
if (space.len != 1) return error.@"Expected there to be only one space but more were given";
} else return error.@"Expected a space after 'file:'";
header.type = .file;
start = p.it.index;
} else if (mem.eql(u8, tag, "tag")) {
p.expect(.colon, @src()) orelse return error.@"Missing ':' after 'tag'";
if (p.eat(.space, @src())) |space| {
if (space.len != 1) return error.@"Expected there to be only one space but more were given";
} else return error.@"Expected a space after 'tag:'";
p.expect(.hash, @src()) orelse return error.@"Missing '#' after 'tag: '";
header.type = .tag;
start = p.it.index;
} else {
return error.@"Invalid option given, expected 'tag:' or 'file:'";
}
const nl = p.scan(.nl) orelse {
return error.@"Expected a newline after the header";
};
header.resource = .{
.start = @intCast(u32, start),
.len = @intCast(u16, nl.start - start),
};
const resource = header.resource.slice(p.it.bytes);
if (header.type == .file) for (&[_][]const u8{ "../", "..\\" }) |invalid| {
if (mem.indexOf(u8, resource, invalid)) |index| {
if (index == 0 or resource[index - 1] != '.') {
return error.@"Invalid file path, parent directory references '../' and '..\\' are not allowed within output paths";
}
}
};
if (header.type == .file) for (&[_][]const u8{ "./", ".\\" }) |invalid| {
if (mem.indexOf(u8, resource, invalid)) |index| {
if (index == 0 or resource[index - 1] != '.') {
return error.@"Invalid file path, current directory references './' and '.\\' are not allowed within output paths";
}
}
};
if (header.resource.len == 0) {
switch (header.type) {
.file => return error.@"Missing file name",
.tag => return error.@"Missing tag name",
}
}
const len = (p.it.index - 1) - header_start;
if ((p.eat(.space, @src()) orelse "").len != 4) {
return error.@"Expected the dividing line to be indented by 4 spaces";
}
const line = p.eat(.line, @src()) orelse {
return error.@"Expected a dividing line of '-' of the same length as the header";
};
if (line.len != len) {
log.debug("header {d} line {d}", .{ len, line.len });
return error.@"Expected the division line to be of the same length as the header";
}
if ((p.eat(.nl, @src()) orelse "").len < 2) {
return error.@"Expected at least one blank line after the division line";
}
return header;
}
fn parseBody(p: *Parser, gpa: Allocator, header: Header) !void {
log.debug("begin parsing body", .{});
defer log.debug("end parsing body", .{});
const entry_point = @intCast(u32, p.program.len);
const location = p.it.locationFrom(p.location);
p.location = location; // avoid RLS
var nl: usize = 0;
loop: while (p.eat(.space, @src())) |space| {
if (space.len < 4) break;
nl = 0;
var sol = p.it.index - (space.len - 4);
while (true) {
const token = p.it.next();
switch (token.tag) {
.eof => {
try p.emitWrite(gpa, .{
.start = @intCast(u32, sol),
.len = @intCast(u16, token.start - sol),
.nl = 0,
});
break :loop;
},
.nl => {
nl = token.len();
try p.emitWrite(gpa, .{
.start = @intCast(u32, sol),
.len = @intCast(u16, token.start - sol),
.nl = @intCast(u16, nl),
});
break;
},
.l_angle,
.l_brace,
.l_bracket,
.l_paren,
=> if (header.delimiter) |delim| {
if (delim[0] != @enumToInt(token.tag)) {
log.debug("dilimiter doesn't match, skipping", .{});
continue;
}
if (delim.len != token.len() * 2) {
log.debug("dilimiter length doesn't match, skipping", .{});
continue;
}
if (token.start - sol > 0) {
try p.emitWrite(gpa, .{
.start = @intCast(u32, sol),
.len = @intCast(u16, token.start - sol),
.nl = 0,
});
}
try p.parseDelimiter(gpa, delim, token.start - sol);
sol = p.it.index;
},
else => {},
}
}
}
const len = p.program.len;
if (len != 0) {
const item = &p.program.items(.data)[len - 1].write;
item.nl = 0;
if (item.len == 0) p.program.len -= 1;
}
if (nl < 2 and p.it.index < p.it.bytes.len) {
return error.@"Expected a blank line after the end of the code block";
}
switch (header.type) {
.tag => {
const adj = try p.adjacent.getOrPut(gpa, header.resource.slice(p.it.bytes));
if (adj.found_existing) {
try p.writeJmp(adj.value_ptr.exit, .{
.address = entry_point,
.module = 0,
});
} else {
adj.value_ptr.entry = entry_point;
adj.value_ptr.location = location;
}
adj.value_ptr.exit = @intCast(u32, p.program.len);
},
.file => {
const file = try p.files.getOrPut(gpa, header.resource.slice(p.it.bytes));
if (file.found_existing) return error.@"Multiple file outputs with the same name";
file.value_ptr.* = .{
.entry = entry_point,
.location = location,
};
},
}
try p.emitRet(gpa, .{
.start = header.resource.start,
.len = header.resource.len,
});
}
fn parseDelimiter(
p: *Parser,
gpa: Allocator,
delim: []const u8,
indent: usize,
) !void {
log.debug("parsing call", .{});
var pipe = false;
var colon = false;
var reached_end = false;
const tag = blk: {
const start = p.it.index;
while (p.next()) |sub| switch (sub.tag) {
.nl => return error.@"Unexpected newline",
.pipe => {
pipe = true;
break :blk p.it.bytes[start..sub.start];
},
.colon => {
colon = true;
break :blk p.it.bytes[start..sub.start];
},
.r_angle,
.r_brace,
.r_bracket,
.r_paren,
=> if (@enumToInt(sub.tag) == delim[delim.len - 1]) {
if (delim.len != sub.len() * 2) {
return error.@"Expected a closing delimiter of equal length";
}
reached_end = true;
break :blk p.it.bytes[start..sub.start];
},
else => {},
};
return error.@"Unexpected end of file";
};
if (colon) {
const ty = p.eat(.word, @src()) orelse return error.@"Missing 'from' following ':'";
if (!mem.eql(u8, ty, "from")) return error.@"Unknown type operation";
p.expect(.l_paren, @src()) orelse return error.@"Expected '(' following 'from'";
p.expect(.word, @src()) orelse return error.@"Expected type name";
p.expect(.r_paren, @src()) orelse return error.@"Expected ')' following type name";
}
if (pipe or p.eat(.pipe, @src()) != null) {
const index = @intCast(u32, p.it.index);
const shell = p.eat(.word, @src()) orelse {
return error.@"Missing command following '|'";
};
if (shell.len > 255) return error.@"Shell command name too long";
try p.emitShell(gpa, .{
.command = index,
.module = 0xffff,
.len = @intCast(u8, shell.len),
.pad = 0,
});
}
try p.emitCall(gpa, tag, .{
.address = undefined,
.module = undefined,
.indent = @intCast(u16, indent),
});
if (!reached_end) {
const last = p.next() orelse return error.@"Expected closing delimiter";
if (last.len() * 2 != delim.len) {
return error.@"Expected closing delimiter length to match";
}
if (@enumToInt(last.tag) != delim[delim.len - 1]) {
return error.@"Invalid closing delimiter";
}
}
}
test "parse body" {
const text =
\\ <<a b c:from(t)|f>>
\\ [[a b c | : a}}
\\ <<b|k>>
\\ <<b:from(k)>>
\\ <<<|:>>
\\ <|:>
\\
\\text
;
var p: Parser = .{ .it = .{ .bytes = text } };
defer p.deinit(testing.allocator);
try p.parseBody(testing.allocator, .{
.language = "",
.delimiter = "<<>>",
.resource = .{ .start = 0, .len = 0 },
.type = .tag,
});
}
test "compile single tag" {
const text =
\\ <<a b c>>
\\ <<. . .:from(zig)>>
\\ <<1 2 3|com>>
\\
\\end
;
var p: Parser = .{ .it = .{ .bytes = text } };
defer p.deinit(testing.allocator);
try p.parseBody(testing.allocator, .{
.language = "",
.delimiter = "<<>>",
.resource = .{ .start = 0, .len = 0 },
.type = .tag,
});
try testing.expect(p.symbols.contains("a b c"));
try testing.expect(p.symbols.contains("1 2 3"));
try testing.expect(p.symbols.contains(". . ."));
}
pub fn parse(gpa: Allocator, name: []const u8, text: []const u8) !Linker.Object {
var p: Parser = .{ .it = .{ .bytes = text } };
errdefer p.deinit(gpa);
while (try p.step(gpa)) {}
return Linker.Object{
.name = name,
.text = text,
.program = p.program,
.symbols = p.symbols,
.adjacent = p.adjacent,
.files = p.files,
};
}
pub fn object(p: *Parser, name: []const u8) Linker.Object {
return Linker.Object{
.name = name,
.text = p.it.bytes,
.program = p.program,
.symbols = p.symbols,
.adjacent = p.adjacent,
.files = p.files,
};
}
pub fn step(p: *Parser, gpa: Allocator) !bool {
while (p.next()) |token| if (token.tag == .nl and token.len() >= 2) {
const space = p.eat(.space, @src()) orelse continue;
if (space.len != 4) continue;
if (p.parseHeaderLine()) |header| {
try p.parseBody(gpa, header);
} else |e| switch (e) {
error.@"Missing language specification" => {
log.debug("begin indented block", .{});
defer log.debug("end indented block", .{});
while (p.scan(.nl)) |nl| if (nl.len() >= 2) {
const tmp = p.next() orelse return false;
if (tmp.tag != .space) return true;
if (tmp.len() < 4) return true;
};
},
else => |err| return err,
}
};
return false;
}
test "parse header line" {
const complete_header = "lang: zig esc: {{}} tag: #hash\n ------------------------------\n\n";
const common: Header = .{
.language = "zig",
.delimiter = "{{}}",
.resource = .{
.start = @intCast(u32, mem.indexOf(u8, complete_header, "hash").?),
.len = 4,
},
.type = .tag,
};
try testing.expectError(
error.@"Expected a space between 'lang:' and the language name",
testParseHeader("lang:zig", common),
);
try testing.expectError(
error.@"Missing 'esc:' delimiter specification",
testParseHeader("lang: zig ", common),
);
try testing.expectError(
error.@"Missing ':' after 'esc'",
testParseHeader("lang: zig esc", common),
);
try testing.expectError(
error.@"Expected a space between 'esc:' and the delimiter specification",
testParseHeader("lang: zig esc:", common),
);
try testing.expectError(
error.@"Expected closing delimiter",
testParseHeader("lang: zig esc: {", common),
);
try testing.expectError(
error.@"Expected matching closing angle bracket '>'",
testParseHeader("lang: zig esc: <}", common),
);
try testing.expectError(
error.@"Expected matching closing brace '}'",
testParseHeader("lang: zig esc: {>", common),
);
try testing.expectError(
error.@"Expected matching closing bracket ']'",
testParseHeader("lang: zig esc: [>", common),
);
try testing.expectError(
error.@"Expected matching closing paren ')'",
testParseHeader("lang: zig esc: (>", common),
);
try testing.expectError(
error.@"Invalid delimiter, expected one of '<', '{', '[', '('",
testParseHeader("lang: zig esc: foo", common),
);
try testing.expectError(
error.@"Invalid delimiter, expected one of '>', '}', ']', ')'",
testParseHeader("lang: zig esc: <oo", common),
);
try testing.expectError(
error.@"Expected opening and closing delimiter lengths to match",
testParseHeader("lang: zig esc: {}}", common),
);
try testing.expectError(
error.@"Expected a space after delimiter specification",
testParseHeader("lang: zig esc: {{}}", common),
);
try testing.expectError(
error.@"Expected 'tag:' or 'file:' following delimiter specification",
testParseHeader("lang: zig esc: {{}} ", common),
);
try testing.expectError(
error.@"Invalid option given, expected 'tag:' or 'file:'",
testParseHeader("lang: zig esc: {{}} none", common),
);
try testing.expectError(
error.@"Missing ':' after 'file'",
testParseHeader("lang: zig esc: {{}} file", common),
);
try testing.expectError(
error.@"Expected a space after 'file:'",
testParseHeader("lang: zig esc: {{}} file:", common),
);
try testing.expectError(
error.@"Missing file name",
testParseHeader("lang: zig esc: {{}} file: \n", common),
);
try testing.expectError(
error.@"Invalid file path, parent directory references '../' and '..\\' are not allowed within output paths",
testParseHeader("lang: zig esc: {{}} file: ../../../../etc/foo\n", common),
);
try testing.expectError(
error.@"Invalid file path, current directory references './' and '.\\' are not allowed within output paths",
testParseHeader("lang: zig esc: {{}} file: ./foo\n", common),
);
try testing.expectError(
error.@"Expected the dividing line to be indented by 4 spaces",
testParseHeader("lang: zig esc: {{}} file: .../foo\n", common),
);
try testing.expectError(
error.@"Missing ':' after 'tag'",
testParseHeader("lang: zig esc: {{}} tag", common),
);
try testing.expectError(
error.@"Expected a space after 'tag:'",
testParseHeader("lang: zig esc: {{}} tag:", common),
);
try testing.expectError(
error.@"Missing '#' after 'tag: '",
testParseHeader("lang: zig esc: {{}} tag: ", common),
);
try testing.expectError(
error.@"Expected a newline after the header",
testParseHeader("lang: zig esc: {{}} tag: #", common),
);
try testing.expectError(
error.@"Missing tag name",
testParseHeader("lang: zig esc: {{}} tag: #\n", common),
);
try testing.expectError(
error.@"Expected the dividing line to be indented by 4 spaces",
testParseHeader("lang: zig esc: {{}} tag: #hash\n", common),
);
try testing.expectError(
error.@"Expected a dividing line of '-' of the same length as the header",
testParseHeader("lang: zig esc: {{}} tag: #hash\n ", common),
);
try testing.expectError(
error.@"Expected the division line to be of the same length as the header",
testParseHeader("lang: zig esc: {{}} tag: #hash\n ----------------", common),
);
try testing.expectError(
error.@"Expected at least one blank line after the division line",
testParseHeader("lang: zig esc: {{}} tag: #hash\n ------------------------------", common),
);
try testing.expectError(
error.@"Expected at least one blank line after the division line",
testParseHeader("lang: zig esc: {{}} tag: #hash\n ------------------------------\n", common),
);
try testParseHeader(complete_header, common);
}
fn testParseHeader(text: []const u8, expected: Header) !void {
var p: Parser = .{ .it = .{ .bytes = text } };
const header = try p.parseHeaderLine();
testing.expectEqualStrings(expected.language, header.language) catch return error.@"Language is not the same";
if (expected.delimiter != null and header.delimiter != null) {
testing.expectEqualStrings(expected.language, header.language) catch return error.@"Delimiter is not the same";
} else if (expected.delimiter == null and header.delimiter != null) {
return error.@"Expected delimiter to be null";
} else if (expected.delimiter != null and header.delimiter == null) {
return error.@"Expected delimiter to not be null";
}
testing.expectEqual(expected.resource, header.resource) catch return error.@"Resource is not the same";
testing.expectEqual(expected.type, header.type) catch return error.@"Type is not the same";
}
const TestCompileResult = struct {
program: []const Instruction.Opcode,
symbols: []const []const u8,
exports: []const []const u8,
};
fn testCompile(
text: []const u8,
result: TestCompileResult,
) !void {
var obj = try Parser.parse(testing.allocator, "", text);
defer obj.deinit(testing.allocator);
errdefer for (obj.program.items(.opcode)) |op| {
log.debug("{s}", .{@tagName(op)});
};
try testing.expectEqualSlices(
Instruction.Opcode,
result.program,
obj.program.items(.opcode),
);
for (result.symbols) |sym| if (!obj.symbols.contains(sym)) {
std.log.err("Missing symbol '{s}'", .{sym});
};
}
test "compile block" {
try testCompile(
\\begin
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ <<example>>
\\
\\end
, .{
.program = &.{ .call, .ret },
.symbols = &.{"example"},
.exports = &.{"here"},
});
}
test "compile block with jump threadding" {
try testCompile(
\\begin
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ <<example>>
\\
\\then
\\
\\ lang: zig esc: none tag: #here
\\ ------------------------------
\\
\\ more
\\
\\end
, .{
.program = &.{ .call, .jmp, .write, .ret },
.symbols = &.{"example"},
.exports = &.{"here"},
});
}
test "compile block multiple call" {
try testCompile(
\\begin
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ <<one>>
\\ <<two>>
\\ <<three>>
\\
\\end
, .{
.program = &.{ .call, .write, .call, .write, .call, .ret },
.symbols = &.{ "one", "two", "three" },
.exports = &.{"here"},
});
}
test "compile block inline" {
try testCompile(
\\begin
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ <<one>><<two>>
\\
\\end
, .{
.program = &.{ .call, .call, .ret },
.symbols = &.{ "one", "two" },
.exports = &.{"here"},
});
}
test "compile block inline indent" {
try testCompile(
\\begin
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ one<<two>>
\\
\\end
, .{
.program = &.{ .write, .call, .ret },
.symbols = &.{"two"},
.exports = &.{"here"},
});
}
test "compile indented" {
try testCompile(
\\begin
\\
\\ normal code block
\\
\\end
\\
\\ lang: zig esc: <<>> tag: #here
\\ ------------------------------
\\
\\ <<one>><<two>>
\\
\\end
, .{
.program = &.{ .call, .call, .ret },
.symbols = &.{ "one", "two" },
.exports = &.{"here"},
});
} | lib/Parser.zig |
const std = @import("std");
const math = std.math;
const trait = std.meta.trait;
const assert = std.debug.assert;
const vec = @import("vec.zig");
const Vec2 = vec.Vec2;
const Vec3 = vec.Vec3;
const Vec4 = vec.Vec4;
fn MatMixin(comptime Self: type, comptime VecType: type, comptime T: type) type {
return struct {
/// Clones the Matrix
pub fn clone(self: *Self) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field| {
@field(result, field.name) = @field(self.*, field.name);
}
return result;
}
/// Gets the vector at specified index
pub fn getIndex(self: *Self, comptime index: usize) VecType {
assert(index < 4);
return @field(self.*, @typeInfo(Self).Struct.fields[index].name);
}
/// Gets the vector at specified index as a ptr
pub fn getIndexPtr(self: *Self, comptime index: usize) *VecType {
assert(index < 4);
return &@field(self.*, @typeInfo(Self).Struct.fields[index].name);
}
/// Sets the vector at specified index
pub fn setIndex(self: *Self, comptime index: usize, value: VecType) void {
assert(index < 4);
@field(self.*, @typeInfo(Self).Struct.fields[index].name) = value;
}
/// Transposes between Col Major and Row Major
pub fn transpose(self: Self) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field, i| {
inline for (@typeInfo(VecType).Struct.fields) |vec_field, j| {
result.getIndexPtr(j).setIndex(i, @field(@field(self, field.name), vec_field.name));
}
}
return result;
}
/// Add two matrices
pub fn add(self: Self, other: Self) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field| {
@field(result, field.name) = @field(self, field.name).add(@field(other, field.name));
}
return result;
}
/// Subtract two matrices
pub fn sub(self: Self, other: Self) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field| {
@field(result, field.name) = @field(self, field.name).sub(@field(other, field.name));
}
return result;
}
/// Multiply two matrices
pub fn mul(self: Self, other: Self) Self {
var result = Self.Zero;
var selfTransposed = self.transpose();
inline for (@typeInfo(Self).Struct.fields) |self_field| {
inline for (@typeInfo(Self).Struct.fields) |other_field| {
@field(@field(result, self_field.name), other_field.name) = @field(selfTransposed, self_field.name).dot(@field(other, other_field.name));
}
}
return result;
}
/// Multiply a matrix by a scalar
pub fn mulScalar(self: Self, other: T) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field| {
@field(result, field.name) = @field(self, field.name).mulScalar(other);
}
return result;
}
/// Divide a matrix by a scalar
pub fn divScalar(self: Self, other: T) Self {
var result = Self.Zero;
inline for (@typeInfo(Self).Struct.fields) |field| {
@field(result, field.name) = @field(self, field.name).divScalar(other);
}
return result;
}
};
}
/// 2x2 column major matrix
///
/// xy
/// x00
/// y00
pub fn Mat22(comptime T: type) type {
if (!comptime trait.isNumber(T)) {
@compileError("Mat22 type must be a number");
}
if (comptime trait.isUnsignedInt(T)) {
@compileError("Mat22 type cannot be unsigned");
}
return extern struct {
const Self = @This();
x: Vec2(T),
y: Vec2(T),
pub const Identity = Self{
.x = Vec2(T).new(1.0, 0.0),
.y = Vec2(T).new(0.0, 1.0),
};
pub const One = Self{
.x = Vec2(T).One,
.y = Vec2(T).One,
};
pub const Zero = Self{
.x = Vec2(T).Zero,
.y = Vec2(T).Zero,
};
usingnamespace MatMixin(Self, Vec2(T), T);
pub fn new(x: Vec2(T), y: Vec2(T)) Self {
return Self{
.x = x,
.y = y,
};
}
};
}
/// 3x3 column major matrix
///
/// xyz
/// x000
/// y000
/// z000
pub fn Mat33(comptime T: type) type {
if (!comptime trait.isNumber(T)) {
@compileError("Mat33 type must be a number");
}
if (comptime trait.isUnsignedInt(T)) {
@compileError("Mat33 type cannot be unsigned");
}
return extern struct {
const Self = @This();
x: Vec3(T),
y: Vec3(T),
z: Vec3(T),
pub const Identity = Self{
.x = Vec3(T).new(1.0, 0.0, 0.0),
.y = Vec3(T).new(0.0, 1.0, 0.0),
.z = Vec3(T).new(0.0, 0.0, 1.0),
};
pub const One = Self{
.x = Vec3(T).One,
.y = Vec3(T).One,
.x = Vec3(T).One,
};
pub const Zero = Self{
.x = Vec3(T).Zero,
.y = Vec3(T).Zero,
.z = Vec3(T).Zero,
};
usingnamespace MatMixin(Self, Vec3(T), T);
pub fn new(x: Vec3(T), y: Vec3(T), z: Vec3(T)) Self {
return Self{
.x = x,
.y = y,
.z = z,
};
}
};
}
/// 4x4 column major matrix
///
/// xyzw
/// x0000
/// y0000
/// z0000
/// w0000
pub fn Mat44(comptime T: type) type {
if (!comptime trait.isNumber(T)) {
@compileError("Mat44 type must be a number");
}
if (comptime trait.isUnsignedInt(T)) {
@compileError("Mat44 type cannot be unsigned");
}
return extern struct {
const Self = @This();
x: Vec4(T),
y: Vec4(T),
z: Vec4(T),
w: Vec4(T),
pub const Identity = Self{
.x = Vec4(T).new(1.0, 0.0, 0.0, 0.0),
.y = Vec4(T).new(0.0, 1.0, 0.0, 0.0),
.z = Vec4(T).new(0.0, 0.0, 1.0, 0.0),
.w = Vec4(T).new(0.0, 0.0, 0.0, 1.0),
};
pub const One = Self{
.x = Vec4(T).One,
.y = Vec4(T).One,
.x = Vec4(T).One,
.w = Vec4(T).One,
};
pub const Zero = Self{
.x = Vec4(T).Zero,
.y = Vec4(T).Zero,
.z = Vec4(T).Zero,
.w = Vec4(T).Zero,
};
usingnamespace MatMixin(Self, Vec4(T), T);
pub fn new(x: Vec4(T), y: Vec4(T), z: Vec4(T), w: Vec4(T)) Self {
return Self{
.x = x,
.y = y,
.z = z,
.w = w,
};
}
};
} | math/src/mat.zig |
pub const GuPixelMode = extern enum(c_int) {
Psm5650 = 0,
Psm5551 = 1,
Psm4444 = 2,
Psm8888 = 3,
PsmT4 = 4,
PsmT8 = 5,
PsmT16 = 6,
PsmT32 = 7,
PsmDXT1 = 8,
PsmDXT3 = 9,
PsmDXT5 = 10,
};
pub const GuPrimitive = extern enum(c_int) {
Points = 0,
Lines = 1,
LineStrip = 2,
Triangles = 3,
TriangleStrip = 4,
TriangleFan = 5,
Sprites = 6,
};
pub const PatchPrimitive = extern enum(c_int) {
Points = 0,
LineStrip = 2,
TriangleStrip = 4,
};
pub const GuState = extern enum(c_int) {
AlphaTest = 0,
DepthTest = 1,
ScissorTest = 2,
StencilTest = 3,
Blend = 4,
CullFace = 5,
Dither = 6,
Fog = 7,
ClipPlanes = 8,
Texture2D = 9,
Lighting = 10,
Light0 = 11,
Light1 = 12,
Light2 = 13,
Light3 = 14,
LineSmooth = 15,
PatchCullFace = 16,
ColorTest = 17,
ColorLogicOp = 18,
FaceNormalReverse = 19,
PatchFace = 20,
Fragment2X = 21,
};
pub const MatrixMode = extern enum(c_int) {
Projection = 0,
View = 1,
Model = 2,
Texture = 3,
};
pub const SplineMode = extern enum(c_int) {
FillFill = 0,
OpenFill = 1,
FillOpen = 2,
OpenOpen = 3,
};
pub const ShadeModel = extern enum(c_int) {
Flat = 0,
Smooth = 1,
};
pub const GuLogicalOperation = extern enum(c_int) {
Clear = 0,
And = 1,
AndReverse = 2,
Copy = 3,
AndInverted = 4,
Noop = 5,
Xor = 6,
Or = 7,
Nor = 8,
Equiv = 9,
Inverted = 10,
OrReverse = 11,
CopyInverted = 12,
OrInverted = 13,
Nand = 14,
Set = 15,
};
pub const TextureFilter = extern enum(c_int) {
Nearest = 0,
Linear = 1,
NearestMipmapNearest = 4,
LinearMipmapNearest = 5,
NearestMipmapLinear = 6,
LinearMipmapLinear = 7,
};
pub const TextureMapMode = extern enum(c_int) {
Coords = 0,
Matrix = 1,
EnvironmentMap = 2,
};
pub const TextureLevelMode = extern enum(c_int) {
Auto = 0,
Const = 1,
Slope = 2,
};
pub const TextureProjectionMapMode = extern enum(c_int) {
Position = 0,
Uv = 1,
NormalizedNormal = 2,
Normal = 3,
};
pub const GuTexWrapMode = extern enum(c_int) {
Repeat = 0,
Clamp = 1,
};
pub const FrontFaceDirection = extern enum(c_int) {
Clockwise = 0,
CounterClockwise = 1,
};
pub const AlphaFunc = extern enum(c_int) {
Never = 0,
Always,
Equal,
NotEqual,
Less,
LessOrEqual,
Greater,
GreaterOrEqual,
};
pub const StencilFunc = extern enum(c_int) {
Never = 0,
Always,
Equal,
NotEqual,
Less,
LessOrEqual,
Greater,
GreaterOrEqual,
};
pub const ColorFunc = extern enum(c_int) {
Never = 0,
Always,
Equal,
NotEqual,
};
pub const DepthFunc = extern enum(c_int) {
Never = 0,
Always,
Equal,
NotEqual,
Less,
LessOrEqual,
Greater,
GreaterOrEqual,
};
pub const TextureEffect = extern enum(c_int) {
Modulate = 0,
Decal = 1,
Blend = 2,
Replace = 3,
Add = 4,
};
pub const TextureColorComponent = extern enum(c_int) {
Rgb = 0,
Rgba = 1,
};
pub const MipmapLevel = extern enum(c_int) {
None = 0,
Level1,
Level2,
Level3,
Level4,
Level5,
Level6,
Level7,
};
pub const BlendOp = extern enum(c_int) {
Add = 0,
Subtract = 1,
ReverseSubtract = 2,
Min = 3,
Max = 4,
Abs = 5,
};
pub const BlendArg = extern enum(c_int) {
SrcColor = 0,
OneMinusSrcColor = 1,
SrcAlpha = 2,
OneMinusSrcAlpha = 3,
DstColor = 0,
OneMinusDstColor = 1,
DstAlpha = 4,
OneMinusDstAlpha = 5,
Fix = 10,
};
pub const StencilOperation = extern enum(c_int) {
Keep = 0,
Zero = 1,
Replace = 2,
Invert = 3,
Incr = 4,
Decr = 5,
};
pub const LightMode = extern enum(c_int) {
SingleColor = 0,
SeparateSpecularColor = 1,
};
pub const GuLightType = extern enum(c_int) {
Directional = 0,
Pointlight = 1,
Spotlight = 2,
};
pub const GuContextType = extern enum(c_int) {
Direct = 0,
Call = 1,
Send = 2,
};
pub const GuQueueMode = extern enum(c_int) {
Tail = 0,
Head = 1,
};
pub const GuSyncMode = extern enum(c_int) {
Finish = 0,
Signal = 1,
Done = 2,
List = 3,
Send = 4,
};
pub const GuSyncBehavior = extern enum(c_int) {
Wait = 0,
NoWait = 1,
};
pub const GuCallbackId = extern enum(c_int) {
Signal = 1,
Finish = 4,
};
pub const GuSignalBehavior = extern enum(c_int) {
Suspend = 1,
Continue = 2,
};
pub const ClearBitFlags = extern enum(c_int) {
ColorBuffer = 1,
StencilBuffer = 2,
DepthBuffer = 4,
};
pub const GuLightBitFlags = extern enum(c_int) {
Ambient = 1,
Diffuse = 2,
AmbientDiffuse = 3,
Specular = 4,
DiffuseSpecular = 6,
Unknown = 8,
};
pub const VertexTypeFlags = extern enum(c_int) {
Texture8Bit = 1,
Texture16Bit = 2,
Texture32Bitf = 3,
Color5650 = 4 << 2,
Color5551 = 5 << 2,
Color4444 = 6 << 2,
Color8888 = 7 << 2,
Normal8Bit = 1 << 5,
Normal16Bit = 2 << 5,
Normal32Bitf = 3 << 5,
Vertex8Bit = 1 << 7,
Vertex16Bit = 2 << 7,
Vertex32Bitf = 3 << 7,
Weight8Bit = 1 << 9,
Weight16Bit = 2 << 9,
Weight32Bitf = 3 << 9,
Index8Bit = 1 << 11,
Index16Bit = 2 << 11,
Transform2D = 1 << 23,
Transform3D = 0,
};
pub const GuSwapBuffersCallback = ?fn ([*c]?*c_void, [*c]?*c_void) callconv(.C) void; | src/psp/sdk/pspgutypes.zig |
pub const JS_SOURCE_CONTEXT_NONE = @as(u64, 18446744073709551615);
//--------------------------------------------------------------------------------
// Section: Types (11)
//--------------------------------------------------------------------------------
pub const JsRuntimeVersion = enum(i32) {
@"10" = 0,
@"11" = 1,
Edge = -1,
};
// TODO: enum 'JsRuntimeVersion' has known issues with its value aliases
pub const JsErrorCode = enum(u32) {
NoError = 0,
ErrorCategoryUsage = 65536,
ErrorInvalidArgument = 65537,
ErrorNullArgument = 65538,
ErrorNoCurrentContext = 65539,
ErrorInExceptionState = 65540,
ErrorNotImplemented = 65541,
ErrorWrongThread = 65542,
ErrorRuntimeInUse = 65543,
ErrorBadSerializedScript = 65544,
ErrorInDisabledState = 65545,
ErrorCannotDisableExecution = 65546,
ErrorHeapEnumInProgress = 65547,
ErrorArgumentNotObject = 65548,
ErrorInProfileCallback = 65549,
ErrorInThreadServiceCallback = 65550,
ErrorCannotSerializeDebugScript = 65551,
ErrorAlreadyDebuggingContext = 65552,
ErrorAlreadyProfilingContext = 65553,
ErrorIdleNotEnabled = 65554,
ErrorCategoryEngine = 131072,
ErrorOutOfMemory = 131073,
ErrorCategoryScript = 196608,
ErrorScriptException = 196609,
ErrorScriptCompile = 196610,
ErrorScriptTerminated = 196611,
ErrorScriptEvalDisabled = 196612,
ErrorCategoryFatal = 262144,
ErrorFatal = 262145,
};
pub const JsNoError = JsErrorCode.NoError;
pub const JsErrorCategoryUsage = JsErrorCode.ErrorCategoryUsage;
pub const JsErrorInvalidArgument = JsErrorCode.ErrorInvalidArgument;
pub const JsErrorNullArgument = JsErrorCode.ErrorNullArgument;
pub const JsErrorNoCurrentContext = JsErrorCode.ErrorNoCurrentContext;
pub const JsErrorInExceptionState = JsErrorCode.ErrorInExceptionState;
pub const JsErrorNotImplemented = JsErrorCode.ErrorNotImplemented;
pub const JsErrorWrongThread = JsErrorCode.ErrorWrongThread;
pub const JsErrorRuntimeInUse = JsErrorCode.ErrorRuntimeInUse;
pub const JsErrorBadSerializedScript = JsErrorCode.ErrorBadSerializedScript;
pub const JsErrorInDisabledState = JsErrorCode.ErrorInDisabledState;
pub const JsErrorCannotDisableExecution = JsErrorCode.ErrorCannotDisableExecution;
pub const JsErrorHeapEnumInProgress = JsErrorCode.ErrorHeapEnumInProgress;
pub const JsErrorArgumentNotObject = JsErrorCode.ErrorArgumentNotObject;
pub const JsErrorInProfileCallback = JsErrorCode.ErrorInProfileCallback;
pub const JsErrorInThreadServiceCallback = JsErrorCode.ErrorInThreadServiceCallback;
pub const JsErrorCannotSerializeDebugScript = JsErrorCode.ErrorCannotSerializeDebugScript;
pub const JsErrorAlreadyDebuggingContext = JsErrorCode.ErrorAlreadyDebuggingContext;
pub const JsErrorAlreadyProfilingContext = JsErrorCode.ErrorAlreadyProfilingContext;
pub const JsErrorIdleNotEnabled = JsErrorCode.ErrorIdleNotEnabled;
pub const JsErrorCategoryEngine = JsErrorCode.ErrorCategoryEngine;
pub const JsErrorOutOfMemory = JsErrorCode.ErrorOutOfMemory;
pub const JsErrorCategoryScript = JsErrorCode.ErrorCategoryScript;
pub const JsErrorScriptException = JsErrorCode.ErrorScriptException;
pub const JsErrorScriptCompile = JsErrorCode.ErrorScriptCompile;
pub const JsErrorScriptTerminated = JsErrorCode.ErrorScriptTerminated;
pub const JsErrorScriptEvalDisabled = JsErrorCode.ErrorScriptEvalDisabled;
pub const JsErrorCategoryFatal = JsErrorCode.ErrorCategoryFatal;
pub const JsErrorFatal = JsErrorCode.ErrorFatal;
pub const JsRuntimeAttributes = enum(i32) {
None = 0,
DisableBackgroundWork = 1,
AllowScriptInterrupt = 2,
EnableIdleProcessing = 4,
DisableNativeCodeGeneration = 8,
DisableEval = 16,
};
pub const JsRuntimeAttributeNone = JsRuntimeAttributes.None;
pub const JsRuntimeAttributeDisableBackgroundWork = JsRuntimeAttributes.DisableBackgroundWork;
pub const JsRuntimeAttributeAllowScriptInterrupt = JsRuntimeAttributes.AllowScriptInterrupt;
pub const JsRuntimeAttributeEnableIdleProcessing = JsRuntimeAttributes.EnableIdleProcessing;
pub const JsRuntimeAttributeDisableNativeCodeGeneration = JsRuntimeAttributes.DisableNativeCodeGeneration;
pub const JsRuntimeAttributeDisableEval = JsRuntimeAttributes.DisableEval;
pub const JsMemoryEventType = enum(i32) {
Allocate = 0,
Free = 1,
Failure = 2,
};
pub const JsMemoryAllocate = JsMemoryEventType.Allocate;
pub const JsMemoryFree = JsMemoryEventType.Free;
pub const JsMemoryFailure = JsMemoryEventType.Failure;
pub const JsMemoryAllocationCallback = fn(
callbackState: ?*c_void,
allocationEvent: JsMemoryEventType,
allocationSize: usize,
) callconv(@import("std").os.windows.WINAPI) bool;
pub const JsBeforeCollectCallback = fn(
callbackState: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const JsBackgroundWorkItemCallback = fn(
callbackState: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const JsThreadServiceCallback = fn(
callback: ?JsBackgroundWorkItemCallback,
callbackState: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) bool;
pub const JsValueType = enum(i32) {
Undefined = 0,
Null = 1,
Number = 2,
String = 3,
Boolean = 4,
Object = 5,
Function = 6,
Error = 7,
Array = 8,
};
pub const JsUndefined = JsValueType.Undefined;
pub const JsNull = JsValueType.Null;
pub const JsNumber = JsValueType.Number;
pub const JsString = JsValueType.String;
pub const JsBoolean = JsValueType.Boolean;
pub const JsObject = JsValueType.Object;
pub const JsFunction = JsValueType.Function;
pub const JsError = JsValueType.Error;
pub const JsArray = JsValueType.Array;
pub const JsFinalizeCallback = fn(
data: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) void;
pub const JsNativeFunction = fn(
callee: ?*c_void,
isConstructCall: bool,
arguments: ?*?*c_void,
argumentCount: u16,
callbackState: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) ?*c_void;
//--------------------------------------------------------------------------------
// Section: Functions (87)
//--------------------------------------------------------------------------------
pub usingnamespace switch (@import("../zig.zig").arch) {
.X64, .Arm64 => struct {
pub extern "chakra" fn JsCreateContext(
runtime: ?*c_void,
debugApplication: ?*IDebugApplication64,
newContext: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
}, else => struct { } };
pub usingnamespace switch (@import("../zig.zig").arch) {
.X64, .Arm64 => struct {
pub extern "chakra" fn JsStartDebugging(
debugApplication: ?*IDebugApplication64,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
}, else => struct { } };
pub extern "chakra" fn JsCreateRuntime(
attributes: JsRuntimeAttributes,
runtimeVersion: JsRuntimeVersion,
threadService: ?JsThreadServiceCallback,
runtime: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCollectGarbage(
runtime: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDisposeRuntime(
runtime: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetRuntimeMemoryUsage(
runtime: ?*c_void,
memoryUsage: ?*usize,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetRuntimeMemoryLimit(
runtime: ?*c_void,
memoryLimit: ?*usize,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetRuntimeMemoryLimit(
runtime: ?*c_void,
memoryLimit: usize,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetRuntimeMemoryAllocationCallback(
runtime: ?*c_void,
callbackState: ?*c_void,
allocationCallback: ?JsMemoryAllocationCallback,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetRuntimeBeforeCollectCallback(
runtime: ?*c_void,
callbackState: ?*c_void,
beforeCollectCallback: ?JsBeforeCollectCallback,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsAddRef(
ref: ?*c_void,
count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsRelease(
ref: ?*c_void,
count: ?*u32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetCurrentContext(
currentContext: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetCurrentContext(
context: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetRuntime(
context: ?*c_void,
runtime: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsIdle(
nextIdleTick: ?*u32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsParseScript(
script: ?[*:0]const u16,
sourceContext: usize,
sourceUrl: ?[*:0]const u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsRunScript(
script: ?[*:0]const u16,
sourceContext: usize,
sourceUrl: ?[*:0]const u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSerializeScript(
script: ?[*:0]const u16,
buffer: ?[*:0]u8,
bufferSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsParseSerializedScript(
script: ?[*:0]const u16,
buffer: ?*u8,
sourceContext: usize,
sourceUrl: ?[*:0]const u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsRunSerializedScript(
script: ?[*:0]const u16,
buffer: ?*u8,
sourceContext: usize,
sourceUrl: ?[*:0]const u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetPropertyIdFromName(
name: ?[*:0]const u16,
propertyId: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetPropertyNameFromId(
propertyId: ?*c_void,
name: ?*const ?*u16,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetUndefinedValue(
undefinedValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetNullValue(
nullValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetTrueValue(
trueValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetFalseValue(
falseValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsBoolToBoolean(
value: u8,
booleanValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsBooleanToBool(
value: ?*c_void,
boolValue: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsConvertValueToBoolean(
value: ?*c_void,
booleanValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetValueType(
value: ?*c_void,
type: ?*JsValueType,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDoubleToNumber(
doubleValue: f64,
value: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsIntToNumber(
intValue: i32,
value: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsNumberToDouble(
value: ?*c_void,
doubleValue: ?*f64,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsConvertValueToNumber(
value: ?*c_void,
numberValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetStringLength(
stringValue: ?*c_void,
length: ?*i32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsPointerToString(
stringValue: [*:0]const u16,
stringLength: usize,
value: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsStringToPointer(
value: ?*c_void,
stringValue: ?*const ?*u16,
stringLength: ?*usize,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsConvertValueToString(
value: ?*c_void,
stringValue: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsVariantToValue(
variant: ?*VARIANT,
value: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsValueToVariant(
object: ?*c_void,
variant: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetGlobalObject(
globalObject: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateObject(
object: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateExternalObject(
data: ?*c_void,
finalizeCallback: ?JsFinalizeCallback,
object: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsConvertValueToObject(
value: ?*c_void,
object: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetPrototype(
object: ?*c_void,
prototypeObject: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetPrototype(
object: ?*c_void,
prototypeObject: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetExtensionAllowed(
object: ?*c_void,
value: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsPreventExtension(
object: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetProperty(
object: ?*c_void,
propertyId: ?*c_void,
value: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetOwnPropertyDescriptor(
object: ?*c_void,
propertyId: ?*c_void,
propertyDescriptor: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetOwnPropertyNames(
object: ?*c_void,
propertyNames: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetProperty(
object: ?*c_void,
propertyId: ?*c_void,
value: ?*c_void,
useStrictRules: u8,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsHasProperty(
object: ?*c_void,
propertyId: ?*c_void,
hasProperty: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDeleteProperty(
object: ?*c_void,
propertyId: ?*c_void,
useStrictRules: u8,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDefineProperty(
object: ?*c_void,
propertyId: ?*c_void,
propertyDescriptor: ?*c_void,
result: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsHasIndexedProperty(
object: ?*c_void,
index: ?*c_void,
result: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetIndexedProperty(
object: ?*c_void,
index: ?*c_void,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetIndexedProperty(
object: ?*c_void,
index: ?*c_void,
value: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDeleteIndexedProperty(
object: ?*c_void,
index: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsEquals(
object1: ?*c_void,
object2: ?*c_void,
result: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsStrictEquals(
object1: ?*c_void,
object2: ?*c_void,
result: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsHasExternalData(
object: ?*c_void,
value: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetExternalData(
object: ?*c_void,
externalData: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetExternalData(
object: ?*c_void,
externalData: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateArray(
length: u32,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCallFunction(
function: ?*c_void,
arguments: [*]?*c_void,
argumentCount: u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsConstructObject(
function: ?*c_void,
arguments: [*]?*c_void,
argumentCount: u16,
result: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateFunction(
nativeFunction: ?JsNativeFunction,
callbackState: ?*c_void,
function: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateRangeError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateReferenceError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateSyntaxError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateTypeError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsCreateURIError(
message: ?*c_void,
@"error": ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsHasException(
hasException: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsGetAndClearException(
exception: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsSetException(
exception: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsDisableRuntimeExecution(
runtime: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsEnableRuntimeExecution(
runtime: ?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsIsRuntimeExecutionDisabled(
runtime: ?*c_void,
isDisabled: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsStartProfiling(
callback: ?*IActiveScriptProfilerCallback,
eventMask: PROFILER_EVENT_MASK,
context: u32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsStopProfiling(
reason: HRESULT,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsEnumerateHeap(
enumerator: ?*?*IActiveScriptProfilerHeapEnum,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub extern "chakra" fn JsIsEnumeratingHeap(
isEnumeratingHeap: ?*bool,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
pub usingnamespace switch (@import("../zig.zig").arch) {
.X86 => struct {
pub extern "chakra" fn JsCreateContext(
runtime: ?*c_void,
debugApplication: ?*IDebugApplication32,
newContext: ?*?*c_void,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
}, else => struct { } };
pub usingnamespace switch (@import("../zig.zig").arch) {
.X86 => struct {
pub extern "chakra" fn JsStartDebugging(
debugApplication: ?*IDebugApplication32,
) callconv(@import("std").os.windows.WINAPI) JsErrorCode;
}, else => struct { } };
//--------------------------------------------------------------------------------
// 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 (8)
//--------------------------------------------------------------------------------
const HRESULT = @import("../foundation.zig").HRESULT;
const IActiveScriptProfilerCallback = @import("../system/diagnostics/debug.zig").IActiveScriptProfilerCallback;
const IActiveScriptProfilerHeapEnum = @import("../system/diagnostics/debug.zig").IActiveScriptProfilerHeapEnum;
const PROFILER_EVENT_MASK = @import("../system/diagnostics/debug.zig").PROFILER_EVENT_MASK;
const PWSTR = @import("../foundation.zig").PWSTR;
const VARIANT = @import("../system/ole_automation.zig").VARIANT;
// 2 arch-specific imports
const IDebugApplication32 = switch(@import("../zig.zig").arch) {
.X86 => @import("../system/diagnostics/debug.zig").IDebugApplication32,
else => usize, // NOTE: this should be a @compileError but can't because of https://github.com/ziglang/zig/issues/9682
};
const IDebugApplication64 = switch(@import("../zig.zig").arch) {
.X64, .Arm64 => @import("../system/diagnostics/debug.zig").IDebugApplication64,
else => usize, // NOTE: this should be a @compileError but can't because of https://github.com/ziglang/zig/issues/9682
};
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "JsMemoryAllocationCallback")) { _ = JsMemoryAllocationCallback; }
if (@hasDecl(@This(), "JsBeforeCollectCallback")) { _ = JsBeforeCollectCallback; }
if (@hasDecl(@This(), "JsBackgroundWorkItemCallback")) { _ = JsBackgroundWorkItemCallback; }
if (@hasDecl(@This(), "JsThreadServiceCallback")) { _ = JsThreadServiceCallback; }
if (@hasDecl(@This(), "JsFinalizeCallback")) { _ = JsFinalizeCallback; }
if (@hasDecl(@This(), "JsNativeFunction")) { _ = JsNativeFunction; }
@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;
}
}
} | deps/zigwin32/win32/system/js.zig |
const std = @import("std");
const ascii = std.ascii;
const mem = std.mem;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const util = @import("util.zig");
const Bytes = util.Bytes;
const IOStream = util.IOStream;
fn isColonValidateToken(ch: u8) !bool {
if (ch == ':') return true;
if (!util.isTokenChar(ch)) return error.BadRequest;
return false;
}
fn isControlOrPrint(ch: u8) bool {
return !ascii.isPrint(ch) and util.isCtrlChar(ch);
}
pub const Headers = struct {
pub const Header = struct {
key: []const u8,
value: []const u8,
};
pub const HeaderList = std.ArrayList(Header);
headers: HeaderList,
pub fn init(allocator: *Allocator) Headers {
return Headers{
.headers = HeaderList.init(allocator),
};
}
pub fn initCapacity(allocator: *Allocator, num: usize) !Headers {
return Headers{
.headers = try HeaderList.initCapacity(allocator, num),
};
}
pub fn deinit(self: *Headers) void {
self.headers.deinit();
}
pub fn format(
self: Headers,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
_ = fmt;
_ = options;
try std.fmt.format(out_stream, "Headers{{", .{});
for (self.headers.items) |header| {
try std.fmt.format(out_stream, "\"{s}\": \"{s}\", ", .{header.key, header.value});
}
try std.fmt.format(out_stream, "}}", .{});
}
// Get the index of the key
pub fn lookup(self: *Headers, key: []const u8) !usize {
for (self.headers.items) |header, i| {
if (ascii.eqlIgnoreCase(header.key, key)) return i;
}
return error.KeyError;
}
// Get the value for the given key
pub fn get(self: *Headers, key: []const u8) ![]const u8 {
const i = try self.lookup(key);
return self.headers.items[i].value;
}
pub fn getOptional(self: *Headers, key: []const u8) ?[]const u8 {
return self.get(key) catch null;
}
pub fn getDefault(self: *Headers, key: []const u8,
default: []const u8) []const u8 {
return self.get(key) catch default;
}
pub fn contains(self: *Headers, key: []const u8) bool {
_ = self.lookup(key) catch { return false; };
return true;
}
// Check if the header equals the other
pub fn eql(self: *Headers, key: []const u8, other: []const u8) bool {
const v = self.get(key) catch { return false; };
return mem.eql(u8, v, other);
}
pub fn eqlIgnoreCase(self: *Headers, key: []const u8, other: []const u8) bool {
const v = self.get(key) catch { return false; };
return ascii.eqlIgnoreCase(v, other);
}
pub fn put(self: *Headers, key: []const u8, value: []const u8) !void {
// If the key already exists under a different name don't add it again
const i = self.lookup(key) catch |err| switch (err) {
error.KeyError => {
try self.headers.append(Header{.key=key, .value=value});
return;
},
else => return err,
};
self.headers.items[i] = Header{.key=key, .value=value};
}
// Put without checking for duplicates
pub fn append(self: *Headers, key: []const u8, value: []const u8) !void {
return self.headers.append(Header{.key=key, .value=value});
}
pub fn appendAssumeCapacity(self: *Headers, key: []const u8, value: []const u8) void {
return self.headers.appendAssumeCapacity(Header{.key=key, .value=value});
}
pub fn remove(self: *Headers, key: []const u8) !void {
const i = try self.lookup(key); // Throw error
_ = self.headers.swapRemove(i);
}
pub fn pop(self: *Headers, key: []const u8) ![]const u8 {
const i = try self.lookup(key); // Throw error
return self.headers.swapRemove(i).value;
}
pub fn popDefault(self: *Headers, key: []const u8, default: []const u8) []const u8 {
return self.pop(key) catch default;
}
// Reset to an empty header list
pub fn reset(self: *Headers) void {
self.headers.items.len = 0;
}
/// Assumes the streams current buffer will exist for the lifetime
/// of the headers.
/// Note readbyteFast will not modify the buffer internal buffer
pub fn parse(self: *Headers, buf: *Bytes, stream: *IOStream, max_size: usize) !void {
// Reuse the request buffer for this
var index: usize = undefined;
var key: ?[]u8 = null;
var value: ?[]u8 = null;
const limit = std.math.min(max_size, stream.amountBuffered());
const read_limit = limit + stream.readCount();
var read_all_headers: bool = false;
while (self.headers.items.len < self.headers.capacity) {
var ch = try stream.readByteSafe();
defer key = null;
switch (ch) {
'\r' => {
ch = try stream.readByteSafe();
if (ch != '\n') return error.BadRequest;
read_all_headers = true;
break; // Empty line, we're done
},
'\n' => {
read_all_headers = true;
break; // Empty line, we're done
},
' ', '\t' => {
// Continuation of multi line header
if (key == null) return error.BadRequest;
},
':' => return error.BadRequest, // Empty key
else => {
index = stream.readCount()-1;
// Read header name
ch = try stream.readUntilExprValidate(
error{BadRequest}, isColonValidateToken, ch, read_limit);
// Header name
key = buf.items[index..stream.readCount()-1];
// Strip whitespace
while (stream.readCount() < read_limit) {
ch = stream.readByteUnsafe();
if (!(ch == ' ' or ch == '\t')) break;
}
},
}
// Read value
index = stream.readCount()-1;
ch = stream.readUntilExpr(isControlOrPrint, ch, read_limit);
// TODO: Strip trailing spaces and tabs?
value = buf.items[index..stream.readCount()-1];
// Ignore any remaining non-print characters
ch = stream.readUntilExpr(isControlOrPrint, ch, read_limit);
if (stream.readCount() >= read_limit) {
if (stream.isEmpty()) return error.EndOfBuffer;
return error.RequestHeaderFieldsTooLarge;
}
// Check CRLF
if (ch == '\r') {
ch = try stream.readByteSafe();
}
if (ch != '\n') {
return error.BadRequest;
}
//std.debug.warn("Found header: '{}'='{}'\n", .{key.?, value.?});
self.appendAssumeCapacity(key.?, value.?);
}
if (!read_all_headers) {
// If you hit this the capacity needs increased
return error.RequestHeaderFieldsTooLarge;
}
}
pub fn parseBuffer(self: *Headers, data: []const u8, max_size: usize) !void {
const hack = @bitCast([]u8, data); // HACK: Explicitly violate const
var fba = std.heap.FixedBufferAllocator.init(hack);
fba.end_index = data.len; // Ensure we don't modify the buffer
// Don't deinit since we don't actually own the data
var buf = Bytes.fromOwnedSlice(&fba.allocator, fba.buffer);
var stream = IOStream.fromBuffer(fba.buffer);
try self.parse(&buf, &stream, max_size);
}
};
test "headers-get" {
const allocator = std.testing.allocator;
var headers = try Headers.initCapacity(allocator, 64);
defer headers.deinit();
try headers.put("Cookie", "Nom;nom;nom");
try testing.expectError(error.KeyError, headers.get("Accept-Type"));
try testing.expectEqualSlices(u8, try headers.get("cookie"), "Nom;nom;nom");
try testing.expectEqualSlices(u8, try headers.get("cOOKie"), "Nom;nom;nom");
try testing.expectEqualSlices(u8,
headers.getDefault("User-Agent" , "zig"), "zig");
try testing.expectEqualSlices(u8,
headers.getDefault("cookie" , "zig"), "Nom;nom;nom");
}
test "headers-put" {
const allocator = std.testing.allocator;
var headers = try Headers.initCapacity(allocator, 64);
defer headers.deinit();
try headers.put("Cookie", "Nom;nom;nom");
try testing.expectEqualSlices(u8, try headers.get("Cookie"), "Nom;nom;nom");
try headers.put("COOKie", "ABC"); // Squash even if different
std.debug.warn("Cookie is: {s}", .{try headers.get("Cookie")});
try testing.expectEqualSlices(u8, try headers.get("Cookie"), "ABC");
}
test "headers-remove" {
const allocator = std.testing.allocator;
var headers = try Headers.initCapacity(allocator, 64);
defer headers.deinit();
try headers.put("Cookie", "Nom;nom;nom");
try testing.expect(headers.contains("Cookie"));
try testing.expect(headers.contains("COOKIE"));
try headers.remove("Cookie");
try testing.expect(!headers.contains("Cookie"));
}
test "headers-pop" {
const allocator = std.testing.allocator;
var headers = try Headers.initCapacity(allocator, 64);
defer headers.deinit();
try testing.expectError(error.KeyError, headers.pop("Cookie"));
try headers.put("Cookie", "Nom;nom;nom");
try testing.expect(mem.eql(u8, try headers.pop("Cookie"), "Nom;nom;nom"));
try testing.expect(!headers.contains("Cookie"));
try testing.expect(mem.eql(u8, headers.popDefault("Cookie", "Hello"), "Hello"));
}
test "headers-parse" {
const HEADERS =
\\Host: bs.serving-sys.com
\\User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:15.0) Gecko/20100101 Firefox/15.0.1
\\Accept: image/png,image/*;q=0.8,*/*;q=0.5
\\Accept-Language: en-us,en;q=0.5
\\Accept-Encoding: gzip, deflate
\\Connection: keep-alive
\\Referer: http://static.adzerk.net/reddit/ads.html?sr=-reddit.com&bust2
\\
\\
;
const allocator = std.testing.allocator;
var headers = try Headers.initCapacity(allocator, 64);
defer headers.deinit();
try headers.parseBuffer(HEADERS[0..], 1024);
try testing.expect(mem.eql(u8, try headers.get("Host"), "bs.serving-sys.com"));
try testing.expect(mem.eql(u8, try headers.get("Connection"), "keep-alive"));
} | src/headers.zig |
const std = @import("std");
const Window = @import("Window.zig");
const Monitor = @import("Monitor.zig");
const Error = @import("errors.zig").Error;
const getError = @import("errors.zig").getError;
const internal_debug = @import("internal_debug.zig");
pub const BackendOptions = struct {
win32: bool = false,
wgl: bool = false,
cocoa: bool = false,
nsgl: bool = false,
x11: bool = false,
glx: bool = false,
wayland: bool = false,
egl: bool = false,
osmesa: bool = false,
};
/// This function returns a type which allows provides an interface to access
/// the native handles based on backends selected.
///
/// The available window API options are:
/// * win32
/// * cocoa
/// * x11
/// * wayland
///
/// The available context API options are:
///
/// * wgl
/// * nsgl
/// * glx
/// * egl
/// * osmesa
///
/// The chosen backends must match those the library was compiled for. Failure to do so
/// will cause a link-time error.
pub fn Native(comptime options: BackendOptions) type {
const native = @cImport({
@cDefine("GLFW_INCLUDE_VULKAN", "1");
@cInclude("GLFW/glfw3.h");
if (options.win32) @cDefine("GLFW_EXPOSE_NATIVE_WIN32", "1");
if (options.wgl) @cDefine("GLFW_EXPOSE_NATIVE_WGL", "1");
if (options.cocoa) @cDefine("GLFW_EXPOSE_NATIVE_COCOA", "1");
if (options.nsgl) @cDefine("GLFW_EXPOSE_NATIVE_NGSL", "1");
if (options.x11) @cDefine("GLFW_EXPOSE_NATIVE_X11", "1");
if (options.glx) @cDefine("GLFW_EXPOSE_NATIVE_GLX", "1");
if (options.wayland) @cDefine("GLFW_EXPOSE_NATIVE_WAYLAND", "1");
if (options.egl) @cDefine("GLFW_EXPOSE_NATIVE_EGL", "1");
if (options.osmesa) @cDefine("GLFW_EXPOSE_NATIVE_OSMESA", "1");
@cInclude("GLFW/glfw3native.h");
});
return struct {
/// Returns the adapter device name of the specified monitor.
///
/// return: The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`) of the
/// specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWin32Adapter(monitor: Monitor) [*:0]const u8 {
internal_debug.assertInitialized();
if (native.glfwGetWin32Adapter(@ptrCast(*native.GLFWmonitor, monitor.handle))) |adapter| return adapter;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWin32Adapter` returns `null` only for errors
unreachable;
}
/// Returns the display device name of the specified monitor.
///
/// return: The UTF-8 encoded display device name (for example `\\.\DISPLAY1\Monitor0`)
/// of the specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWin32Monitor(monitor: Monitor) [*:0]const u8 {
internal_debug.assertInitialized();
if (native.glfwGetWin32Monitor(@ptrCast(*native.GLFWmonitor, monitor.handle))) |mon| return mon;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWin32Monitor` returns `null` only for errors
unreachable;
}
/// Returns the `HWND` of the specified window.
///
/// The `HDC` associated with the window can be queried with the
/// [GetDC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc)
/// function.
/// ```
/// const dc = std.os.windows.user32.GetDC(native.getWin32Window(window));
/// ```
/// This DC is private and does not need to be released.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWin32Window(window: Window) std.os.windows.HWND {
internal_debug.assertInitialized();
if (native.glfwGetWin32Window(@ptrCast(*native.GLFWwindow, window.handle))) |win|
return @ptrCast(std.os.windows.HWND, win);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWin32Window` returns `null` only for errors
unreachable;
}
/// Returns the `HGLRC` of the specified window.
///
/// The `HDC` associated with the window can be queried with the
/// [GetDC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc)
/// function.
/// ```
/// const dc = std.os.windows.user32.GetDC(native.getWin32Window(window));
/// ```
/// This DC is private and does not need to be released.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWGLContext(window: Window) error{NoWindowContext}!std.os.windows.HGLRC {
internal_debug.assertInitialized();
if (native.glfwGetWGLContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return context;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetWGLContext` returns `null` only for errors
unreachable;
}
/// Returns the `CGDirectDisplayID` of the specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getCocoaMonitor(monitor: Monitor) u32 {
internal_debug.assertInitialized();
const mon = native.glfwGetCocoaMonitor(@ptrCast(*native.GLFWmonitor, monitor.handle));
if (mon != native.kCGNullDirectDisplay) return mon;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetCocoaMonitor` returns `kCGNullDirectDisplay` only for errors
unreachable;
}
/// Returns the `NSWindow` of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getCocoaWindow(window: Window) ?*anyopaque {
internal_debug.assertInitialized();
const win = native.glfwGetCocoaWindow(@ptrCast(*native.GLFWwindow, window.handle));
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
return win;
}
/// Returns the `NSWindow` of the specified window.
///
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.NoWindowContext.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getNSGLContext(window: Window) error{NoWindowContext}!u32 {
internal_debug.assertInitialized();
const context = native.glfwGetNSGLContext(@ptrCast(*native.GLFWwindow, window.handle));
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
return context;
}
/// Returns the `Display` used by GLFW.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getX11Display() *anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetX11Display()) |display| return @ptrCast(*anyopaque, display);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetX11Display` returns `null` only for errors
unreachable;
}
/// Returns the `RRCrtc` of the specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getX11Adapter(monitor: Monitor) u32 {
internal_debug.assertInitialized();
const adapter = native.glfwGetX11Adapter(@ptrCast(*native.GLFWMonitor, monitor.handle));
if (adapter != 0) return adapter;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetX11Adapter` returns `0` only for errors
unreachable;
}
/// Returns the `RROutput` of the specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getX11Monitor(monitor: Monitor) u32 {
internal_debug.assertInitialized();
const mon = native.glfwGetX11Monitor(@ptrCast(*native.GLFWmonitor, monitor.handle));
if (mon != 0) return mon;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetX11Monitor` returns `0` only for errors
unreachable;
}
/// Returns the `Window` of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getX11Window(window: Window) u32 {
internal_debug.assertInitialized();
const win = native.glfwGetX11Window(@ptrCast(*native.GLFWwindow, window.handle));
if (win != 0) return @intCast(u32, win);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetX11Window` returns `0` only for errors
unreachable;
}
/// Sets the current primary selection to the specified string.
///
/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
///
/// The specified string is copied before this function returns.
///
/// thread_safety: This function must only be called from the main thread.
pub fn setX11SelectionString(string: [*:0]const u8) error{PlatformError}!void {
internal_debug.assertInitialized();
native.glfwSetX11SelectionString(string);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.PlatformError => |e| e,
else => unreachable,
};
}
/// Returns the contents of the current primary selection as a string.
///
/// Possible errors include glfw.Error.NotInitialized and glfw.Error.PlatformError.
///
/// The returned string is allocated and freed by GLFW. You should not free it
/// yourself. It is valid until the next call to getX11SelectionString or
/// setX11SelectionString, or until the library is terminated.
///
/// thread_safety: This function must only be called from the main thread.
pub fn getX11SelectionString() error{FormatUnavailable}![*:0]const u8 {
internal_debug.assertInitialized();
if (native.glfwGetX11SelectionString()) |str| return str;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.FormatUnavailable => |e| e,
else => unreachable,
};
// `glfwGetX11SelectionString` returns `null` only for errors
unreachable;
}
/// Returns the `GLXContext` of the specified window.
///
/// Possible errors include glfw.Error.NoWindowContext and glfw.Error.NotInitialized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getGLXContext(window: Window) error{NoWindowContext}!*anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetGLXContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return @ptrCast(*anyopaque, context);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetGLXContext` returns `null` only for errors
unreachable;
}
/// Returns the `GLXWindow` of the specified window.
///
/// Possible errors include glfw.Error.NoWindowContext and glfw.Error.NotInitialized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getGLXWindow(window: Window) error{NoWindowContext}!*anyopaque {
internal_debug.assertInitialized();
const win = native.glfwGetGLXWindow(@ptrCast(*native.GLFWwindow, window.handle));
if (win != 0) return @ptrCast(*anyopaque, win);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetGLXWindow` returns `0` only for errors
unreachable;
}
/// Returns the `*wl_display` used by GLFW.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWaylandDisplay() *anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetWaylandDisplay()) |display| return @ptrCast(*anyopaque, display);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWaylandDisplay` returns `null` only for errors
unreachable;
}
/// Returns the `*wl_output` of the specified monitor.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWaylandMonitor(monitor: Monitor) *anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetWaylandMonitor(@ptrCast(*native.GLFWmonitor, monitor.handle))) |mon| return @ptrCast(*anyopaque, mon);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWaylandMonitor` returns `null` only for errors
unreachable;
}
/// Returns the `*wl_surface` of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getWaylandWindow(window: Window) *anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetWaylandWindow(@ptrCast(*native.GLFWwindow, window.handle))) |win| return @ptrCast(*anyopaque, win);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetWaylandWindow` returns `null` only for errors
unreachable;
}
/// Returns the `EGLDisplay` used by GLFW.
///
/// Possible errors include glfw.Error.NotInitalized.
///
/// remark: Because EGL is initialized on demand, this function will return `EGL_NO_DISPLAY`
/// until the first context has been created via EGL.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getEGLDisplay() *anyopaque {
internal_debug.assertInitialized();
const display = native.glfwGetEGLDisplay();
if (display != native.EGL_NO_DISPLAY) return @ptrCast(*anyopaque, display);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
else => unreachable,
};
// `glfwGetEGLDisplay` returns `EGL_NO_DISPLAY` only for errors
unreachable;
}
/// Returns the `EGLContext` of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized and glfw.Error.NoWindowContext.
///
/// thread_safety This function may be called from any thread. Access is not synchronized.
pub fn getEGLContext(window: Window) error{NoWindowContext}!*anyopaque {
internal_debug.assertInitialized();
const context = native.glfwGetEGLContext(@ptrCast(*native.GLFWwindow, window.handle));
if (context != native.EGL_NO_CONTEXT) return @ptrCast(*anyopaque, context);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetEGLContext` returns `EGL_NO_CONTEXT` only for errors
unreachable;
}
/// Returns the `EGLSurface` of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized and glfw.Error.NoWindowContext.
///
/// thread_safety This function may be called from any thread. Access is not synchronized.
pub fn getEGLSurface(window: Window) error{NoWindowContext}!*anyopaque {
internal_debug.assertInitialized();
const surface = native.glfwGetEGLSurface(@ptrCast(*native.GLFWwindow, window.handle));
if (surface != native.EGL_NO_SURFACE) return @ptrCast(*anyopaque, surface);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetEGLSurface` returns `EGL_NO_SURFACE` only for errors
unreachable;
}
pub const OSMesaColorBuffer = struct {
width: c_int,
height: c_int,
format: c_int,
buffer: *anyopaque,
};
/// Retrieves the color buffer associated with the specified window.
///
/// Possible errors include glfw.Error.NotInitalized, glfw.Error.NoWindowContext
/// and glfw.Error.PlatformError.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getOSMesaColorBuffer(window: Window) error{ PlatformError, NoWindowContext }!OSMesaColorBuffer {
internal_debug.assertInitialized();
var buf: OSMesaColorBuffer = undefined;
if (native.glfwGetOSMesaColorBuffer(
@ptrCast(*native.GLFWwindow, window.handle),
&buf.width,
&buf.height,
&buf.format,
&buf.buffer,
) == native.GLFW_TRUE) return buf;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.PlatformError, Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetOSMesaColorBuffer` returns `GLFW_FALSE` only for errors
unreachable;
}
pub const OSMesaDepthBuffer = struct {
width: c_int,
height: c_int,
bytes_per_value: c_int,
buffer: *anyopaque,
};
/// Retrieves the depth buffer associated with the specified window.
///
/// Possible errors include glfw.Error.NotInitalized, glfw.Error.NoWindowContext
/// and glfw.Error.PlatformError.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getOSMesaDepthBuffer(window: Window) error{ PlatformError, NoWindowContext }!OSMesaDepthBuffer {
internal_debug.assertInitialized();
var buf: OSMesaDepthBuffer = undefined;
if (native.glfwGetOSMesaDepthBuffer(
@ptrCast(*native.GLFWwindow, window.handle),
&buf.width,
&buf.height,
&buf.bytes_per_value,
&buf.buffer,
) == native.GLFW_TRUE) return buf;
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.PlatformError, Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetOSMesaDepthBuffer` returns `GLFW_FALSE` only for errors
unreachable;
}
/// Returns the 'OSMesaContext' of the specified window.
///
/// Possible errors include glfw.Error.NotInitalized and glfw.Error.NoWindowContext.
///
/// thread_safety: This function may be called from any thread. Access is not synchronized.
pub fn getOSMesaContext(window: Window) error{NoWindowContext}!*anyopaque {
internal_debug.assertInitialized();
if (native.glfwGetOSMesaContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return @ptrCast(*anyopaque, context);
getError() catch |err| return switch (err) {
Error.NotInitialized => unreachable,
Error.NoWindowContext => |e| e,
else => unreachable,
};
// `glfwGetOSMesaContext` returns `null` only for errors
unreachable;
}
};
} | glfw/src/native.zig |
const std = @import("std");
const Color = @This();
alpha: ?u8 = null,
red: u8 = 0,
green: u8 = 0,
blue: u8 = 0,
pub fn write(this: Color, writer: anytype) !void {
if (this.alpha) |a_value| {
try writer.print("#{x:0>2}{x:0>2}{x:0>2}{x:0>2}", .{ this.alpha, this.red, this.green, this.blue });
} else {
try writer.print("#{x:0>2}{x:0>2}{x:0>2}", .{ this.red, this.green, this.blue });
}
}
pub fn bufferWrite(this: Color, buffer: []u8) ![]const u8 {
std.mem.set(u8, buffer, 0);
if (this.alpha) |a_value| {
if (buffer.len < 9) return error.OutOfSpace;
return try std.fmt.bufPrint(buffer, "#{x:0>2}{x:0>2}{x:0>2}{x:0>2}", .{ this.alpha, this.red, this.green, this.blue });
} else {
if (buffer.len < 7) return error.OutOfSpace;
return try std.fmt.bufPrint(buffer, "#{x:0>2}{x:0>2}{x:0>2}", .{ this.red, this.green, this.blue });
}
}
pub fn toString(this: Color, allocator: *std.mem.Allocator) ![]u8 {
if (this.alpha) |a_value| {
return try std.fmt.allocPrint(allocator, "#{x:0>2}{x:0>2}{x:0>2}{x:0>2}", .{ this.alpha, this.red, this.green, this.blue });
} else {
return try std.fmt.allocPrint(allocator, "#{x:0>2}{x:0>2}{x:0>2}", .{ this.red, this.green, this.blue });
}
}
pub fn fromString(string: []const u8) !Color {
var alpha: ?u8 = null;
var red: u8 = 0;
var green: u8 = 0;
var blue: u8 = 0;
if (string.len > 0 and string[0] != '#') return error.InvalidInput;
switch (string.len) {
4 => {
red = try std.fmt.charToDigit(string[1], 16);
green = try std.fmt.charToDigit(string[2], 16);
blue = try std.fmt.charToDigit(string[3], 16);
red = red | std.math.shl(u8, red, 4);
green = green | std.math.shl(u8, green, 4);
blue = blue | std.math.shl(u8, blue, 4);
},
7 => {
red = (try std.fmt.charToDigit(string[2], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[1], 16), 4);
green = (try std.fmt.charToDigit(string[4], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[3], 16), 4);
blue = (try std.fmt.charToDigit(string[6], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[5], 16), 4);
},
9 => {
alpha = (try std.fmt.charToDigit(string[2], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[1], 16), 4);
red = (try std.fmt.charToDigit(string[4], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[3], 16), 4);
green = (try std.fmt.charToDigit(string[6], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[5], 16), 4);
blue = (try std.fmt.charToDigit(string[8], 16)) | std.math.shl(u8, try std.fmt.charToDigit(string[7], 16), 4);
},
else => return error.InvalidInput,
}
return Color{
.alpha = alpha,
.red = red,
.green = green,
.blue = blue,
};
}
test "write color string to buffer" {
var buffer = [_]u8{0} ** 9;
var color = Color{
.alpha = 0xde,
.red = 0xad,
.green = 0xbe,
.blue = 0xef,
};
std.testing.expectEqualStrings("#deadbeef", try color.bufferWrite(&buffer));
color = Color{
.alpha = null,
.red = 0x06,
.green = 0x94,
.blue = 0x20,
};
std.testing.expectEqualStrings("#069420", try color.bufferWrite(&buffer));
var buf2 = [_]u8{0} ** 4;
std.testing.expectError(error.OutOfSpace, color.bufferWrite(&buf2));
}
test "color to string" {
var color = Color{
.alpha = 0xde,
.red = 0xad,
.green = 0xbe,
.blue = 0xef,
};
var string_1 = try color.toString(std.testing.allocator);
defer std.testing.allocator.free(string_1);
std.testing.expectEqualStrings("#deadbeef", string_1);
color = Color{
.alpha = null,
.red = 0x06,
.green = 0x94,
.blue = 0x20,
};
var string_2 = try color.toString(std.testing.allocator);
defer std.testing.allocator.free(string_2);
std.testing.expectEqualStrings("#069420", string_2);
}
test "color from string" {
std.testing.expectEqual(Color{
.alpha = null,
.red = 0xaa,
.green = 0xbb,
.blue = 0xcc,
}, try Color.fromString("#abc"));
std.testing.expectEqual(Color{
.alpha = null,
.red = 0x06,
.green = 0x94,
.blue = 0x20,
}, try Color.fromString("#069420"));
std.testing.expectEqual(Color{
.alpha = 0xde,
.red = 0xad,
.green = 0xbe,
.blue = 0xef,
}, try Color.fromString("#deadbeef"));
std.testing.expectError(error.InvalidInput, Color.fromString("#0000000"));
std.testing.expectError(error.InvalidInput, Color.fromString("000000"));
}
test "lossless conversion to/from string" {
var string_1 = "#069420";
var string_2 = "#deadbeef";
var buffer = [_]u8{0} ** 9;
std.testing.expectEqualStrings(string_1, try (try Color.fromString(string_1)).bufferWrite(&buffer));
std.testing.expectEqualStrings(string_2, try (try Color.fromString(string_2)).bufferWrite(&buffer));
} | src/Formatter/Color.zig |
const modf = @import("std").math.modf;
var CVTBUF: [80]u8 = undefined;
export fn cvt(_arg_arg: f64, _arg_ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int, buf: [*c]u8, eflag: c_int) [*c]u8 {
var arg = _arg_arg;
var ndigits = _arg_ndigits;
var r2: c_int = undefined;
var fi: f64 = undefined;
var fj: f64 = undefined;
var p: [*c]u8 = undefined;
var p1: [*c]u8 = undefined;
if (ndigits < 0) ndigits = 0;
if (ndigits >= (80 - 1)) ndigits = (80 - 2);
r2 = 0;
sign.?.* = 0;
p = (&buf[0]);
if (arg < @intToFloat(f64, 0)) {
sign.?.* = 1;
arg = (-arg);
}
{
const modf_result = modf(arg);
arg = modf_result.fpart;
fi = modf_result.ipart;
}
p1 = (&buf[80]);
if (fi != @intToFloat(f64, 0)) {
p1 = (&buf[80]);
while (fi != @intToFloat(f64, 0)) {
{
const modf_result = modf(fi / 10.0);
fj = modf_result.fpart;
fi = modf_result.ipart;
}
p1 -= 1;
p1.?.* = @floatToInt(u8, (fj + 0.03) * 10.0) + '0';
r2 += 1;
}
while (p1 < (&buf[80])) {
p.?.* = p1.?.*;
p += 1;
p1 += 1;
}
} else if (arg > 0.0) {
while ((x: {
const _tmp = arg * 10.0;
fj = _tmp;
break :x _tmp;
}) < @intToFloat(f64, 1)) {
arg = fj;
r2 -= 1;
}
}
p1 = (&buf[@intCast(usize, ndigits)]);
if (eflag == 0) p1 += @intCast(usize, r2);
decpt.?.* = r2;
if (p1 < (&buf[0])) {
buf[0] = @as(u8, '\x00');
return buf;
}
while ((p <= p1) and (p < (&buf[80]))) {
arg *= 10.0;
{
const modf_result = modf(arg);
arg = modf_result.fpart;
fj = modf_result.ipart;
}
p.?.* = @floatToInt(u8, fj) + '0';
p += 1;
}
if (p1 >= (&buf[80])) {
buf[80 - 1] = @as(u8, '\x00');
return buf;
}
p = p1;
p1.?.* +%= 5;
while (@as(c_int, p1.?.*) > '9') {
p1.?.* = @as(u8, '0');
if (p1 > buf) {
p1 -= 1;
p1.?.* += 1;
} else {
p1.?.* = @as(u8, '1');
decpt.?.* += 1;
if (eflag == 0) {
if (p > buf) p.?.* = @as(u8, '0');
p += 1;
}
}
}
p.?.* = 0;
return buf;
}
export fn ecvt(arg: f64, ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int) [*c]u8 {
return cvt(arg, ndigits, decpt, sign, &CVTBUF, 1);
}
export fn ecvtbuf(arg: f64, ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int, buf: [*c]u8) [*c]u8 {
return cvt(arg, ndigits, decpt, sign, buf, 1);
}
export fn fcvt(arg: f64, ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int) [*c]u8 {
return cvt(arg, ndigits, decpt, sign, &CVTBUF, 0);
}
export fn fcvtbuf(arg: f64, ndigits: c_int, decpt: [*c]c_int, sign: [*c]c_int, buf: [*c]u8) [*c]u8 {
return cvt(arg, ndigits, decpt, sign, buf, 0);
} | examples/nonsecure-bench-coremark/cvt.zig |
const std = @import("std");
const os = std.os;
pub const Segments = std.ArrayList(Segment);
/// A segment of readable memory.
const Segment = struct {
start: usize,
len: usize,
name: ?[]u8 = null,
};
/// Reads /proc/pid/maps file for a given pid.
/// Translates the addresses in that file into Segment structs, representing memory owned by the pid.
pub fn readMemMap(allocator: *std.mem.Allocator, pid: os.pid_t) !Segments {
var path_buffer = [_]u8{0} ** 30;
var fbs = std.io.fixedBufferStream(path_buffer[0..]);
try std.fmt.format(fbs.writer(), "/proc/{}/maps", .{pid});
const path = path_buffer[0..fbs.pos];
const fd = try os.open(path, 0, os.O_RDONLY);
defer os.close(fd);
var file = std.fs.File{ .handle = fd };
const map_data = try file.readToEndAlloc(allocator, 1_024_000);
defer allocator.free(map_data);
return try parseMap(allocator, map_data);
}
fn parseMap(allocator: *std.mem.Allocator, map_data: []u8) !Segments {
var segments = Segments.init(allocator);
errdefer segments.deinit();
// map_data's line structure:
// start-end, perms, data, time, data, maybe_name
var it = std.mem.split(map_data, "\n");
while (it.next()) |line| {
if (line.len == 0) continue;
var tokens = std.mem.split(line, " ");
var token_index: usize = 0;
var segment: Segment = undefined;
while (tokens.next()) |token| {
// Ignore tokens that are more delimeters
// Might not be needed if we move token 4+ code into its own block
// if (token_index > 4 and token.len == 0) continue;
if (token_index == 0) {
segment = try parseMemRange(token);
}
// Check to see if the memory segment is readable. We can safely ignore memory that is not readable.
else if (token_index == 1) {
if (token[0] != 'r') {
break;
}
// There is the possiblity for memory to have no name associated.
// Thus, we must look at future tokens from the token preceding the name token.
} else if (token_index == 4) {
var has_name = false;
while (tokens.next()) |name| {
if (name.len == 0) continue;
has_name = true;
// Token is the name of the memory allocator
// Ignore [stack], [vsyscall], etc
if (name[0] == '[' or name[0] == ' ') break;
if (std.mem.startsWith(u8, name, "/dev/")) break;
if (std.mem.startsWith(u8, name, "/newroot/dev/")) break;
// if (std.mem.indexOf(u8, name, ".so")) |_| break;
// if (std.mem.indexOf(u8, name, ".cache")) |_| break;
segment.name = try allocator.alloc(u8, name.len);
for (name) |char, index| segment.name.?[index] = char;
try segments.append(segment);
}
if (!has_name) {
try segments.append(segment);
}
}
token_index += 1;
}
}
return segments;
}
fn parseMemRange(str_range: []const u8) !Segment {
var it = std.mem.split(str_range, "-");
const hex_start = it.next().?;
const start = try std.fmt.parseInt(usize, hex_start, 16);
const hex_end = it.next().?;
const end = try std.fmt.parseInt(usize, hex_end, 16);
const size = end - start;
return Segment{ .start = start, .len = size };
} | src/read_map.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
// Parse flags from an ArgIterator according to the provided Flags struct. Skips the first arg
pub fn parse(allocator: Allocator, comptime Flags: type, args: *std.process.ArgIterator) !Flags {
std.debug.assert(args.skip());
return parseRaw(allocator, Flags, args);
}
// Parse flags from an ArgIterator according to the provided Flags struct
pub fn parseRaw(allocator: Allocator, comptime Flags: type, args: *std.process.ArgIterator) !Flags {
return parseIter(allocator, Flags, args, argPeek, argAdvance);
}
fn argPeek(args: *std.process.ArgIterator) ?[]const u8 {
var argsCopy = args.*;
return argsCopy.next() orelse null;
}
fn argAdvance(args: *std.process.ArgIterator) void {
std.debug.assert(args.skip());
}
pub fn parseIter(
allocator: Allocator,
comptime Flags: type,
context: anytype,
peek: fn (@TypeOf(context)) ?[]const u8,
advance: fn (@TypeOf(context)) void,
) !Flags {
var flags: Flags = .{};
while (peek(context)) |arg| {
if (arg.len < 2 or !std.mem.startsWith(u8, arg, "-")) break;
advance(context);
if (std.mem.eql(u8, arg, "--")) break;
arg_flags: for (arg[1..]) |opt, i| {
inline for (std.meta.fields(Flags)) |field| {
if (field.name.len != 1) {
@compileError("An argument name must be a single character");
}
if (opt == field.name[0]) {
const T = Unwrap(field.field_type);
if (T == bool) {
@field(flags, field.name) = true;
} else {
var param: []const u8 = undefined;
if (i + 2 < arg.len) {
param = arg[i + 2 ..];
} else {
param = peek(context) orelse {
return error.MissingParameter;
};
advance(context);
}
if (T == []const u8) {
@field(flags, field.name) = param;
} else {
@field(flags, field.name) = switch (@typeInfo(T)) {
.Int => try std.fmt.parseInt(T, param, 10),
.Float => try std.fmt.parseFloat(T, param),
else => @compileError("Unsupported flag type '" ++ @typeName(field.field_type) ++ "'"),
};
}
// Ensure we don't try to parse any more flags from this arg
break :arg_flags;
}
break;
}
} else {
return error.InvalidFlag;
}
}
}
// Dupe all strings
const fields = std.meta.fields(Flags);
inline for (fields) |field, i| {
if (field.field_type == []const u8) {
@field(flags, field.name) = allocator.dupe(u8, @field(flags, field.name)) catch |err| {
// Free all previously allocated strings
comptime var j = i;
inline while (j > 0) {
j -= 1;
if (fields[j].field_type == []const u8) {
allocator.free(@field(flags, fields[j].name));
}
}
return err;
};
}
}
return flags;
}
fn Unwrap(comptime T: type) type {
return if (@typeInfo(T) == .Optional) std.meta.Child(T) else T;
}
fn parseTest(comptime Flags: type, args: []const []const u8) !Flags {
var argsV = args;
return parseIter(std.testing.allocator, Flags, &argsV, testPeek, testAdvance);
}
fn testPeek(args: *[]const []const u8) ?[]const u8 {
if (args.*.len == 0) return null;
return args.*[0];
}
fn testAdvance(args: *[]const []const u8) void {
args.* = args.*[1..];
}
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
test "arg iterator" {
var args = try std.process.argsWithAllocator(std.testing.allocator);
defer args.deinit();
_ = try parse(std.testing.allocator, struct {}, &args);
}
test "bool flag - default" {
const flags = try parseTest(
struct { b: bool = false },
&.{},
);
try expect(!flags.b);
}
test "bool flag - specified" {
const flags = try parseTest(
struct { b: bool = false },
&.{"-b"},
);
try expect(flags.b);
}
test "string flag - default" {
const flags = try parseTest(
struct { s: []const u8 = "default value" },
&.{},
);
defer std.testing.allocator.free(flags.s);
try expectEqualStrings(flags.s, "default value");
}
test "string flag - separated" {
const flags = try parseTest(
struct { s: []const u8 = "default value" },
&.{ "-s", "separate value" },
);
defer std.testing.allocator.free(flags.s);
try expectEqualStrings(flags.s, "separate value");
}
test "string flag - combined" {
const flags = try parseTest(
struct { s: []const u8 = "default value" },
&.{"-scombined value"},
);
defer std.testing.allocator.free(flags.s);
try expectEqualStrings(flags.s, "combined value");
}
test "int flag - default" {
const flags = try parseTest(
struct { s: u8 = 7 },
&.{},
);
try expectEqual(flags.s, 7);
}
test "int flag - separated" {
const flags = try parseTest(
struct { s: u8 = 7 },
&.{ "-s", "40" },
);
try expectEqual(flags.s, 40);
}
test "int flag - combined" {
const flags = try parseTest(
struct { s: u8 = 7 },
&.{"-s70"},
);
try expectEqual(flags.s, 70);
}
test "float flag - default" {
const flags = try parseTest(
struct { s: f32 = 9.6 },
&.{},
);
try expectEqual(flags.s, 9.6);
}
test "float flag - separated" {
const flags = try parseTest(
struct { s: f32 = 9.6 },
&.{ "-s", "4.2" },
);
try expectEqual(flags.s, 4.2);
}
test "float flag - combined" {
const flags = try parseTest(
struct { s: f32 = 9.6 },
&.{"-s0.36"},
);
try expectEqual(flags.s, 0.36);
}
test "bool and string flags" {
const flags = try parseTest(
struct {
b: bool = false,
s: []const u8 = "",
},
&.{ "-s", "foo" },
);
defer std.testing.allocator.free(flags.s);
try expectEqual(flags.b, false);
try expectEqualStrings(flags.s, "foo");
} | optz.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day16.txt");
const PacketType = enum(u3) {
literal_value = 4,
operator,
};
const Payload = union(PacketType) {
literal_value: u64,
};
const Packet = struct {
version: u3,
type: PacketType,
payload: Payload,
};
fn readLiteralValue(reader: anytype) u64 {
var reader_ = reader;
var ret: u64 = 0;
var count: usize = 0;
while (true) : (count += 1) {
var num_bits: usize = undefined;
const group_type = try reader_.readBits(u1, 1, &num_bits);
assert(num_bits == 1);
const group_bits = try reader_.readBits(u4, 4, &num_bits);
assert(num_bits == 4);
ret <<= 4;
ret &= group_bits;
if (group_type == 0) break;
}
return ret;
}
pub fn main() !void {
const input: []u8 = blk: {
var iter = tokenize(u8, data, "\r\n");
const line = iter.next().?;
var buf = try gpa.alloc(u8, line.len/2);
const bytes = try std.fmt.hexToBytes(buf, line);
break :blk bytes;
};
if (false) {
print("\n", .{});
for (input) |c| {
print("{b:0>8}", .{c});
}
print("\n\n", .{});
}
var bit_stream = std.io.bitReader(.Big, std.io.fixedBufferStream(input).reader());
var num_bits: usize = undefined;
const version = try bit_stream.readBits(u3, 3, &num_bits);
print("version: {}\n", .{version});
const type_id = try bit_stream.readBits(u3, 3, &num_bits);
print("type: {}\n", .{type_id});
if (type_id == 4) {
const literal = readLiteralValue(bit_stream);
print("{}\n", .{literal});
} else {
const length_type_id = try bit_stream.readBits(u1, 1, &num_bits);
if (length_type_id == 1) {
const length_bits = try bit_stream.readBits(u15, 15, &num_bits);
print("length in bits: {}\n", .{length_bits});
} else {
const length_pkts = try bit_stream.readBits(u11, 11, &num_bits);
print("length in subpackets: {}\n", .{length_pkts});
}
}
}
// 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/day16.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Map = std.AutoHashMap;
const StrMap = std.StringHashMap;
const BitSet = std.DynamicBitSet;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("../data/day02.txt");
const Direction = enum {
forward,
down,
up,
};
const Instruction = struct {
direction: Direction,
value: u32,
};
pub fn main() !void {
// create list
var list = std.ArrayList(Instruction).init(gpa);
defer list.deinit();
// parse data and append to list
{
var iter = split(u8, data, "\n");
while(iter.next()) |line| {
if (line.len == 0) continue;
var instruction: Instruction = undefined;
var iter2 = split(u8, line, " ");
if (iter2.next()) |s| {
switch (s[0]) {
'f' => instruction.direction = .forward,
'd' => instruction.direction = .down,
'u' => instruction.direction = .up,
else => unreachable,
}
}
if (iter2.next()) |s| {
const n = try parseInt(u32, s, 10);
instruction.value = n;
}
try list.append(instruction);
}
}
{ // Part 1
var depth: u32 = 0;
var dist: u32 = 0;
for (list.items) |instruction| {
switch (instruction.direction) {
.forward => { dist += instruction.value; },
.up => { depth -= instruction.value; },
.down => { depth += instruction.value; },
}
}
const answer = dist * depth;
print("{}\n", .{answer});
}
{ // Part 2
var depth: u32 = 0;
var dist: u32 = 0;
var aim: u32 = 0;
for (list.items) |instruction| {
switch (instruction.direction) {
.forward => {
dist += instruction.value;
depth += aim * instruction.value;
},
.up => { aim -= instruction.value; },
.down => { aim += instruction.value; },
}
}
const answer = dist * depth;
print("{}\n", .{answer});
}
}
// 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/day02.zig |
pub const CLSID_VERSION_DEPENDENT_MSIME_JAPANESE = Guid.initString("6a91029e-aa49-471b-aee7-7d332785660d");
pub const IFEC_S_ALREADY_DEFAULT = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291840));
pub const FELANG_REQ_CONV = @as(u32, 65536);
pub const FELANG_REQ_RECONV = @as(u32, 131072);
pub const FELANG_REQ_REV = @as(u32, 196608);
pub const FELANG_CMODE_MONORUBY = @as(u32, 2);
pub const FELANG_CMODE_NOPRUNING = @as(u32, 4);
pub const FELANG_CMODE_KATAKANAOUT = @as(u32, 8);
pub const FELANG_CMODE_HIRAGANAOUT = @as(u32, 0);
pub const FELANG_CMODE_HALFWIDTHOUT = @as(u32, 16);
pub const FELANG_CMODE_FULLWIDTHOUT = @as(u32, 32);
pub const FELANG_CMODE_BOPOMOFO = @as(u32, 64);
pub const FELANG_CMODE_HANGUL = @as(u32, 128);
pub const FELANG_CMODE_PINYIN = @as(u32, 256);
pub const FELANG_CMODE_PRECONV = @as(u32, 512);
pub const FELANG_CMODE_RADICAL = @as(u32, 1024);
pub const FELANG_CMODE_UNKNOWNREADING = @as(u32, 2048);
pub const FELANG_CMODE_MERGECAND = @as(u32, 4096);
pub const FELANG_CMODE_ROMAN = @as(u32, 8192);
pub const FELANG_CMODE_BESTFIRST = @as(u32, 16384);
pub const FELANG_CMODE_USENOREVWORDS = @as(u32, 32768);
pub const FELANG_CMODE_NONE = @as(u32, 16777216);
pub const FELANG_CMODE_PLAURALCLAUSE = @as(u32, 33554432);
pub const FELANG_CMODE_SINGLECONVERT = @as(u32, 67108864);
pub const FELANG_CMODE_AUTOMATIC = @as(u32, 134217728);
pub const FELANG_CMODE_PHRASEPREDICT = @as(u32, 268435456);
pub const FELANG_CMODE_CONVERSATION = @as(u32, 536870912);
pub const FELANG_CMODE_NAME = @as(u32, 268435456);
pub const FELANG_CMODE_NOINVISIBLECHAR = @as(u32, 1073741824);
pub const E_NOCAND = @as(u32, 48);
pub const E_NOTENOUGH_BUFFER = @as(u32, 49);
pub const E_NOTENOUGH_WDD = @as(u32, 50);
pub const E_LARGEINPUT = @as(u32, 51);
pub const FELANG_CLMN_WBREAK = @as(u32, 1);
pub const FELANG_CLMN_NOWBREAK = @as(u32, 2);
pub const FELANG_CLMN_PBREAK = @as(u32, 4);
pub const FELANG_CLMN_NOPBREAK = @as(u32, 8);
pub const FELANG_CLMN_FIXR = @as(u32, 16);
pub const FELANG_CLMN_FIXD = @as(u32, 32);
pub const FELANG_INVALD_PO = @as(u32, 65535);
pub const IFED_POS_NONE = @as(u32, 0);
pub const IFED_POS_NOUN = @as(u32, 1);
pub const IFED_POS_VERB = @as(u32, 2);
pub const IFED_POS_ADJECTIVE = @as(u32, 4);
pub const IFED_POS_ADJECTIVE_VERB = @as(u32, 8);
pub const IFED_POS_ADVERB = @as(u32, 16);
pub const IFED_POS_ADNOUN = @as(u32, 32);
pub const IFED_POS_CONJUNCTION = @as(u32, 64);
pub const IFED_POS_INTERJECTION = @as(u32, 128);
pub const IFED_POS_INDEPENDENT = @as(u32, 255);
pub const IFED_POS_INFLECTIONALSUFFIX = @as(u32, 256);
pub const IFED_POS_PREFIX = @as(u32, 512);
pub const IFED_POS_SUFFIX = @as(u32, 1024);
pub const IFED_POS_AFFIX = @as(u32, 1536);
pub const IFED_POS_TANKANJI = @as(u32, 2048);
pub const IFED_POS_IDIOMS = @as(u32, 4096);
pub const IFED_POS_SYMBOLS = @as(u32, 8192);
pub const IFED_POS_PARTICLE = @as(u32, 16384);
pub const IFED_POS_AUXILIARY_VERB = @as(u32, 32768);
pub const IFED_POS_SUB_VERB = @as(u32, 65536);
pub const IFED_POS_DEPENDENT = @as(u32, 114688);
pub const IFED_POS_ALL = @as(u32, 131071);
pub const IFED_SELECT_NONE = @as(u32, 0);
pub const IFED_SELECT_READING = @as(u32, 1);
pub const IFED_SELECT_DISPLAY = @as(u32, 2);
pub const IFED_SELECT_POS = @as(u32, 4);
pub const IFED_SELECT_COMMENT = @as(u32, 8);
pub const IFED_SELECT_ALL = @as(u32, 15);
pub const IFED_REG_NONE = @as(u32, 0);
pub const IFED_REG_USER = @as(u32, 1);
pub const IFED_REG_AUTO = @as(u32, 2);
pub const IFED_REG_GRAMMAR = @as(u32, 4);
pub const IFED_REG_ALL = @as(u32, 7);
pub const IFED_TYPE_NONE = @as(u32, 0);
pub const IFED_TYPE_GENERAL = @as(u32, 1);
pub const IFED_TYPE_NAMEPLACE = @as(u32, 2);
pub const IFED_TYPE_SPEECH = @as(u32, 4);
pub const IFED_TYPE_REVERSE = @as(u32, 8);
pub const IFED_TYPE_ENGLISH = @as(u32, 16);
pub const IFED_TYPE_ALL = @as(u32, 31);
pub const IFED_S_MORE_ENTRIES = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291328));
pub const IFED_S_EMPTY_DICTIONARY = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291329));
pub const IFED_S_WORD_EXISTS = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291330));
pub const IFED_S_COMMENT_CHANGED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 291331));
pub const IFED_E_NOT_FOUND = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192064));
pub const IFED_E_INVALID_FORMAT = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192063));
pub const IFED_E_OPEN_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192062));
pub const IFED_E_WRITE_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192061));
pub const IFED_E_NO_ENTRY = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192060));
pub const IFED_E_REGISTER_FAILED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192059));
pub const IFED_E_NOT_USER_DIC = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192058));
pub const IFED_E_NOT_SUPPORTED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192057));
pub const IFED_E_USER_COMMENT = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192056));
pub const IFED_E_REGISTER_ILLEGAL_POS = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192055));
pub const IFED_E_REGISTER_IMPROPER_WORD = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192054));
pub const IFED_E_REGISTER_DISCONNECTED = @import("../../zig.zig").typedConst(HRESULT, @as(i32, -2147192053));
pub const POS_UNDEFINED = @as(u32, 0);
pub const JPOS_UNDEFINED = @as(u32, 0);
pub const JPOS_MEISHI_FUTSU = @as(u32, 100);
pub const JPOS_MEISHI_SAHEN = @as(u32, 101);
pub const JPOS_MEISHI_ZAHEN = @as(u32, 102);
pub const JPOS_MEISHI_KEIYOUDOUSHI = @as(u32, 103);
pub const JPOS_HUKUSIMEISHI = @as(u32, 104);
pub const JPOS_MEISA_KEIDOU = @as(u32, 105);
pub const JPOS_JINMEI = @as(u32, 106);
pub const JPOS_JINMEI_SEI = @as(u32, 107);
pub const JPOS_JINMEI_MEI = @as(u32, 108);
pub const JPOS_CHIMEI = @as(u32, 109);
pub const JPOS_CHIMEI_KUNI = @as(u32, 110);
pub const JPOS_CHIMEI_KEN = @as(u32, 111);
pub const JPOS_CHIMEI_GUN = @as(u32, 112);
pub const JPOS_CHIMEI_KU = @as(u32, 113);
pub const JPOS_CHIMEI_SHI = @as(u32, 114);
pub const JPOS_CHIMEI_MACHI = @as(u32, 115);
pub const JPOS_CHIMEI_MURA = @as(u32, 116);
pub const JPOS_CHIMEI_EKI = @as(u32, 117);
pub const JPOS_SONOTA = @as(u32, 118);
pub const JPOS_SHAMEI = @as(u32, 119);
pub const JPOS_SOSHIKI = @as(u32, 120);
pub const JPOS_KENCHIKU = @as(u32, 121);
pub const JPOS_BUPPIN = @as(u32, 122);
pub const JPOS_DAIMEISHI = @as(u32, 123);
pub const JPOS_DAIMEISHI_NINSHOU = @as(u32, 124);
pub const JPOS_DAIMEISHI_SHIJI = @as(u32, 125);
pub const JPOS_KAZU = @as(u32, 126);
pub const JPOS_KAZU_SURYOU = @as(u32, 127);
pub const JPOS_KAZU_SUSHI = @as(u32, 128);
pub const JPOS_5DAN_AWA = @as(u32, 200);
pub const JPOS_5DAN_KA = @as(u32, 201);
pub const JPOS_5DAN_GA = @as(u32, 202);
pub const JPOS_5DAN_SA = @as(u32, 203);
pub const JPOS_5DAN_TA = @as(u32, 204);
pub const JPOS_5DAN_NA = @as(u32, 205);
pub const JPOS_5DAN_BA = @as(u32, 206);
pub const JPOS_5DAN_MA = @as(u32, 207);
pub const JPOS_5DAN_RA = @as(u32, 208);
pub const JPOS_5DAN_AWAUON = @as(u32, 209);
pub const JPOS_5DAN_KASOKUON = @as(u32, 210);
pub const JPOS_5DAN_RAHEN = @as(u32, 211);
pub const JPOS_4DAN_HA = @as(u32, 212);
pub const JPOS_1DAN = @as(u32, 213);
pub const JPOS_TOKUSHU_KAHEN = @as(u32, 214);
pub const JPOS_TOKUSHU_SAHENSURU = @as(u32, 215);
pub const JPOS_TOKUSHU_SAHEN = @as(u32, 216);
pub const JPOS_TOKUSHU_ZAHEN = @as(u32, 217);
pub const JPOS_TOKUSHU_NAHEN = @as(u32, 218);
pub const JPOS_KURU_KI = @as(u32, 219);
pub const JPOS_KURU_KITA = @as(u32, 220);
pub const JPOS_KURU_KITARA = @as(u32, 221);
pub const JPOS_KURU_KITARI = @as(u32, 222);
pub const JPOS_KURU_KITAROU = @as(u32, 223);
pub const JPOS_KURU_KITE = @as(u32, 224);
pub const JPOS_KURU_KUREBA = @as(u32, 225);
pub const JPOS_KURU_KO = @as(u32, 226);
pub const JPOS_KURU_KOI = @as(u32, 227);
pub const JPOS_KURU_KOYOU = @as(u32, 228);
pub const JPOS_SURU_SA = @as(u32, 229);
pub const JPOS_SURU_SI = @as(u32, 230);
pub const JPOS_SURU_SITA = @as(u32, 231);
pub const JPOS_SURU_SITARA = @as(u32, 232);
pub const JPOS_SURU_SIATRI = @as(u32, 233);
pub const JPOS_SURU_SITAROU = @as(u32, 234);
pub const JPOS_SURU_SITE = @as(u32, 235);
pub const JPOS_SURU_SIYOU = @as(u32, 236);
pub const JPOS_SURU_SUREBA = @as(u32, 237);
pub const JPOS_SURU_SE = @as(u32, 238);
pub const JPOS_SURU_SEYO = @as(u32, 239);
pub const JPOS_KEIYOU = @as(u32, 300);
pub const JPOS_KEIYOU_GARU = @as(u32, 301);
pub const JPOS_KEIYOU_GE = @as(u32, 302);
pub const JPOS_KEIYOU_ME = @as(u32, 303);
pub const JPOS_KEIYOU_YUU = @as(u32, 304);
pub const JPOS_KEIYOU_U = @as(u32, 305);
pub const JPOS_KEIDOU = @as(u32, 400);
pub const JPOS_KEIDOU_NO = @as(u32, 401);
pub const JPOS_KEIDOU_TARU = @as(u32, 402);
pub const JPOS_KEIDOU_GARU = @as(u32, 403);
pub const JPOS_FUKUSHI = @as(u32, 500);
pub const JPOS_FUKUSHI_SAHEN = @as(u32, 501);
pub const JPOS_FUKUSHI_NI = @as(u32, 502);
pub const JPOS_FUKUSHI_NANO = @as(u32, 503);
pub const JPOS_FUKUSHI_DA = @as(u32, 504);
pub const JPOS_FUKUSHI_TO = @as(u32, 505);
pub const JPOS_FUKUSHI_TOSURU = @as(u32, 506);
pub const JPOS_RENTAISHI = @as(u32, 600);
pub const JPOS_RENTAISHI_SHIJI = @as(u32, 601);
pub const JPOS_SETSUZOKUSHI = @as(u32, 650);
pub const JPOS_KANDOUSHI = @as(u32, 670);
pub const JPOS_SETTOU = @as(u32, 700);
pub const JPOS_SETTOU_KAKU = @as(u32, 701);
pub const JPOS_SETTOU_SAI = @as(u32, 702);
pub const JPOS_SETTOU_FUKU = @as(u32, 703);
pub const JPOS_SETTOU_MI = @as(u32, 704);
pub const JPOS_SETTOU_DAISHOU = @as(u32, 705);
pub const JPOS_SETTOU_KOUTEI = @as(u32, 706);
pub const JPOS_SETTOU_CHOUTAN = @as(u32, 707);
pub const JPOS_SETTOU_SHINKYU = @as(u32, 708);
pub const JPOS_SETTOU_JINMEI = @as(u32, 709);
pub const JPOS_SETTOU_CHIMEI = @as(u32, 710);
pub const JPOS_SETTOU_SONOTA = @as(u32, 711);
pub const JPOS_SETTOU_JOSUSHI = @as(u32, 712);
pub const JPOS_SETTOU_TEINEI_O = @as(u32, 713);
pub const JPOS_SETTOU_TEINEI_GO = @as(u32, 714);
pub const JPOS_SETTOU_TEINEI_ON = @as(u32, 715);
pub const JPOS_SETSUBI = @as(u32, 800);
pub const JPOS_SETSUBI_TEKI = @as(u32, 801);
pub const JPOS_SETSUBI_SEI = @as(u32, 802);
pub const JPOS_SETSUBI_KA = @as(u32, 803);
pub const JPOS_SETSUBI_CHU = @as(u32, 804);
pub const JPOS_SETSUBI_FU = @as(u32, 805);
pub const JPOS_SETSUBI_RYU = @as(u32, 806);
pub const JPOS_SETSUBI_YOU = @as(u32, 807);
pub const JPOS_SETSUBI_KATA = @as(u32, 808);
pub const JPOS_SETSUBI_MEISHIRENDAKU = @as(u32, 809);
pub const JPOS_SETSUBI_JINMEI = @as(u32, 810);
pub const JPOS_SETSUBI_CHIMEI = @as(u32, 811);
pub const JPOS_SETSUBI_KUNI = @as(u32, 812);
pub const JPOS_SETSUBI_KEN = @as(u32, 813);
pub const JPOS_SETSUBI_GUN = @as(u32, 814);
pub const JPOS_SETSUBI_KU = @as(u32, 815);
pub const JPOS_SETSUBI_SHI = @as(u32, 816);
pub const JPOS_SETSUBI_MACHI = @as(u32, 817);
pub const JPOS_SETSUBI_CHOU = @as(u32, 818);
pub const JPOS_SETSUBI_MURA = @as(u32, 819);
pub const JPOS_SETSUBI_SON = @as(u32, 820);
pub const JPOS_SETSUBI_EKI = @as(u32, 821);
pub const JPOS_SETSUBI_SONOTA = @as(u32, 822);
pub const JPOS_SETSUBI_SHAMEI = @as(u32, 823);
pub const JPOS_SETSUBI_SOSHIKI = @as(u32, 824);
pub const JPOS_SETSUBI_KENCHIKU = @as(u32, 825);
pub const JPOS_RENYOU_SETSUBI = @as(u32, 826);
pub const JPOS_SETSUBI_JOSUSHI = @as(u32, 827);
pub const JPOS_SETSUBI_JOSUSHIPLUS = @as(u32, 828);
pub const JPOS_SETSUBI_JIKAN = @as(u32, 829);
pub const JPOS_SETSUBI_JIKANPLUS = @as(u32, 830);
pub const JPOS_SETSUBI_TEINEI = @as(u32, 831);
pub const JPOS_SETSUBI_SAN = @as(u32, 832);
pub const JPOS_SETSUBI_KUN = @as(u32, 833);
pub const JPOS_SETSUBI_SAMA = @as(u32, 834);
pub const JPOS_SETSUBI_DONO = @as(u32, 835);
pub const JPOS_SETSUBI_FUKUSU = @as(u32, 836);
pub const JPOS_SETSUBI_TACHI = @as(u32, 837);
pub const JPOS_SETSUBI_RA = @as(u32, 838);
pub const JPOS_TANKANJI = @as(u32, 900);
pub const JPOS_TANKANJI_KAO = @as(u32, 901);
pub const JPOS_KANYOUKU = @as(u32, 902);
pub const JPOS_DOKURITSUGO = @as(u32, 903);
pub const JPOS_FUTEIGO = @as(u32, 904);
pub const JPOS_KIGOU = @as(u32, 905);
pub const JPOS_EIJI = @as(u32, 906);
pub const JPOS_KUTEN = @as(u32, 907);
pub const JPOS_TOUTEN = @as(u32, 908);
pub const JPOS_KANJI = @as(u32, 909);
pub const JPOS_OPENBRACE = @as(u32, 910);
pub const JPOS_CLOSEBRACE = @as(u32, 911);
pub const JPOS_YOKUSEI = @as(u32, 912);
pub const JPOS_TANSHUKU = @as(u32, 913);
pub const VERSION_ID_JAPANESE = @as(u32, 16777216);
pub const VERSION_ID_KOREAN = @as(u32, 33554432);
pub const VERSION_ID_CHINESE_TRADITIONAL = @as(u32, 67108864);
pub const VERSION_ID_CHINESE_SIMPLIFIED = @as(u32, 134217728);
pub const FID_MSIME_VERSION = @as(u32, 0);
pub const VERSION_MOUSE_OPERATION = @as(u32, 1);
pub const IMEMOUSERET_NOTHANDLED = @as(i32, -1);
pub const IMEMOUSE_VERSION = @as(u32, 255);
pub const IMEMOUSE_NONE = @as(u32, 0);
pub const IMEMOUSE_LDOWN = @as(u32, 1);
pub const IMEMOUSE_RDOWN = @as(u32, 2);
pub const IMEMOUSE_MDOWN = @as(u32, 4);
pub const IMEMOUSE_WUP = @as(u32, 16);
pub const IMEMOUSE_WDOWN = @as(u32, 32);
pub const FID_RECONVERT_VERSION = @as(u32, 268435456);
pub const VERSION_RECONVERSION = @as(u32, 1);
pub const VERSION_DOCUMENTFEED = @as(u32, 1);
pub const VERSION_QUERYPOSITION = @as(u32, 1);
pub const VERSION_MODEBIAS = @as(u32, 1);
pub const MODEBIAS_GETVERSION = @as(u32, 0);
pub const MODEBIAS_SETVALUE = @as(u32, 1);
pub const MODEBIAS_GETVALUE = @as(u32, 2);
pub const MODEBIASMODE_DEFAULT = @as(u32, 0);
pub const MODEBIASMODE_FILENAME = @as(u32, 1);
pub const MODEBIASMODE_READING = @as(u32, 2);
pub const MODEBIASMODE_DIGIT = @as(u32, 4);
pub const SHOWIMEPAD_DEFAULT = @as(u32, 0);
pub const SHOWIMEPAD_CATEGORY = @as(u32, 1);
pub const SHOWIMEPAD_GUID = @as(u32, 2);
pub const FID_MSIME_KMS_VERSION = @as(u32, 1);
pub const FID_MSIME_KMS_INIT = @as(u32, 2);
pub const FID_MSIME_KMS_TERM = @as(u32, 3);
pub const FID_MSIME_KMS_DEL_KEYLIST = @as(u32, 4);
pub const FID_MSIME_KMS_NOTIFY = @as(u32, 5);
pub const FID_MSIME_KMS_GETMAP = @as(u32, 6);
pub const FID_MSIME_KMS_INVOKE = @as(u32, 7);
pub const FID_MSIME_KMS_SETMAP = @as(u32, 8);
pub const FID_MSIME_KMS_FUNCDESC = @as(u32, 9);
pub const FID_MSIME_KMS_GETMAPSEAMLESS = @as(u32, 10);
pub const FID_MSIME_KMS_GETMAPFAST = @as(u32, 11);
pub const IMEKMS_NOCOMPOSITION = @as(u32, 0);
pub const IMEKMS_COMPOSITION = @as(u32, 1);
pub const IMEKMS_SELECTION = @as(u32, 2);
pub const IMEKMS_IMEOFF = @as(u32, 3);
pub const IMEKMS_2NDLEVEL = @as(u32, 4);
pub const IMEKMS_INPTGL = @as(u32, 5);
pub const IMEKMS_CANDIDATE = @as(u32, 6);
pub const IMEKMS_TYPECAND = @as(u32, 7);
pub const RECONVOPT_NONE = @as(u32, 0);
pub const RECONVOPT_USECANCELNOTIFY = @as(u32, 1);
pub const GCSEX_CANCELRECONVERT = @as(u32, 268435456);
pub const STYLE_DESCRIPTION_SIZE = @as(u32, 32);
pub const IMEMENUITEM_STRING_SIZE = @as(u32, 80);
pub const IMC_GETCANDIDATEPOS = @as(u32, 7);
pub const IMC_SETCANDIDATEPOS = @as(u32, 8);
pub const IMC_GETCOMPOSITIONFONT = @as(u32, 9);
pub const IMC_SETCOMPOSITIONFONT = @as(u32, 10);
pub const IMC_GETCOMPOSITIONWINDOW = @as(u32, 11);
pub const IMC_SETCOMPOSITIONWINDOW = @as(u32, 12);
pub const IMC_GETSTATUSWINDOWPOS = @as(u32, 15);
pub const IMC_SETSTATUSWINDOWPOS = @as(u32, 16);
pub const IMC_CLOSESTATUSWINDOW = @as(u32, 33);
pub const IMC_OPENSTATUSWINDOW = @as(u32, 34);
pub const NI_FINALIZECONVERSIONRESULT = @as(u32, 20);
pub const ISC_SHOWUICANDIDATEWINDOW = @as(u32, 1);
pub const ISC_SHOWUICOMPOSITIONWINDOW = @as(u32, 2147483648);
pub const ISC_SHOWUIGUIDELINE = @as(u32, 1073741824);
pub const ISC_SHOWUIALLCANDIDATEWINDOW = @as(u32, 15);
pub const ISC_SHOWUIALL = @as(u32, 3221225487);
pub const MOD_LEFT = @as(u32, 32768);
pub const MOD_RIGHT = @as(u32, 16384);
pub const MOD_ON_KEYUP = @as(u32, 2048);
pub const MOD_IGNORE_ALL_MODIFIER = @as(u32, 1024);
pub const IME_CHOTKEY_IME_NONIME_TOGGLE = @as(u32, 16);
pub const IME_CHOTKEY_SHAPE_TOGGLE = @as(u32, 17);
pub const IME_CHOTKEY_SYMBOL_TOGGLE = @as(u32, 18);
pub const IME_JHOTKEY_CLOSE_OPEN = @as(u32, 48);
pub const IME_KHOTKEY_SHAPE_TOGGLE = @as(u32, 80);
pub const IME_KHOTKEY_HANJACONVERT = @as(u32, 81);
pub const IME_KHOTKEY_ENGLISH = @as(u32, 82);
pub const IME_THOTKEY_IME_NONIME_TOGGLE = @as(u32, 112);
pub const IME_THOTKEY_SHAPE_TOGGLE = @as(u32, 113);
pub const IME_THOTKEY_SYMBOL_TOGGLE = @as(u32, 114);
pub const IME_HOTKEY_DSWITCH_FIRST = @as(u32, 256);
pub const IME_HOTKEY_DSWITCH_LAST = @as(u32, 287);
pub const IME_HOTKEY_PRIVATE_FIRST = @as(u32, 512);
pub const IME_ITHOTKEY_RESEND_RESULTSTR = @as(u32, 512);
pub const IME_ITHOTKEY_PREVIOUS_COMPOSITION = @as(u32, 513);
pub const IME_ITHOTKEY_UISTYLE_TOGGLE = @as(u32, 514);
pub const IME_ITHOTKEY_RECONVERTSTRING = @as(u32, 515);
pub const IME_HOTKEY_PRIVATE_LAST = @as(u32, 543);
pub const GCS_COMPREADSTR = @as(u32, 1);
pub const GCS_COMPREADATTR = @as(u32, 2);
pub const GCS_COMPREADCLAUSE = @as(u32, 4);
pub const GCS_COMPSTR = @as(u32, 8);
pub const GCS_COMPATTR = @as(u32, 16);
pub const GCS_COMPCLAUSE = @as(u32, 32);
pub const GCS_CURSORPOS = @as(u32, 128);
pub const GCS_DELTASTART = @as(u32, 256);
pub const GCS_RESULTREADSTR = @as(u32, 512);
pub const GCS_RESULTREADCLAUSE = @as(u32, 1024);
pub const GCS_RESULTSTR = @as(u32, 2048);
pub const GCS_RESULTCLAUSE = @as(u32, 4096);
pub const CS_INSERTCHAR = @as(u32, 8192);
pub const CS_NOMOVECARET = @as(u32, 16384);
pub const IMEVER_0310 = @as(u32, 196618);
pub const IMEVER_0400 = @as(u32, 262144);
pub const IME_PROP_AT_CARET = @as(u32, 65536);
pub const IME_PROP_SPECIAL_UI = @as(u32, 131072);
pub const IME_PROP_CANDLIST_START_FROM_1 = @as(u32, 262144);
pub const IME_PROP_UNICODE = @as(u32, 524288);
pub const IME_PROP_COMPLETE_ON_UNSELECT = @as(u32, 1048576);
pub const UI_CAP_2700 = @as(u32, 1);
pub const UI_CAP_ROT90 = @as(u32, 2);
pub const UI_CAP_ROTANY = @as(u32, 4);
pub const SCS_CAP_COMPSTR = @as(u32, 1);
pub const SCS_CAP_MAKEREAD = @as(u32, 2);
pub const SCS_CAP_SETRECONVERTSTRING = @as(u32, 4);
pub const SELECT_CAP_CONVERSION = @as(u32, 1);
pub const SELECT_CAP_SENTENCE = @as(u32, 2);
pub const GL_LEVEL_NOGUIDELINE = @as(u32, 0);
pub const GL_LEVEL_FATAL = @as(u32, 1);
pub const GL_LEVEL_ERROR = @as(u32, 2);
pub const GL_LEVEL_WARNING = @as(u32, 3);
pub const GL_LEVEL_INFORMATION = @as(u32, 4);
pub const GL_ID_UNKNOWN = @as(u32, 0);
pub const GL_ID_NOMODULE = @as(u32, 1);
pub const GL_ID_NODICTIONARY = @as(u32, 16);
pub const GL_ID_CANNOTSAVE = @as(u32, 17);
pub const GL_ID_NOCONVERT = @as(u32, 32);
pub const GL_ID_TYPINGERROR = @as(u32, 33);
pub const GL_ID_TOOMANYSTROKE = @as(u32, 34);
pub const GL_ID_READINGCONFLICT = @as(u32, 35);
pub const GL_ID_INPUTREADING = @as(u32, 36);
pub const GL_ID_INPUTRADICAL = @as(u32, 37);
pub const GL_ID_INPUTCODE = @as(u32, 38);
pub const GL_ID_INPUTSYMBOL = @as(u32, 39);
pub const GL_ID_CHOOSECANDIDATE = @as(u32, 40);
pub const GL_ID_REVERSECONVERSION = @as(u32, 41);
pub const GL_ID_PRIVATE_FIRST = @as(u32, 32768);
pub const GL_ID_PRIVATE_LAST = @as(u32, 65535);
pub const ATTR_INPUT = @as(u32, 0);
pub const ATTR_TARGET_CONVERTED = @as(u32, 1);
pub const ATTR_CONVERTED = @as(u32, 2);
pub const ATTR_TARGET_NOTCONVERTED = @as(u32, 3);
pub const ATTR_INPUT_ERROR = @as(u32, 4);
pub const ATTR_FIXEDCONVERTED = @as(u32, 5);
pub const CFS_DEFAULT = @as(u32, 0);
pub const CFS_RECT = @as(u32, 1);
pub const CFS_POINT = @as(u32, 2);
pub const CFS_FORCE_POSITION = @as(u32, 32);
pub const CFS_CANDIDATEPOS = @as(u32, 64);
pub const CFS_EXCLUDE = @as(u32, 128);
pub const IME_CMODE_SOFTKBD = @as(u32, 128);
pub const IME_CMODE_NOCONVERSION = @as(u32, 256);
pub const IME_CMODE_EUDC = @as(u32, 512);
pub const IME_CMODE_SYMBOL = @as(u32, 1024);
pub const IME_CMODE_FIXED = @as(u32, 2048);
pub const IME_CMODE_RESERVED = @as(u32, 4026531840);
pub const IME_SMODE_NONE = @as(u32, 0);
pub const IME_SMODE_PLAURALCLAUSE = @as(u32, 1);
pub const IME_SMODE_SINGLECONVERT = @as(u32, 2);
pub const IME_SMODE_AUTOMATIC = @as(u32, 4);
pub const IME_SMODE_PHRASEPREDICT = @as(u32, 8);
pub const IME_SMODE_CONVERSATION = @as(u32, 16);
pub const IME_SMODE_RESERVED = @as(u32, 61440);
pub const IME_CAND_UNKNOWN = @as(u32, 0);
pub const IME_CAND_READ = @as(u32, 1);
pub const IME_CAND_CODE = @as(u32, 2);
pub const IME_CAND_MEANING = @as(u32, 3);
pub const IME_CAND_RADICAL = @as(u32, 4);
pub const IME_CAND_STROKE = @as(u32, 5);
pub const IMN_CLOSESTATUSWINDOW = @as(u32, 1);
pub const IMN_OPENSTATUSWINDOW = @as(u32, 2);
pub const IMN_CHANGECANDIDATE = @as(u32, 3);
pub const IMN_CLOSECANDIDATE = @as(u32, 4);
pub const IMN_OPENCANDIDATE = @as(u32, 5);
pub const IMN_SETCONVERSIONMODE = @as(u32, 6);
pub const IMN_SETSENTENCEMODE = @as(u32, 7);
pub const IMN_SETOPENSTATUS = @as(u32, 8);
pub const IMN_SETCANDIDATEPOS = @as(u32, 9);
pub const IMN_SETCOMPOSITIONFONT = @as(u32, 10);
pub const IMN_SETCOMPOSITIONWINDOW = @as(u32, 11);
pub const IMN_SETSTATUSWINDOWPOS = @as(u32, 12);
pub const IMN_GUIDELINE = @as(u32, 13);
pub const IMN_PRIVATE = @as(u32, 14);
pub const IMR_COMPOSITIONWINDOW = @as(u32, 1);
pub const IMR_CANDIDATEWINDOW = @as(u32, 2);
pub const IMR_COMPOSITIONFONT = @as(u32, 3);
pub const IMR_RECONVERTSTRING = @as(u32, 4);
pub const IMR_CONFIRMRECONVERTSTRING = @as(u32, 5);
pub const IMR_QUERYCHARPOSITION = @as(u32, 6);
pub const IMR_DOCUMENTFEED = @as(u32, 7);
pub const IMM_ERROR_NODATA = @as(i32, -1);
pub const IMM_ERROR_GENERAL = @as(i32, -2);
pub const IME_CONFIG_GENERAL = @as(u32, 1);
pub const IME_CONFIG_REGISTERWORD = @as(u32, 2);
pub const IME_CONFIG_SELECTDICTIONARY = @as(u32, 3);
pub const IME_ESC_QUERY_SUPPORT = @as(u32, 3);
pub const IME_ESC_RESERVED_FIRST = @as(u32, 4);
pub const IME_ESC_RESERVED_LAST = @as(u32, 2047);
pub const IME_ESC_PRIVATE_FIRST = @as(u32, 2048);
pub const IME_ESC_PRIVATE_LAST = @as(u32, 4095);
pub const IME_ESC_SEQUENCE_TO_INTERNAL = @as(u32, 4097);
pub const IME_ESC_GET_EUDC_DICTIONARY = @as(u32, 4099);
pub const IME_ESC_SET_EUDC_DICTIONARY = @as(u32, 4100);
pub const IME_ESC_MAX_KEY = @as(u32, 4101);
pub const IME_ESC_IME_NAME = @as(u32, 4102);
pub const IME_ESC_SYNC_HOTKEY = @as(u32, 4103);
pub const IME_ESC_HANJA_MODE = @as(u32, 4104);
pub const IME_ESC_AUTOMATA = @as(u32, 4105);
pub const IME_ESC_PRIVATE_HOTKEY = @as(u32, 4106);
pub const IME_ESC_GETHELPFILENAME = @as(u32, 4107);
pub const IME_REGWORD_STYLE_EUDC = @as(u32, 1);
pub const IME_REGWORD_STYLE_USER_FIRST = @as(u32, 2147483648);
pub const IME_REGWORD_STYLE_USER_LAST = @as(u32, 4294967295);
pub const IACE_CHILDREN = @as(u32, 1);
pub const IACE_DEFAULT = @as(u32, 16);
pub const IACE_IGNORENOCONTEXT = @as(u32, 32);
pub const IGIMIF_RIGHTMENU = @as(u32, 1);
pub const IGIMII_CMODE = @as(u32, 1);
pub const IGIMII_SMODE = @as(u32, 2);
pub const IGIMII_CONFIGURE = @as(u32, 4);
pub const IGIMII_TOOLS = @as(u32, 8);
pub const IGIMII_HELP = @as(u32, 16);
pub const IGIMII_OTHER = @as(u32, 32);
pub const IGIMII_INPUTTOOLS = @as(u32, 64);
pub const IMFT_RADIOCHECK = @as(u32, 1);
pub const IMFT_SEPARATOR = @as(u32, 2);
pub const IMFT_SUBMENU = @as(u32, 4);
pub const SOFTKEYBOARD_TYPE_T1 = @as(u32, 1);
pub const SOFTKEYBOARD_TYPE_C1 = @as(u32, 2);
pub const IMMGWL_IMC = @as(u32, 0);
pub const IMMGWLP_IMC = @as(u32, 0);
pub const IMC_SETCONVERSIONMODE = @as(u32, 2);
pub const IMC_SETSENTENCEMODE = @as(u32, 4);
pub const IMC_SETOPENSTATUS = @as(u32, 6);
pub const IMC_GETSOFTKBDFONT = @as(u32, 17);
pub const IMC_SETSOFTKBDFONT = @as(u32, 18);
pub const IMC_GETSOFTKBDPOS = @as(u32, 19);
pub const IMC_SETSOFTKBDPOS = @as(u32, 20);
pub const IMC_GETSOFTKBDSUBTYPE = @as(u32, 21);
pub const IMC_SETSOFTKBDSUBTYPE = @as(u32, 22);
pub const IMC_SETSOFTKBDDATA = @as(u32, 24);
pub const NI_CONTEXTUPDATED = @as(u32, 3);
pub const IME_SYSINFO_WINLOGON = @as(u32, 1);
pub const IME_SYSINFO_WOW16 = @as(u32, 2);
pub const INIT_STATUSWNDPOS = @as(u32, 1);
pub const INIT_CONVERSION = @as(u32, 2);
pub const INIT_SENTENCE = @as(u32, 4);
pub const INIT_LOGFONT = @as(u32, 8);
pub const INIT_COMPFORM = @as(u32, 16);
pub const INIT_SOFTKBDPOS = @as(u32, 32);
pub const IME_PROP_END_UNLOAD = @as(u32, 1);
pub const IME_PROP_KBD_CHAR_FIRST = @as(u32, 2);
pub const IME_PROP_IGNORE_UPKEYS = @as(u32, 4);
pub const IME_PROP_NEED_ALTKEY = @as(u32, 8);
pub const IME_PROP_NO_KEYS_ON_CLOSE = @as(u32, 16);
pub const IME_PROP_ACCEPT_WIDE_VKEY = @as(u32, 32);
pub const UI_CAP_SOFTKBD = @as(u32, 65536);
pub const IMN_SOFTKBDDESTROYED = @as(u32, 17);
pub const IME_UI_CLASS_NAME_SIZE = @as(u32, 16);
pub const IME_ESC_STRING_BUFFER_SIZE = @as(u32, 80);
pub const CATID_MSIME_IImePadApplet_VER7 = Guid.initString("4a0f8e31-c3ee-11d1-afef-00805f0c8b6d");
pub const CATID_MSIME_IImePadApplet_VER80 = Guid.initString("56f7a792-fef1-11d3-8463-00c04f7a06e5");
pub const CATID_MSIME_IImePadApplet_VER81 = Guid.initString("656520b0-bb88-11d4-84c0-00c04f7a06e5");
pub const CATID_MSIME_IImePadApplet900 = Guid.initString("faae51bf-5e5b-4a1d-8de1-17c1d9e1728d");
pub const CATID_MSIME_IImePadApplet1000 = Guid.initString("e081e1d6-2389-43cb-b66f-609f823d9f9c");
pub const CATID_MSIME_IImePadApplet1200 = Guid.initString("a47fb5fc-7d15-4223-a789-b781bf9ae667");
pub const CATID_MSIME_IImePadApplet = Guid.initString("7566cad1-4ec9-4478-9fe9-8ed766619edf");
pub const FEID_NONE = @as(u32, 0);
pub const FEID_CHINESE_TRADITIONAL = @as(u32, 1);
pub const FEID_CHINESE_SIMPLIFIED = @as(u32, 2);
pub const FEID_CHINESE_HONGKONG = @as(u32, 3);
pub const FEID_CHINESE_SINGAPORE = @as(u32, 4);
pub const FEID_JAPANESE = @as(u32, 5);
pub const FEID_KOREAN = @as(u32, 6);
pub const FEID_KOREAN_JOHAB = @as(u32, 7);
pub const INFOMASK_NONE = @as(u32, 0);
pub const INFOMASK_QUERY_CAND = @as(u32, 1);
pub const INFOMASK_APPLY_CAND = @as(u32, 2);
pub const INFOMASK_APPLY_CAND_EX = @as(u32, 4);
pub const INFOMASK_STRING_FIX = @as(u32, 65536);
pub const INFOMASK_HIDE_CAND = @as(u32, 131072);
pub const INFOMASK_BLOCK_CAND = @as(u32, 262144);
pub const IMEFAREASTINFO_TYPE_DEFAULT = @as(u32, 0);
pub const IMEFAREASTINFO_TYPE_READING = @as(u32, 1);
pub const IMEFAREASTINFO_TYPE_COMMENT = @as(u32, 2);
pub const IMEFAREASTINFO_TYPE_COSTTIME = @as(u32, 3);
pub const CHARINFO_APPLETID_MASK = @as(u32, 4278190080);
pub const CHARINFO_FEID_MASK = @as(u32, 15728640);
pub const CHARINFO_CHARID_MASK = @as(u32, 65535);
pub const MAX_APPLETTITLE = @as(u32, 64);
pub const MAX_FONTFACE = @as(u32, 32);
pub const IPACFG_NONE = @as(i32, 0);
pub const IPACFG_PROPERTY = @as(i32, 1);
pub const IPACFG_HELP = @as(i32, 2);
pub const IPACFG_TITLE = @as(i32, 65536);
pub const IPACFG_TITLEFONTFACE = @as(i32, 131072);
pub const IPACFG_CATEGORY = @as(i32, 262144);
pub const IPACFG_LANG = @as(i32, 16);
pub const IPACID_NONE = @as(u32, 0);
pub const IPACID_SOFTKEY = @as(u32, 1);
pub const IPACID_HANDWRITING = @as(u32, 2);
pub const IPACID_STROKESEARCH = @as(u32, 3);
pub const IPACID_RADICALSEARCH = @as(u32, 4);
pub const IPACID_SYMBOLSEARCH = @as(u32, 5);
pub const IPACID_VOICE = @as(u32, 6);
pub const IPACID_EPWING = @as(u32, 7);
pub const IPACID_OCR = @as(u32, 8);
pub const IPACID_CHARLIST = @as(u32, 9);
pub const IPACID_USER = @as(u32, 256);
pub const IMEPADREQ_FIRST = @as(u32, 4096);
pub const IMEPADREQ_INSERTSTRINGCANDIDATE = @as(u32, 4098);
pub const IMEPADREQ_INSERTITEMCANDIDATE = @as(u32, 4099);
pub const IMEPADREQ_SENDKEYCONTROL = @as(u32, 4101);
pub const IMEPADREQ_GETSELECTEDSTRING = @as(u32, 4103);
pub const IMEPADREQ_SETAPPLETDATA = @as(u32, 4105);
pub const IMEPADREQ_GETAPPLETDATA = @as(u32, 4106);
pub const IMEPADREQ_SETTITLEFONT = @as(u32, 4107);
pub const IMEPADREQ_GETCOMPOSITIONSTRINGID = @as(u32, 4109);
pub const IMEPADREQ_INSERTSTRINGCANDIDATEINFO = @as(u32, 4110);
pub const IMEPADREQ_CHANGESTRINGCANDIDATEINFO = @as(u32, 4111);
pub const IMEPADREQ_INSERTSTRINGINFO = @as(u32, 4114);
pub const IMEPADREQ_CHANGESTRINGINFO = @as(u32, 4115);
pub const IMEPADREQ_GETCURRENTUILANGID = @as(u32, 4120);
pub const IMEPADCTRL_CONVERTALL = @as(u32, 1);
pub const IMEPADCTRL_DETERMINALL = @as(u32, 2);
pub const IMEPADCTRL_DETERMINCHAR = @as(u32, 3);
pub const IMEPADCTRL_CLEARALL = @as(u32, 4);
pub const IMEPADCTRL_CARETSET = @as(u32, 5);
pub const IMEPADCTRL_CARETLEFT = @as(u32, 6);
pub const IMEPADCTRL_CARETRIGHT = @as(u32, 7);
pub const IMEPADCTRL_CARETTOP = @as(u32, 8);
pub const IMEPADCTRL_CARETBOTTOM = @as(u32, 9);
pub const IMEPADCTRL_CARETBACKSPACE = @as(u32, 10);
pub const IMEPADCTRL_CARETDELETE = @as(u32, 11);
pub const IMEPADCTRL_PHRASEDELETE = @as(u32, 12);
pub const IMEPADCTRL_INSERTSPACE = @as(u32, 13);
pub const IMEPADCTRL_INSERTFULLSPACE = @as(u32, 14);
pub const IMEPADCTRL_INSERTHALFSPACE = @as(u32, 15);
pub const IMEPADCTRL_ONIME = @as(u32, 16);
pub const IMEPADCTRL_OFFIME = @as(u32, 17);
pub const IMEPADCTRL_ONPRECONVERSION = @as(u32, 18);
pub const IMEPADCTRL_OFFPRECONVERSION = @as(u32, 19);
pub const IMEPADCTRL_PHONETICCANDIDATE = @as(u32, 20);
pub const IMEKEYCTRLMASK_ALT = @as(u32, 1);
pub const IMEKEYCTRLMASK_CTRL = @as(u32, 2);
pub const IMEKEYCTRLMASK_SHIFT = @as(u32, 4);
pub const IMEKEYCTRL_UP = @as(u32, 1);
pub const IMEKEYCTRL_DOWN = @as(u32, 0);
pub const IMEPN_FIRST = @as(u32, 256);
pub const IMEPN_ACTIVATE = @as(u32, 257);
pub const IMEPN_INACTIVATE = @as(u32, 258);
pub const IMEPN_SHOW = @as(u32, 260);
pub const IMEPN_HIDE = @as(u32, 261);
pub const IMEPN_SIZECHANGING = @as(u32, 262);
pub const IMEPN_SIZECHANGED = @as(u32, 263);
pub const IMEPN_CONFIG = @as(u32, 264);
pub const IMEPN_HELP = @as(u32, 265);
pub const IMEPN_QUERYCAND = @as(u32, 266);
pub const IMEPN_APPLYCAND = @as(u32, 267);
pub const IMEPN_APPLYCANDEX = @as(u32, 268);
pub const IMEPN_SETTINGCHANGED = @as(u32, 269);
pub const IMEPN_USER = @as(u32, 356);
pub const IPAWS_ENABLED = @as(i32, 1);
pub const IPAWS_SIZINGNOTIFY = @as(i32, 4);
pub const IPAWS_VERTICALFIXED = @as(i32, 256);
pub const IPAWS_HORIZONTALFIXED = @as(i32, 512);
pub const IPAWS_SIZEFIXED = @as(i32, 768);
pub const IPAWS_MAXWIDTHFIXED = @as(i32, 4096);
pub const IPAWS_MAXHEIGHTFIXED = @as(i32, 8192);
pub const IPAWS_MAXSIZEFIXED = @as(i32, 12288);
pub const IPAWS_MINWIDTHFIXED = @as(i32, 65536);
pub const IPAWS_MINHEIGHTFIXED = @as(i32, 131072);
pub const IPAWS_MINSIZEFIXED = @as(i32, 196608);
pub const CLSID_ImePlugInDictDictionaryList_CHS = Guid.initString("7bf0129b-5bef-4de4-9b0b-5edb66ac2fa6");
pub const CLSID_ImePlugInDictDictionaryList_JPN = Guid.initString("4fe2776b-b0f9-4396-b5fc-e9d4cf1ec195");
//--------------------------------------------------------------------------------
// Section: Types (80)
//--------------------------------------------------------------------------------
pub const SET_COMPOSITION_STRING_TYPE = enum(u32) {
SETSTR = 9,
CHANGEATTR = 18,
CHANGECLAUSE = 36,
SETRECONVERTSTRING = 65536,
QUERYRECONVERTSTRING = 131072,
};
pub const SCS_SETSTR = SET_COMPOSITION_STRING_TYPE.SETSTR;
pub const SCS_CHANGEATTR = SET_COMPOSITION_STRING_TYPE.CHANGEATTR;
pub const SCS_CHANGECLAUSE = SET_COMPOSITION_STRING_TYPE.CHANGECLAUSE;
pub const SCS_SETRECONVERTSTRING = SET_COMPOSITION_STRING_TYPE.SETRECONVERTSTRING;
pub const SCS_QUERYRECONVERTSTRING = SET_COMPOSITION_STRING_TYPE.QUERYRECONVERTSTRING;
pub const GET_GUIDE_LINE_TYPE = enum(u32) {
LEVEL = 1,
INDEX = 2,
STRING = 3,
PRIVATE = 4,
};
pub const GGL_LEVEL = GET_GUIDE_LINE_TYPE.LEVEL;
pub const GGL_INDEX = GET_GUIDE_LINE_TYPE.INDEX;
pub const GGL_STRING = GET_GUIDE_LINE_TYPE.STRING;
pub const GGL_PRIVATE = GET_GUIDE_LINE_TYPE.PRIVATE;
pub const NOTIFY_IME_INDEX = enum(u32) {
CANCEL = 4,
COMPLETE = 1,
CONVERT = 2,
REVERT = 3,
};
pub const CPS_CANCEL = NOTIFY_IME_INDEX.CANCEL;
pub const CPS_COMPLETE = NOTIFY_IME_INDEX.COMPLETE;
pub const CPS_CONVERT = NOTIFY_IME_INDEX.CONVERT;
pub const CPS_REVERT = NOTIFY_IME_INDEX.REVERT;
pub const NOTIFY_IME_ACTION = enum(u32) {
CHANGECANDIDATELIST = 19,
CLOSECANDIDATE = 17,
COMPOSITIONSTR = 21,
IMEMENUSELECTED = 24,
OPENCANDIDATE = 16,
SELECTCANDIDATESTR = 18,
SETCANDIDATE_PAGESIZE = 23,
SETCANDIDATE_PAGESTART = 22,
};
pub const NI_CHANGECANDIDATELIST = NOTIFY_IME_ACTION.CHANGECANDIDATELIST;
pub const NI_CLOSECANDIDATE = NOTIFY_IME_ACTION.CLOSECANDIDATE;
pub const NI_COMPOSITIONSTR = NOTIFY_IME_ACTION.COMPOSITIONSTR;
pub const NI_IMEMENUSELECTED = NOTIFY_IME_ACTION.IMEMENUSELECTED;
pub const NI_OPENCANDIDATE = NOTIFY_IME_ACTION.OPENCANDIDATE;
pub const NI_SELECTCANDIDATESTR = NOTIFY_IME_ACTION.SELECTCANDIDATESTR;
pub const NI_SETCANDIDATE_PAGESIZE = NOTIFY_IME_ACTION.SETCANDIDATE_PAGESIZE;
pub const NI_SETCANDIDATE_PAGESTART = NOTIFY_IME_ACTION.SETCANDIDATE_PAGESTART;
pub const GET_CONVERSION_LIST_FLAG = enum(u32) {
CONVERSION = 1,
REVERSECONVERSION = 2,
REVERSE_LENGTH = 3,
};
pub const GCL_CONVERSION = GET_CONVERSION_LIST_FLAG.CONVERSION;
pub const GCL_REVERSECONVERSION = GET_CONVERSION_LIST_FLAG.REVERSECONVERSION;
pub const GCL_REVERSE_LENGTH = GET_CONVERSION_LIST_FLAG.REVERSE_LENGTH;
pub const IME_PAD_REQUEST_FLAGS = enum(u32) {
INSERTSTRING = 4097,
SENDCONTROL = 4100,
SETAPPLETSIZE = 4104,
GETCOMPOSITIONSTRING = 4102,
GETCOMPOSITIONSTRINGINFO = 4108,
DELETESTRING = 4112,
CHANGESTRING = 4113,
GETAPPLHWND = 4116,
FORCEIMEPADWINDOWSHOW = 4117,
POSTMODALNOTIFY = 4118,
GETDEFAULTUILANGID = 4119,
GETAPPLETUISTYLE = 4121,
SETAPPLETUISTYLE = 4122,
ISAPPLETACTIVE = 4123,
ISIMEPADWINDOWVISIBLE = 4124,
SETAPPLETMINMAXSIZE = 4125,
GETCONVERSIONSTATUS = 4126,
GETVERSION = 4127,
GETCURRENTIMEINFO = 4128,
};
pub const IMEPADREQ_INSERTSTRING = IME_PAD_REQUEST_FLAGS.INSERTSTRING;
pub const IMEPADREQ_SENDCONTROL = IME_PAD_REQUEST_FLAGS.SENDCONTROL;
pub const IMEPADREQ_SETAPPLETSIZE = IME_PAD_REQUEST_FLAGS.SETAPPLETSIZE;
pub const IMEPADREQ_GETCOMPOSITIONSTRING = IME_PAD_REQUEST_FLAGS.GETCOMPOSITIONSTRING;
pub const IMEPADREQ_GETCOMPOSITIONSTRINGINFO = IME_PAD_REQUEST_FLAGS.GETCOMPOSITIONSTRINGINFO;
pub const IMEPADREQ_DELETESTRING = IME_PAD_REQUEST_FLAGS.DELETESTRING;
pub const IMEPADREQ_CHANGESTRING = IME_PAD_REQUEST_FLAGS.CHANGESTRING;
pub const IMEPADREQ_GETAPPLHWND = IME_PAD_REQUEST_FLAGS.GETAPPLHWND;
pub const IMEPADREQ_FORCEIMEPADWINDOWSHOW = IME_PAD_REQUEST_FLAGS.FORCEIMEPADWINDOWSHOW;
pub const IMEPADREQ_POSTMODALNOTIFY = IME_PAD_REQUEST_FLAGS.POSTMODALNOTIFY;
pub const IMEPADREQ_GETDEFAULTUILANGID = IME_PAD_REQUEST_FLAGS.GETDEFAULTUILANGID;
pub const IMEPADREQ_GETAPPLETUISTYLE = IME_PAD_REQUEST_FLAGS.GETAPPLETUISTYLE;
pub const IMEPADREQ_SETAPPLETUISTYLE = IME_PAD_REQUEST_FLAGS.SETAPPLETUISTYLE;
pub const IMEPADREQ_ISAPPLETACTIVE = IME_PAD_REQUEST_FLAGS.ISAPPLETACTIVE;
pub const IMEPADREQ_ISIMEPADWINDOWVISIBLE = IME_PAD_REQUEST_FLAGS.ISIMEPADWINDOWVISIBLE;
pub const IMEPADREQ_SETAPPLETMINMAXSIZE = IME_PAD_REQUEST_FLAGS.SETAPPLETMINMAXSIZE;
pub const IMEPADREQ_GETCONVERSIONSTATUS = IME_PAD_REQUEST_FLAGS.GETCONVERSIONSTATUS;
pub const IMEPADREQ_GETVERSION = IME_PAD_REQUEST_FLAGS.GETVERSION;
pub const IMEPADREQ_GETCURRENTIMEINFO = IME_PAD_REQUEST_FLAGS.GETCURRENTIMEINFO;
pub const COMPOSITIONFORM = extern struct {
dwStyle: u32,
ptCurrentPos: POINT,
rcArea: RECT,
};
pub const CANDIDATEFORM = extern struct {
dwIndex: u32,
dwStyle: u32,
ptCurrentPos: POINT,
rcArea: RECT,
};
pub const CANDIDATELIST = extern struct {
dwSize: u32,
dwStyle: u32,
dwCount: u32,
dwSelection: u32,
dwPageStart: u32,
dwPageSize: u32,
dwOffset: [1]u32,
};
pub const REGISTERWORDA = extern struct {
lpReading: ?PSTR,
lpWord: ?PSTR,
};
pub const REGISTERWORDW = extern struct {
lpReading: ?PWSTR,
lpWord: ?PWSTR,
};
pub const RECONVERTSTRING = extern struct {
dwSize: u32,
dwVersion: u32,
dwStrLen: u32,
dwStrOffset: u32,
dwCompStrLen: u32,
dwCompStrOffset: u32,
dwTargetStrLen: u32,
dwTargetStrOffset: u32,
};
pub const STYLEBUFA = extern struct {
dwStyle: u32,
szDescription: [32]CHAR,
};
pub const STYLEBUFW = extern struct {
dwStyle: u32,
szDescription: [32]u16,
};
pub const IMEMENUITEMINFOA = extern struct {
cbSize: u32,
fType: u32,
fState: u32,
wID: u32,
hbmpChecked: ?HBITMAP,
hbmpUnchecked: ?HBITMAP,
dwItemData: u32,
szString: [80]CHAR,
hbmpItem: ?HBITMAP,
};
pub const IMEMENUITEMINFOW = extern struct {
cbSize: u32,
fType: u32,
fState: u32,
wID: u32,
hbmpChecked: ?HBITMAP,
hbmpUnchecked: ?HBITMAP,
dwItemData: u32,
szString: [80]u16,
hbmpItem: ?HBITMAP,
};
pub const IMECHARPOSITION = extern struct {
dwSize: u32,
dwCharPos: u32,
pt: POINT,
cLineHeight: u32,
rcDocument: RECT,
};
pub const IMCENUMPROC = fn(
param0: ?HIMC,
param1: LPARAM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub const REGISTERWORDENUMPROCA = fn(
lpszReading: ?[*:0]const u8,
param1: u32,
lpszString: ?[*:0]const u8,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;
pub const REGISTERWORDENUMPROCW = fn(
lpszReading: ?[*:0]const u16,
param1: u32,
lpszString: ?[*:0]const u16,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) i32;
pub const IFEClassFactory = extern struct {
pub const VTable = extern struct {
base: IClassFactory.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IClassFactory.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
pub const IMEDLG = packed struct {
cbIMEDLG: i32,
hwnd: ?HWND,
lpwstrWord: ?PWSTR,
nTabId: i32,
};
const IID_IFECommon_Value = @import("../../zig.zig").Guid.initString("019f7151-e6db-11d0-83c3-00c04fddb82e");
pub const IID_IFECommon = &IID_IFECommon_Value;
pub const IFECommon = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
IsDefaultIME: fn(
self: *const IFECommon,
szName: [*:0]const u8,
cszName: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetDefaultIME: fn(
self: *const IFECommon,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InvokeWordRegDialog: fn(
self: *const IFECommon,
pimedlg: ?*IMEDLG,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InvokeDictToolDialog: fn(
self: *const IFECommon,
pimedlg: ?*IMEDLG,
) 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 IFECommon_IsDefaultIME(self: *const T, szName: [*:0]const u8, cszName: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFECommon.VTable, self.vtable).IsDefaultIME(@ptrCast(*const IFECommon, self), szName, cszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFECommon_SetDefaultIME(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IFECommon.VTable, self.vtable).SetDefaultIME(@ptrCast(*const IFECommon, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFECommon_InvokeWordRegDialog(self: *const T, pimedlg: ?*IMEDLG) callconv(.Inline) HRESULT {
return @ptrCast(*const IFECommon.VTable, self.vtable).InvokeWordRegDialog(@ptrCast(*const IFECommon, self), pimedlg);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFECommon_InvokeDictToolDialog(self: *const T, pimedlg: ?*IMEDLG) callconv(.Inline) HRESULT {
return @ptrCast(*const IFECommon.VTable, self.vtable).InvokeDictToolDialog(@ptrCast(*const IFECommon, self), pimedlg);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WDD = packed struct {
wDispPos: u16,
Anonymous1: packed union {
wReadPos: u16,
wCompPos: u16,
},
cchDisp: u16,
Anonymous2: packed union {
cchRead: u16,
cchComp: u16,
},
WDD_nReserve1: u32,
nPos: u16,
_bitfield: u16,
pReserved: ?*anyopaque,
};
pub const MORRSLT = packed struct {
dwSize: u32,
pwchOutput: ?PWSTR,
cchOutput: u16,
Anonymous1: packed union {
pwchRead: ?PWSTR,
pwchComp: ?PWSTR,
},
Anonymous2: packed union {
cchRead: u16,
cchComp: u16,
},
pchInputPos: ?*u16,
pchOutputIdxWDD: ?*u16,
Anonymous3: packed union {
pchReadIdxWDD: ?*u16,
pchCompIdxWDD: ?*u16,
},
paMonoRubyPos: ?*u16,
pWDD: ?*WDD,
cWDD: i32,
pPrivate: ?*anyopaque,
BLKBuff: [1]u16,
};
const IID_IFELanguage_Value = @import("../../zig.zig").Guid.initString("019f7152-e6db-11d0-83c3-00c04fddb82e");
pub const IID_IFELanguage = &IID_IFELanguage_Value;
pub const IFELanguage = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const IFELanguage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const IFELanguage,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetJMorphResult: fn(
self: *const IFELanguage,
dwRequest: u32,
dwCMode: u32,
cwchInput: i32,
pwchInput: ?[*:0]const u16,
pfCInfo: ?*u32,
ppResult: ?*?*MORRSLT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionModeCaps: fn(
self: *const IFELanguage,
pdwCaps: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPhonetic: fn(
self: *const IFELanguage,
string: ?BSTR,
start: i32,
length: i32,
phonetic: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversion: fn(
self: *const IFELanguage,
string: ?BSTR,
start: i32,
length: i32,
result: ?*?BSTR,
) 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 IFELanguage_Open(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).Open(@ptrCast(*const IFELanguage, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFELanguage_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).Close(@ptrCast(*const IFELanguage, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFELanguage_GetJMorphResult(self: *const T, dwRequest: u32, dwCMode: u32, cwchInput: i32, pwchInput: ?[*:0]const u16, pfCInfo: ?*u32, ppResult: ?*?*MORRSLT) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).GetJMorphResult(@ptrCast(*const IFELanguage, self), dwRequest, dwCMode, cwchInput, pwchInput, pfCInfo, ppResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFELanguage_GetConversionModeCaps(self: *const T, pdwCaps: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).GetConversionModeCaps(@ptrCast(*const IFELanguage, self), pdwCaps);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFELanguage_GetPhonetic(self: *const T, string: ?BSTR, start: i32, length: i32, phonetic: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).GetPhonetic(@ptrCast(*const IFELanguage, self), string, start, length, phonetic);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFELanguage_GetConversion(self: *const T, string: ?BSTR, start: i32, length: i32, result: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IFELanguage.VTable, self.vtable).GetConversion(@ptrCast(*const IFELanguage, self), string, start, length, result);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const IMEREG = enum(i32) {
HEAD = 0,
TAIL = 1,
DEL = 2,
};
pub const IFED_REG_HEAD = IMEREG.HEAD;
pub const IFED_REG_TAIL = IMEREG.TAIL;
pub const IFED_REG_DEL = IMEREG.DEL;
pub const IMEFMT = enum(i32) {
UNKNOWN = 0,
MSIME2_BIN_SYSTEM = 1,
MSIME2_BIN_USER = 2,
MSIME2_TEXT_USER = 3,
MSIME95_BIN_SYSTEM = 4,
MSIME95_BIN_USER = 5,
MSIME95_TEXT_USER = 6,
MSIME97_BIN_SYSTEM = 7,
MSIME97_BIN_USER = 8,
MSIME97_TEXT_USER = 9,
MSIME98_BIN_SYSTEM = 10,
MSIME98_BIN_USER = 11,
MSIME98_TEXT_USER = 12,
ACTIVE_DICT = 13,
ATOK9 = 14,
ATOK10 = 15,
NEC_AI_ = 16,
WX_II = 17,
WX_III = 18,
VJE_20 = 19,
MSIME98_SYSTEM_CE = 20,
MSIME_BIN_SYSTEM = 21,
MSIME_BIN_USER = 22,
MSIME_TEXT_USER = 23,
PIME2_BIN_USER = 24,
PIME2_BIN_SYSTEM = 25,
PIME2_BIN_STANDARD_SYSTEM = 26,
};
pub const IFED_UNKNOWN = IMEFMT.UNKNOWN;
pub const IFED_MSIME2_BIN_SYSTEM = IMEFMT.MSIME2_BIN_SYSTEM;
pub const IFED_MSIME2_BIN_USER = IMEFMT.MSIME2_BIN_USER;
pub const IFED_MSIME2_TEXT_USER = IMEFMT.MSIME2_TEXT_USER;
pub const IFED_MSIME95_BIN_SYSTEM = IMEFMT.MSIME95_BIN_SYSTEM;
pub const IFED_MSIME95_BIN_USER = IMEFMT.MSIME95_BIN_USER;
pub const IFED_MSIME95_TEXT_USER = IMEFMT.MSIME95_TEXT_USER;
pub const IFED_MSIME97_BIN_SYSTEM = IMEFMT.MSIME97_BIN_SYSTEM;
pub const IFED_MSIME97_BIN_USER = IMEFMT.MSIME97_BIN_USER;
pub const IFED_MSIME97_TEXT_USER = IMEFMT.MSIME97_TEXT_USER;
pub const IFED_MSIME98_BIN_SYSTEM = IMEFMT.MSIME98_BIN_SYSTEM;
pub const IFED_MSIME98_BIN_USER = IMEFMT.MSIME98_BIN_USER;
pub const IFED_MSIME98_TEXT_USER = IMEFMT.MSIME98_TEXT_USER;
pub const IFED_ACTIVE_DICT = IMEFMT.ACTIVE_DICT;
pub const IFED_ATOK9 = IMEFMT.ATOK9;
pub const IFED_ATOK10 = IMEFMT.ATOK10;
pub const IFED_NEC_AI_ = IMEFMT.NEC_AI_;
pub const IFED_WX_II = IMEFMT.WX_II;
pub const IFED_WX_III = IMEFMT.WX_III;
pub const IFED_VJE_20 = IMEFMT.VJE_20;
pub const IFED_MSIME98_SYSTEM_CE = IMEFMT.MSIME98_SYSTEM_CE;
pub const IFED_MSIME_BIN_SYSTEM = IMEFMT.MSIME_BIN_SYSTEM;
pub const IFED_MSIME_BIN_USER = IMEFMT.MSIME_BIN_USER;
pub const IFED_MSIME_TEXT_USER = IMEFMT.MSIME_TEXT_USER;
pub const IFED_PIME2_BIN_USER = IMEFMT.PIME2_BIN_USER;
pub const IFED_PIME2_BIN_SYSTEM = IMEFMT.PIME2_BIN_SYSTEM;
pub const IFED_PIME2_BIN_STANDARD_SYSTEM = IMEFMT.PIME2_BIN_STANDARD_SYSTEM;
pub const IMEUCT = enum(i32) {
NONE = 0,
STRING_SJIS = 1,
STRING_UNICODE = 2,
USER_DEFINED = 3,
MAX = 4,
};
pub const IFED_UCT_NONE = IMEUCT.NONE;
pub const IFED_UCT_STRING_SJIS = IMEUCT.STRING_SJIS;
pub const IFED_UCT_STRING_UNICODE = IMEUCT.STRING_UNICODE;
pub const IFED_UCT_USER_DEFINED = IMEUCT.USER_DEFINED;
pub const IFED_UCT_MAX = IMEUCT.MAX;
pub const IMEWRD = packed struct {
pwchReading: ?PWSTR,
pwchDisplay: ?PWSTR,
Anonymous: packed union {
ulPos: u32,
Anonymous: packed struct {
nPos1: u16,
nPos2: u16,
},
},
rgulAttrs: [2]u32,
cbComment: i32,
uct: IMEUCT,
pvComment: ?*anyopaque,
};
pub const IMESHF = packed struct {
cbShf: u16,
verDic: u16,
szTitle: [48]CHAR,
szDescription: [256]CHAR,
szCopyright: [128]CHAR,
};
pub const POSTBL = packed struct {
nPos: u16,
szName: ?*u8,
};
pub const IMEREL = enum(i32) {
NONE = 0,
NO = 1,
GA = 2,
WO = 3,
NI = 4,
DE = 5,
YORI = 6,
KARA = 7,
MADE = 8,
HE = 9,
TO = 10,
IDEOM = 11,
FUKU_YOUGEN = 12,
KEIYOU_YOUGEN = 13,
KEIDOU1_YOUGEN = 14,
KEIDOU2_YOUGEN = 15,
TAIGEN = 16,
YOUGEN = 17,
RENTAI_MEI = 18,
RENSOU = 19,
KEIYOU_TO_YOUGEN = 20,
KEIYOU_TARU_YOUGEN = 21,
UNKNOWN1 = 22,
UNKNOWN2 = 23,
ALL = 24,
};
pub const IFED_REL_NONE = IMEREL.NONE;
pub const IFED_REL_NO = IMEREL.NO;
pub const IFED_REL_GA = IMEREL.GA;
pub const IFED_REL_WO = IMEREL.WO;
pub const IFED_REL_NI = IMEREL.NI;
pub const IFED_REL_DE = IMEREL.DE;
pub const IFED_REL_YORI = IMEREL.YORI;
pub const IFED_REL_KARA = IMEREL.KARA;
pub const IFED_REL_MADE = IMEREL.MADE;
pub const IFED_REL_HE = IMEREL.HE;
pub const IFED_REL_TO = IMEREL.TO;
pub const IFED_REL_IDEOM = IMEREL.IDEOM;
pub const IFED_REL_FUKU_YOUGEN = IMEREL.FUKU_YOUGEN;
pub const IFED_REL_KEIYOU_YOUGEN = IMEREL.KEIYOU_YOUGEN;
pub const IFED_REL_KEIDOU1_YOUGEN = IMEREL.KEIDOU1_YOUGEN;
pub const IFED_REL_KEIDOU2_YOUGEN = IMEREL.KEIDOU2_YOUGEN;
pub const IFED_REL_TAIGEN = IMEREL.TAIGEN;
pub const IFED_REL_YOUGEN = IMEREL.YOUGEN;
pub const IFED_REL_RENTAI_MEI = IMEREL.RENTAI_MEI;
pub const IFED_REL_RENSOU = IMEREL.RENSOU;
pub const IFED_REL_KEIYOU_TO_YOUGEN = IMEREL.KEIYOU_TO_YOUGEN;
pub const IFED_REL_KEIYOU_TARU_YOUGEN = IMEREL.KEIYOU_TARU_YOUGEN;
pub const IFED_REL_UNKNOWN1 = IMEREL.UNKNOWN1;
pub const IFED_REL_UNKNOWN2 = IMEREL.UNKNOWN2;
pub const IFED_REL_ALL = IMEREL.ALL;
pub const IMEDP = packed struct {
wrdModifier: IMEWRD,
wrdModifiee: IMEWRD,
relID: IMEREL,
};
pub const PFNLOG = fn(
param0: ?*IMEDP,
param1: HRESULT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
const IID_IFEDictionary_Value = @import("../../zig.zig").Guid.initString("019f7153-e6db-11d0-83c3-00c04fddb82e");
pub const IID_IFEDictionary = &IID_IFEDictionary_Value;
pub const IFEDictionary = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const IFEDictionary,
pchDictPath: ?*[260]u8,
pshf: ?*IMESHF,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Close: fn(
self: *const IFEDictionary,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetHeader: fn(
self: *const IFEDictionary,
pchDictPath: ?*[260]u8,
pshf: ?*IMESHF,
pjfmt: ?*IMEFMT,
pulType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DisplayProperty: fn(
self: *const IFEDictionary,
hwnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPosTable: fn(
self: *const IFEDictionary,
prgPosTbl: ?*?*POSTBL,
pcPosTbl: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetWords: fn(
self: *const IFEDictionary,
pwchFirst: ?[*:0]const u16,
pwchLast: ?[*:0]const u16,
pwchDisplay: ?[*:0]const u16,
ulPos: u32,
ulSelect: u32,
ulWordSrc: u32,
pchBuffer: ?*u8,
cbBuffer: u32,
pcWrd: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NextWords: fn(
self: *const IFEDictionary,
pchBuffer: ?*u8,
cbBuffer: u32,
pcWrd: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Create: fn(
self: *const IFEDictionary,
pchDictPath: ?[*:0]const u8,
pshf: ?*IMESHF,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetHeader: fn(
self: *const IFEDictionary,
pshf: ?*IMESHF,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExistWord: fn(
self: *const IFEDictionary,
pwrd: ?*IMEWRD,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExistDependency: fn(
self: *const IFEDictionary,
pdp: ?*IMEDP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWord: fn(
self: *const IFEDictionary,
reg: IMEREG,
pwrd: ?*IMEWRD,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterDependency: fn(
self: *const IFEDictionary,
reg: IMEREG,
pdp: ?*IMEDP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDependencies: fn(
self: *const IFEDictionary,
pwchKakariReading: ?[*:0]const u16,
pwchKakariDisplay: ?[*:0]const u16,
ulKakariPos: u32,
pwchUkeReading: ?[*:0]const u16,
pwchUkeDisplay: ?[*:0]const u16,
ulUkePos: u32,
jrel: IMEREL,
ulWordSrc: u32,
pchBuffer: ?*u8,
cbBuffer: u32,
pcdp: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NextDependencies: fn(
self: *const IFEDictionary,
pchBuffer: ?*u8,
cbBuffer: u32,
pcDp: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConvertFromOldMSIME: fn(
self: *const IFEDictionary,
pchDic: ?[*:0]const u8,
pfnLog: ?PFNLOG,
reg: IMEREG,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConvertFromUserToSys: fn(
self: *const IFEDictionary,
) 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 IFEDictionary_Open(self: *const T, pchDictPath: ?*[260]u8, pshf: ?*IMESHF) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).Open(@ptrCast(*const IFEDictionary, self), pchDictPath, pshf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_Close(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).Close(@ptrCast(*const IFEDictionary, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_GetHeader(self: *const T, pchDictPath: ?*[260]u8, pshf: ?*IMESHF, pjfmt: ?*IMEFMT, pulType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).GetHeader(@ptrCast(*const IFEDictionary, self), pchDictPath, pshf, pjfmt, pulType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_DisplayProperty(self: *const T, hwnd: ?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).DisplayProperty(@ptrCast(*const IFEDictionary, self), hwnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_GetPosTable(self: *const T, prgPosTbl: ?*?*POSTBL, pcPosTbl: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).GetPosTable(@ptrCast(*const IFEDictionary, self), prgPosTbl, pcPosTbl);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_GetWords(self: *const T, pwchFirst: ?[*:0]const u16, pwchLast: ?[*:0]const u16, pwchDisplay: ?[*:0]const u16, ulPos: u32, ulSelect: u32, ulWordSrc: u32, pchBuffer: ?*u8, cbBuffer: u32, pcWrd: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).GetWords(@ptrCast(*const IFEDictionary, self), pwchFirst, pwchLast, pwchDisplay, ulPos, ulSelect, ulWordSrc, pchBuffer, cbBuffer, pcWrd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_NextWords(self: *const T, pchBuffer: ?*u8, cbBuffer: u32, pcWrd: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).NextWords(@ptrCast(*const IFEDictionary, self), pchBuffer, cbBuffer, pcWrd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_Create(self: *const T, pchDictPath: ?[*:0]const u8, pshf: ?*IMESHF) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).Create(@ptrCast(*const IFEDictionary, self), pchDictPath, pshf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_SetHeader(self: *const T, pshf: ?*IMESHF) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).SetHeader(@ptrCast(*const IFEDictionary, self), pshf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_ExistWord(self: *const T, pwrd: ?*IMEWRD) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).ExistWord(@ptrCast(*const IFEDictionary, self), pwrd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_ExistDependency(self: *const T, pdp: ?*IMEDP) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).ExistDependency(@ptrCast(*const IFEDictionary, self), pdp);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_RegisterWord(self: *const T, reg: IMEREG, pwrd: ?*IMEWRD) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).RegisterWord(@ptrCast(*const IFEDictionary, self), reg, pwrd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_RegisterDependency(self: *const T, reg: IMEREG, pdp: ?*IMEDP) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).RegisterDependency(@ptrCast(*const IFEDictionary, self), reg, pdp);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_GetDependencies(self: *const T, pwchKakariReading: ?[*:0]const u16, pwchKakariDisplay: ?[*:0]const u16, ulKakariPos: u32, pwchUkeReading: ?[*:0]const u16, pwchUkeDisplay: ?[*:0]const u16, ulUkePos: u32, jrel: IMEREL, ulWordSrc: u32, pchBuffer: ?*u8, cbBuffer: u32, pcdp: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).GetDependencies(@ptrCast(*const IFEDictionary, self), pwchKakariReading, pwchKakariDisplay, ulKakariPos, pwchUkeReading, pwchUkeDisplay, ulUkePos, jrel, ulWordSrc, pchBuffer, cbBuffer, pcdp);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_NextDependencies(self: *const T, pchBuffer: ?*u8, cbBuffer: u32, pcDp: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).NextDependencies(@ptrCast(*const IFEDictionary, self), pchBuffer, cbBuffer, pcDp);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_ConvertFromOldMSIME(self: *const T, pchDic: ?[*:0]const u8, pfnLog: ?PFNLOG, reg: IMEREG) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).ConvertFromOldMSIME(@ptrCast(*const IFEDictionary, self), pchDic, pfnLog, reg);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IFEDictionary_ConvertFromUserToSys(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IFEDictionary.VTable, self.vtable).ConvertFromUserToSys(@ptrCast(*const IFEDictionary, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const IMEKMSINIT = packed struct {
cbSize: i32,
hWnd: ?HWND,
};
pub const IMEKMSKEY = packed struct {
dwStatus: u32,
dwCompStatus: u32,
dwVKEY: u32,
Anonymous1: packed union {
dwControl: u32,
dwNotUsed: u32,
},
Anonymous2: packed union {
pwszDscr: [31]u16,
pwszNoUse: [31]u16,
},
};
pub const IMEKMS = packed struct {
cbSize: i32,
hIMC: ?HIMC,
cKeyList: u32,
pKeyList: ?*IMEKMSKEY,
};
pub const IMEKMSNTFY = packed struct {
cbSize: i32,
hIMC: ?HIMC,
fSelect: BOOL,
};
pub const IMEKMSKMP = packed struct {
cbSize: i32,
hIMC: ?HIMC,
idLang: u16,
wVKStart: u16,
wVKEnd: u16,
cKeyList: i32,
pKeyList: ?*IMEKMSKEY,
};
pub const IMEKMSINVK = packed struct {
cbSize: i32,
hIMC: ?HIMC,
dwControl: u32,
};
pub const IMEKMSFUNCDESC = packed struct {
cbSize: i32,
idLang: u16,
dwControl: u32,
pwszDescription: [128]u16,
};
pub const fpCreateIFECommonInstanceType = fn(
ppvObj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const fpCreateIFELanguageInstanceType = fn(
clsid: ?*const Guid,
ppvObj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const fpCreateIFEDictionaryInstanceType = fn(
ppvObj: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;
pub const COMPOSITIONSTRING = extern struct {
dwSize: u32,
dwCompReadAttrLen: u32,
dwCompReadAttrOffset: u32,
dwCompReadClauseLen: u32,
dwCompReadClauseOffset: u32,
dwCompReadStrLen: u32,
dwCompReadStrOffset: u32,
dwCompAttrLen: u32,
dwCompAttrOffset: u32,
dwCompClauseLen: u32,
dwCompClauseOffset: u32,
dwCompStrLen: u32,
dwCompStrOffset: u32,
dwCursorPos: u32,
dwDeltaStart: u32,
dwResultReadClauseLen: u32,
dwResultReadClauseOffset: u32,
dwResultReadStrLen: u32,
dwResultReadStrOffset: u32,
dwResultClauseLen: u32,
dwResultClauseOffset: u32,
dwResultStrLen: u32,
dwResultStrOffset: u32,
dwPrivateSize: u32,
dwPrivateOffset: u32,
};
pub const GUIDELINE = extern struct {
dwSize: u32,
dwLevel: u32,
dwIndex: u32,
dwStrLen: u32,
dwStrOffset: u32,
dwPrivateSize: u32,
dwPrivateOffset: u32,
};
pub const TRANSMSG = extern struct {
message: u32,
wParam: WPARAM,
lParam: LPARAM,
};
pub const TRANSMSGLIST = extern struct {
uMsgCount: u32,
TransMsg: [1]TRANSMSG,
};
pub const CANDIDATEINFO = extern struct {
dwSize: u32,
dwCount: u32,
dwOffset: [32]u32,
dwPrivateSize: u32,
dwPrivateOffset: u32,
};
pub const INPUTCONTEXT = extern struct {
hWnd: ?HWND,
fOpen: BOOL,
ptStatusWndPos: POINT,
ptSoftKbdPos: POINT,
fdwConversion: u32,
fdwSentence: u32,
lfFont: extern union {
A: LOGFONTA,
W: LOGFONTW,
},
cfCompForm: COMPOSITIONFORM,
cfCandForm: [4]CANDIDATEFORM,
hCompStr: ?HIMCC,
hCandInfo: ?HIMCC,
hGuideLine: ?HIMCC,
hPrivate: ?HIMCC,
dwNumMsgBuf: u32,
hMsgBuf: ?HIMCC,
fdwInit: u32,
dwReserve: [3]u32,
};
pub const IMEINFO = extern struct {
dwPrivateDataSize: u32,
fdwProperty: u32,
fdwConversionCaps: u32,
fdwSentenceCaps: u32,
fdwUICaps: u32,
fdwSCSCaps: u32,
fdwSelectCaps: u32,
};
pub const SOFTKBDDATA = extern struct {
uCount: u32,
wCode: [256]u16,
};
pub const APPLETIDLIST = extern struct {
count: i32,
pIIDList: ?*Guid,
};
pub const IMESTRINGCANDIDATE = extern struct {
uCount: u32,
lpwstr: [1]?PWSTR,
};
pub const IMEITEM = extern struct {
cbSize: i32,
iType: i32,
lpItemData: ?*anyopaque,
};
pub const IMEITEMCANDIDATE = extern struct {
uCount: u32,
imeItem: [1]IMEITEM,
};
pub const tabIMESTRINGINFO = extern struct {
dwFarEastId: u32,
lpwstr: ?PWSTR,
};
pub const tabIMEFAREASTINFO = extern struct {
dwSize: u32,
dwType: u32,
dwData: [1]u32,
};
pub const IMESTRINGCANDIDATEINFO = extern struct {
dwFarEastId: u32,
lpFarEastInfo: ?*tabIMEFAREASTINFO,
fInfoMask: u32,
iSelIndex: i32,
uCount: u32,
lpwstr: [1]?PWSTR,
};
pub const IMECOMPOSITIONSTRINGINFO = extern struct {
iCompStrLen: i32,
iCaretPos: i32,
iEditStart: i32,
iEditLen: i32,
iTargetStart: i32,
iTargetLen: i32,
};
pub const IMECHARINFO = extern struct {
wch: u16,
dwCharInfo: u32,
};
pub const IMEAPPLETCFG = extern struct {
dwConfig: u32,
wchTitle: [64]u16,
wchTitleFontFace: [32]u16,
dwCharSet: u32,
iCategory: i32,
hIcon: ?HICON,
langID: u16,
dummy: u16,
lReserved1: LPARAM,
};
pub const IMEAPPLETUI = extern struct {
hwnd: ?HWND,
dwStyle: u32,
width: i32,
height: i32,
minWidth: i32,
minHeight: i32,
maxWidth: i32,
maxHeight: i32,
lReserved1: LPARAM,
lReserved2: LPARAM,
};
pub const APPLYCANDEXPARAM = extern struct {
dwSize: u32,
lpwstrDisplay: ?PWSTR,
lpwstrReading: ?PWSTR,
dwReserved: u32,
};
const IID_IImeSpecifyApplets_Value = @import("../../zig.zig").Guid.initString("5d8e643c-c3a9-11d1-afef-00805f0c8b6d");
pub const IID_IImeSpecifyApplets = &IID_IImeSpecifyApplets_Value;
pub const IImeSpecifyApplets = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetAppletIIDList: fn(
self: *const IImeSpecifyApplets,
refiid: ?*const Guid,
lpIIDList: ?*APPLETIDLIST,
) 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 IImeSpecifyApplets_GetAppletIIDList(self: *const T, refiid: ?*const Guid, lpIIDList: ?*APPLETIDLIST) callconv(.Inline) HRESULT {
return @ptrCast(*const IImeSpecifyApplets.VTable, self.vtable).GetAppletIIDList(@ptrCast(*const IImeSpecifyApplets, self), refiid, lpIIDList);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IImePadApplet_Value = @import("../../zig.zig").Guid.initString("5d8e643b-c3a9-11d1-afef-00805f0c8b6d");
pub const IID_IImePadApplet = &IID_IImePadApplet_Value;
pub const IImePadApplet = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const IImePadApplet,
lpIImePad: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Terminate: fn(
self: *const IImePadApplet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAppletConfig: fn(
self: *const IImePadApplet,
lpAppletCfg: ?*IMEAPPLETCFG,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateUI: fn(
self: *const IImePadApplet,
hwndParent: ?HWND,
lpImeAppletUI: ?*IMEAPPLETUI,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Notify: fn(
self: *const IImePadApplet,
lpImePad: ?*IUnknown,
notify: i32,
wParam: WPARAM,
lParam: LPARAM,
) 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 IImePadApplet_Initialize(self: *const T, lpIImePad: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePadApplet.VTable, self.vtable).Initialize(@ptrCast(*const IImePadApplet, self), lpIImePad);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IImePadApplet_Terminate(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePadApplet.VTable, self.vtable).Terminate(@ptrCast(*const IImePadApplet, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IImePadApplet_GetAppletConfig(self: *const T, lpAppletCfg: ?*IMEAPPLETCFG) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePadApplet.VTable, self.vtable).GetAppletConfig(@ptrCast(*const IImePadApplet, self), lpAppletCfg);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IImePadApplet_CreateUI(self: *const T, hwndParent: ?HWND, lpImeAppletUI: ?*IMEAPPLETUI) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePadApplet.VTable, self.vtable).CreateUI(@ptrCast(*const IImePadApplet, self), hwndParent, lpImeAppletUI);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IImePadApplet_Notify(self: *const T, lpImePad: ?*IUnknown, notify: i32, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePadApplet.VTable, self.vtable).Notify(@ptrCast(*const IImePadApplet, self), lpImePad, notify, wParam, lParam);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IImePad_Value = @import("../../zig.zig").Guid.initString("5d8e643a-c3a9-11d1-afef-00805f0c8b6d");
pub const IID_IImePad = &IID_IImePad_Value;
pub const IImePad = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Request: fn(
self: *const IImePad,
pIImePadApplet: ?*IImePadApplet,
reqId: IME_PAD_REQUEST_FLAGS,
wParam: WPARAM,
lParam: LPARAM,
) 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 IImePad_Request(self: *const T, pIImePadApplet: ?*IImePadApplet, reqId: IME_PAD_REQUEST_FLAGS, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePad.VTable, self.vtable).Request(@ptrCast(*const IImePad, self), pIImePadApplet, reqId, wParam, lParam);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows8.0'
const IID_IImePlugInDictDictionaryList_Value = @import("../../zig.zig").Guid.initString("98752974-b0a6-489b-8f6f-bff3769c8eeb");
pub const IID_IImePlugInDictDictionaryList = &IID_IImePlugInDictDictionaryList_Value;
pub const IImePlugInDictDictionaryList = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetDictionariesInUse: fn(
self: *const IImePlugInDictDictionaryList,
prgDictionaryGUID: ?*?*SAFEARRAY,
prgDateCreated: ?*?*SAFEARRAY,
prgfEncrypted: ?*?*SAFEARRAY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteDictionary: fn(
self: *const IImePlugInDictDictionaryList,
bstrDictionaryGUID: ?BSTR,
) 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 IImePlugInDictDictionaryList_GetDictionariesInUse(self: *const T, prgDictionaryGUID: ?*?*SAFEARRAY, prgDateCreated: ?*?*SAFEARRAY, prgfEncrypted: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePlugInDictDictionaryList.VTable, self.vtable).GetDictionariesInUse(@ptrCast(*const IImePlugInDictDictionaryList, self), prgDictionaryGUID, prgDateCreated, prgfEncrypted);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IImePlugInDictDictionaryList_DeleteDictionary(self: *const T, bstrDictionaryGUID: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IImePlugInDictDictionaryList.VTable, self.vtable).DeleteDictionary(@ptrCast(*const IImePlugInDictDictionaryList, self), bstrDictionaryGUID);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_CActiveIMM_Value = @import("../../zig.zig").Guid.initString("4955dd33-b159-11d0-8fcf-00aa006bcc59");
pub const CLSID_CActiveIMM = &CLSID_CActiveIMM_Value;
const IID_IEnumRegisterWordA_Value = @import("../../zig.zig").Guid.initString("08c03412-f96b-11d0-a475-00aa006bcc59");
pub const IID_IEnumRegisterWordA = &IID_IEnumRegisterWordA_Value;
pub const IEnumRegisterWordA = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Clone: fn(
self: *const IEnumRegisterWordA,
ppEnum: ?*?*IEnumRegisterWordA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IEnumRegisterWordA,
ulCount: u32,
rgRegisterWord: ?*REGISTERWORDA,
pcFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IEnumRegisterWordA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IEnumRegisterWordA,
ulCount: 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 IEnumRegisterWordA_Clone(self: *const T, ppEnum: ?*?*IEnumRegisterWordA) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordA.VTable, self.vtable).Clone(@ptrCast(*const IEnumRegisterWordA, self), ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordA_Next(self: *const T, ulCount: u32, rgRegisterWord: ?*REGISTERWORDA, pcFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordA.VTable, self.vtable).Next(@ptrCast(*const IEnumRegisterWordA, self), ulCount, rgRegisterWord, pcFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordA_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordA.VTable, self.vtable).Reset(@ptrCast(*const IEnumRegisterWordA, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordA_Skip(self: *const T, ulCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordA.VTable, self.vtable).Skip(@ptrCast(*const IEnumRegisterWordA, self), ulCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IEnumRegisterWordW_Value = @import("../../zig.zig").Guid.initString("4955dd31-b159-11d0-8fcf-00aa006bcc59");
pub const IID_IEnumRegisterWordW = &IID_IEnumRegisterWordW_Value;
pub const IEnumRegisterWordW = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Clone: fn(
self: *const IEnumRegisterWordW,
ppEnum: ?*?*IEnumRegisterWordW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IEnumRegisterWordW,
ulCount: u32,
rgRegisterWord: ?*REGISTERWORDW,
pcFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IEnumRegisterWordW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IEnumRegisterWordW,
ulCount: 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 IEnumRegisterWordW_Clone(self: *const T, ppEnum: ?*?*IEnumRegisterWordW) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordW.VTable, self.vtable).Clone(@ptrCast(*const IEnumRegisterWordW, self), ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordW_Next(self: *const T, ulCount: u32, rgRegisterWord: ?*REGISTERWORDW, pcFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordW.VTable, self.vtable).Next(@ptrCast(*const IEnumRegisterWordW, self), ulCount, rgRegisterWord, pcFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordW_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordW.VTable, self.vtable).Reset(@ptrCast(*const IEnumRegisterWordW, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumRegisterWordW_Skip(self: *const T, ulCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumRegisterWordW.VTable, self.vtable).Skip(@ptrCast(*const IEnumRegisterWordW, self), ulCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IEnumInputContext_Value = @import("../../zig.zig").Guid.initString("09b5eab0-f997-11d1-93d4-0060b067b86e");
pub const IID_IEnumInputContext = &IID_IEnumInputContext_Value;
pub const IEnumInputContext = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Clone: fn(
self: *const IEnumInputContext,
ppEnum: ?*?*IEnumInputContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IEnumInputContext,
ulCount: u32,
rgInputContext: ?*?HIMC,
pcFetched: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Reset: fn(
self: *const IEnumInputContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IEnumInputContext,
ulCount: 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 IEnumInputContext_Clone(self: *const T, ppEnum: ?*?*IEnumInputContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumInputContext.VTable, self.vtable).Clone(@ptrCast(*const IEnumInputContext, self), ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumInputContext_Next(self: *const T, ulCount: u32, rgInputContext: ?*?HIMC, pcFetched: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumInputContext.VTable, self.vtable).Next(@ptrCast(*const IEnumInputContext, self), ulCount, rgInputContext, pcFetched);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumInputContext_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumInputContext.VTable, self.vtable).Reset(@ptrCast(*const IEnumInputContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumInputContext_Skip(self: *const T, ulCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumInputContext.VTable, self.vtable).Skip(@ptrCast(*const IEnumInputContext, self), ulCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIMMRegistrar_Value = @import("../../zig.zig").Guid.initString("b3458082-bd00-11d1-939b-0060b067b86e");
pub const IID_IActiveIMMRegistrar = &IID_IActiveIMMRegistrar_Value;
pub const IActiveIMMRegistrar = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
RegisterIME: fn(
self: *const IActiveIMMRegistrar,
rclsid: ?*const Guid,
lgid: u16,
pszIconFile: ?[*:0]const u16,
pszDesc: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterIME: fn(
self: *const IActiveIMMRegistrar,
rclsid: ?*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 IActiveIMMRegistrar_RegisterIME(self: *const T, rclsid: ?*const Guid, lgid: u16, pszIconFile: ?[*:0]const u16, pszDesc: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMRegistrar.VTable, self.vtable).RegisterIME(@ptrCast(*const IActiveIMMRegistrar, self), rclsid, lgid, pszIconFile, pszDesc);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMRegistrar_UnregisterIME(self: *const T, rclsid: ?*const Guid) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMRegistrar.VTable, self.vtable).UnregisterIME(@ptrCast(*const IActiveIMMRegistrar, self), rclsid);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIMMMessagePumpOwner_Value = @import("../../zig.zig").Guid.initString("b5cf2cfa-8aeb-11d1-9364-0060b067b86e");
pub const IID_IActiveIMMMessagePumpOwner = &IID_IActiveIMMMessagePumpOwner_Value;
pub const IActiveIMMMessagePumpOwner = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Start: fn(
self: *const IActiveIMMMessagePumpOwner,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
End: fn(
self: *const IActiveIMMMessagePumpOwner,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnTranslateMessage: fn(
self: *const IActiveIMMMessagePumpOwner,
pMsg: ?*const MSG,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Pause: fn(
self: *const IActiveIMMMessagePumpOwner,
pdwCookie: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Resume: fn(
self: *const IActiveIMMMessagePumpOwner,
dwCookie: 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 IActiveIMMMessagePumpOwner_Start(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMMessagePumpOwner.VTable, self.vtable).Start(@ptrCast(*const IActiveIMMMessagePumpOwner, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMMessagePumpOwner_End(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMMessagePumpOwner.VTable, self.vtable).End(@ptrCast(*const IActiveIMMMessagePumpOwner, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMMessagePumpOwner_OnTranslateMessage(self: *const T, pMsg: ?*const MSG) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMMessagePumpOwner.VTable, self.vtable).OnTranslateMessage(@ptrCast(*const IActiveIMMMessagePumpOwner, self), pMsg);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMMessagePumpOwner_Pause(self: *const T, pdwCookie: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMMessagePumpOwner.VTable, self.vtable).Pause(@ptrCast(*const IActiveIMMMessagePumpOwner, self), pdwCookie);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMMessagePumpOwner_Resume(self: *const T, dwCookie: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMMessagePumpOwner.VTable, self.vtable).Resume(@ptrCast(*const IActiveIMMMessagePumpOwner, self), dwCookie);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIMMApp_Value = @import("../../zig.zig").Guid.initString("08c0e040-62d1-11d1-9326-0060b067b86e");
pub const IID_IActiveIMMApp = &IID_IActiveIMMApp_Value;
pub const IActiveIMMApp = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AssociateContext: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
hIME: ?HIMC,
phPrev: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConfigureIMEA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hWnd: ?HWND,
dwMode: u32,
pData: ?*REGISTERWORDA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConfigureIMEW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hWnd: ?HWND,
dwMode: u32,
pData: ?*REGISTERWORDW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateContext: fn(
self: *const IActiveIMMApp,
phIMC: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DestroyContext: fn(
self: *const IActiveIMMApp,
hIME: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumRegisterWordA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szRegister: ?PSTR,
pData: ?*anyopaque,
pEnum: ?*?*IEnumRegisterWordA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumRegisterWordW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szRegister: ?PWSTR,
pData: ?*anyopaque,
pEnum: ?*?*IEnumRegisterWordW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EscapeA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hIMC: ?HIMC,
uEscape: u32,
pData: ?*anyopaque,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EscapeW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hIMC: ?HIMC,
uEscape: u32,
pData: ?*anyopaque,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
uBufLen: u32,
pCandList: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
uBufLen: u32,
pCandList: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListCountA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pdwListSize: ?*u32,
pdwBufLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListCountW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pdwListSize: ?*u32,
pdwBufLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateWindow: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
pCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionFontA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
plf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionFontW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
plf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionStringA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
plCopied: ?*i32,
pBuf: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionStringW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
plCopied: ?*i32,
pBuf: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionWindow: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetContext: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
phIMC: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionListA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hIMC: ?HIMC,
pSrc: ?PSTR,
uBufLen: u32,
uFlag: u32,
pDst: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionListW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
hIMC: ?HIMC,
pSrc: ?PWSTR,
uBufLen: u32,
uFlag: u32,
pDst: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionStatus: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pfdwConversion: ?*u32,
pfdwSentence: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDefaultIMEWnd: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
phDefWnd: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDescriptionA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
uBufLen: u32,
szDescription: ?PSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDescriptionW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
uBufLen: u32,
szDescription: ?PWSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGuideLineA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
pBuf: ?PSTR,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGuideLineW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
pBuf: ?PWSTR,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMEFileNameA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
uBufLen: u32,
szFileName: ?PSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMEFileNameW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
uBufLen: u32,
szFileName: ?PWSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOpenStatus: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetProperty: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
fdwIndex: u32,
pdwProperty: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisterWordStyleA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
nItem: u32,
pStyleBuf: ?*STYLEBUFA,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisterWordStyleW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
nItem: u32,
pStyleBuf: ?*STYLEBUFW,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatusWindowPos: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVirtualKey: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
puVirtualKey: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstallIMEA: fn(
self: *const IActiveIMMApp,
szIMEFileName: ?PSTR,
szLayoutText: ?PSTR,
phKL: ?*?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstallIMEW: fn(
self: *const IActiveIMMApp,
szIMEFileName: ?PWSTR,
szLayoutText: ?PWSTR,
phKL: ?*?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsIME: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsUIMessageA: fn(
self: *const IActiveIMMApp,
hWndIME: ?HWND,
msg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsUIMessageW: fn(
self: *const IActiveIMMApp,
hWndIME: ?HWND,
msg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NotifyIME: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwAction: u32,
dwIndex: u32,
dwValue: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWordA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szRegister: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWordW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szRegister: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseContext: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCandidateWindow: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionFontA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
plf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionFontW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
plf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionStringA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
pComp: ?*anyopaque,
dwCompLen: u32,
pRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionStringW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwIndex: u32,
pComp: ?*anyopaque,
dwCompLen: u32,
pRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionWindow: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetConversionStatus: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
fdwConversion: u32,
fdwSentence: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOpenStatus: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
fOpen: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetStatusWindowPos: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
pptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SimulateHotKey: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
dwHotKeyID: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWordA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szUnregister: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWordW: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szUnregister: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Activate: fn(
self: *const IActiveIMMApp,
fRestoreLayout: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Deactivate: fn(
self: *const IActiveIMMApp,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OnDefWindowProc: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
Msg: u32,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FilterClientWindows: fn(
self: *const IActiveIMMApp,
aaClassList: ?*u16,
uSize: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCodePageA: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
uCodePage: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLangId: fn(
self: *const IActiveIMMApp,
hKL: ?HKL,
plid: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AssociateContextEx: fn(
self: *const IActiveIMMApp,
hWnd: ?HWND,
hIMC: ?HIMC,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DisableIME: fn(
self: *const IActiveIMMApp,
idThread: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetImeMenuItemsA: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwFlags: u32,
dwType: u32,
pImeParentMenu: ?*IMEMENUITEMINFOA,
pImeMenu: ?*IMEMENUITEMINFOA,
dwSize: u32,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetImeMenuItemsW: fn(
self: *const IActiveIMMApp,
hIMC: ?HIMC,
dwFlags: u32,
dwType: u32,
pImeParentMenu: ?*IMEMENUITEMINFOW,
pImeMenu: ?*IMEMENUITEMINFOW,
dwSize: u32,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumInputContext: fn(
self: *const IActiveIMMApp,
idThread: u32,
ppEnum: ?*?*IEnumInputContext,
) 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 IActiveIMMApp_AssociateContext(self: *const T, hWnd: ?HWND, hIME: ?HIMC, phPrev: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).AssociateContext(@ptrCast(*const IActiveIMMApp, self), hWnd, hIME, phPrev);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_ConfigureIMEA(self: *const T, hKL: ?HKL, hWnd: ?HWND, dwMode: u32, pData: ?*REGISTERWORDA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).ConfigureIMEA(@ptrCast(*const IActiveIMMApp, self), hKL, hWnd, dwMode, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_ConfigureIMEW(self: *const T, hKL: ?HKL, hWnd: ?HWND, dwMode: u32, pData: ?*REGISTERWORDW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).ConfigureIMEW(@ptrCast(*const IActiveIMMApp, self), hKL, hWnd, dwMode, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_CreateContext(self: *const T, phIMC: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).CreateContext(@ptrCast(*const IActiveIMMApp, self), phIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_DestroyContext(self: *const T, hIME: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).DestroyContext(@ptrCast(*const IActiveIMMApp, self), hIME);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_EnumRegisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szRegister: ?PSTR, pData: ?*anyopaque, pEnum: ?*?*IEnumRegisterWordA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).EnumRegisterWordA(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szRegister, pData, pEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_EnumRegisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szRegister: ?PWSTR, pData: ?*anyopaque, pEnum: ?*?*IEnumRegisterWordW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).EnumRegisterWordW(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szRegister, pData, pEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_EscapeA(self: *const T, hKL: ?HKL, hIMC: ?HIMC, uEscape: u32, pData: ?*anyopaque, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).EscapeA(@ptrCast(*const IActiveIMMApp, self), hKL, hIMC, uEscape, pData, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_EscapeW(self: *const T, hKL: ?HKL, hIMC: ?HIMC, uEscape: u32, pData: ?*anyopaque, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).EscapeW(@ptrCast(*const IActiveIMMApp, self), hKL, hIMC, uEscape, pData, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCandidateListA(self: *const T, hIMC: ?HIMC, dwIndex: u32, uBufLen: u32, pCandList: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCandidateListA(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, uBufLen, pCandList, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCandidateListW(self: *const T, hIMC: ?HIMC, dwIndex: u32, uBufLen: u32, pCandList: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCandidateListW(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, uBufLen, pCandList, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCandidateListCountA(self: *const T, hIMC: ?HIMC, pdwListSize: ?*u32, pdwBufLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCandidateListCountA(@ptrCast(*const IActiveIMMApp, self), hIMC, pdwListSize, pdwBufLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCandidateListCountW(self: *const T, hIMC: ?HIMC, pdwListSize: ?*u32, pdwBufLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCandidateListCountW(@ptrCast(*const IActiveIMMApp, self), hIMC, pdwListSize, pdwBufLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCandidateWindow(self: *const T, hIMC: ?HIMC, dwIndex: u32, pCandidate: ?*CANDIDATEFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCandidateWindow(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, pCandidate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCompositionFontA(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCompositionFontA(@ptrCast(*const IActiveIMMApp, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCompositionFontW(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCompositionFontW(@ptrCast(*const IActiveIMMApp, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCompositionStringA(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, plCopied: ?*i32, pBuf: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCompositionStringA(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, dwBufLen, plCopied, pBuf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCompositionStringW(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, plCopied: ?*i32, pBuf: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCompositionStringW(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, dwBufLen, plCopied, pBuf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCompositionWindow(self: *const T, hIMC: ?HIMC, pCompForm: ?*COMPOSITIONFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCompositionWindow(@ptrCast(*const IActiveIMMApp, self), hIMC, pCompForm);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetContext(self: *const T, hWnd: ?HWND, phIMC: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetContext(@ptrCast(*const IActiveIMMApp, self), hWnd, phIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetConversionListA(self: *const T, hKL: ?HKL, hIMC: ?HIMC, pSrc: ?PSTR, uBufLen: u32, uFlag: u32, pDst: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetConversionListA(@ptrCast(*const IActiveIMMApp, self), hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetConversionListW(self: *const T, hKL: ?HKL, hIMC: ?HIMC, pSrc: ?PWSTR, uBufLen: u32, uFlag: u32, pDst: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetConversionListW(@ptrCast(*const IActiveIMMApp, self), hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetConversionStatus(self: *const T, hIMC: ?HIMC, pfdwConversion: ?*u32, pfdwSentence: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetConversionStatus(@ptrCast(*const IActiveIMMApp, self), hIMC, pfdwConversion, pfdwSentence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetDefaultIMEWnd(self: *const T, hWnd: ?HWND, phDefWnd: ?*?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetDefaultIMEWnd(@ptrCast(*const IActiveIMMApp, self), hWnd, phDefWnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetDescriptionA(self: *const T, hKL: ?HKL, uBufLen: u32, szDescription: ?PSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetDescriptionA(@ptrCast(*const IActiveIMMApp, self), hKL, uBufLen, szDescription, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetDescriptionW(self: *const T, hKL: ?HKL, uBufLen: u32, szDescription: ?PWSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetDescriptionW(@ptrCast(*const IActiveIMMApp, self), hKL, uBufLen, szDescription, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetGuideLineA(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, pBuf: ?PSTR, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetGuideLineA(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetGuideLineW(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, pBuf: ?PWSTR, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetGuideLineW(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetIMEFileNameA(self: *const T, hKL: ?HKL, uBufLen: u32, szFileName: ?PSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetIMEFileNameA(@ptrCast(*const IActiveIMMApp, self), hKL, uBufLen, szFileName, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetIMEFileNameW(self: *const T, hKL: ?HKL, uBufLen: u32, szFileName: ?PWSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetIMEFileNameW(@ptrCast(*const IActiveIMMApp, self), hKL, uBufLen, szFileName, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetOpenStatus(self: *const T, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetOpenStatus(@ptrCast(*const IActiveIMMApp, self), hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetProperty(self: *const T, hKL: ?HKL, fdwIndex: u32, pdwProperty: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetProperty(@ptrCast(*const IActiveIMMApp, self), hKL, fdwIndex, pdwProperty);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetRegisterWordStyleA(self: *const T, hKL: ?HKL, nItem: u32, pStyleBuf: ?*STYLEBUFA, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetRegisterWordStyleA(@ptrCast(*const IActiveIMMApp, self), hKL, nItem, pStyleBuf, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetRegisterWordStyleW(self: *const T, hKL: ?HKL, nItem: u32, pStyleBuf: ?*STYLEBUFW, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetRegisterWordStyleW(@ptrCast(*const IActiveIMMApp, self), hKL, nItem, pStyleBuf, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetStatusWindowPos(self: *const T, hIMC: ?HIMC, pptPos: ?*POINT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetStatusWindowPos(@ptrCast(*const IActiveIMMApp, self), hIMC, pptPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetVirtualKey(self: *const T, hWnd: ?HWND, puVirtualKey: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetVirtualKey(@ptrCast(*const IActiveIMMApp, self), hWnd, puVirtualKey);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_InstallIMEA(self: *const T, szIMEFileName: ?PSTR, szLayoutText: ?PSTR, phKL: ?*?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).InstallIMEA(@ptrCast(*const IActiveIMMApp, self), szIMEFileName, szLayoutText, phKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_InstallIMEW(self: *const T, szIMEFileName: ?PWSTR, szLayoutText: ?PWSTR, phKL: ?*?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).InstallIMEW(@ptrCast(*const IActiveIMMApp, self), szIMEFileName, szLayoutText, phKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_IsIME(self: *const T, hKL: ?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).IsIME(@ptrCast(*const IActiveIMMApp, self), hKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_IsUIMessageA(self: *const T, hWndIME: ?HWND, msg: u32, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).IsUIMessageA(@ptrCast(*const IActiveIMMApp, self), hWndIME, msg, wParam, lParam);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_IsUIMessageW(self: *const T, hWndIME: ?HWND, msg: u32, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).IsUIMessageW(@ptrCast(*const IActiveIMMApp, self), hWndIME, msg, wParam, lParam);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_NotifyIME(self: *const T, hIMC: ?HIMC, dwAction: u32, dwIndex: u32, dwValue: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).NotifyIME(@ptrCast(*const IActiveIMMApp, self), hIMC, dwAction, dwIndex, dwValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_RegisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szRegister: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).RegisterWordA(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szRegister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_RegisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szRegister: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).RegisterWordW(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szRegister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_ReleaseContext(self: *const T, hWnd: ?HWND, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).ReleaseContext(@ptrCast(*const IActiveIMMApp, self), hWnd, hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCandidateWindow(self: *const T, hIMC: ?HIMC, pCandidate: ?*CANDIDATEFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCandidateWindow(@ptrCast(*const IActiveIMMApp, self), hIMC, pCandidate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCompositionFontA(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCompositionFontA(@ptrCast(*const IActiveIMMApp, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCompositionFontW(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCompositionFontW(@ptrCast(*const IActiveIMMApp, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCompositionStringA(self: *const T, hIMC: ?HIMC, dwIndex: u32, pComp: ?*anyopaque, dwCompLen: u32, pRead: ?*anyopaque, dwReadLen: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCompositionStringA(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCompositionStringW(self: *const T, hIMC: ?HIMC, dwIndex: u32, pComp: ?*anyopaque, dwCompLen: u32, pRead: ?*anyopaque, dwReadLen: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCompositionStringW(@ptrCast(*const IActiveIMMApp, self), hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetCompositionWindow(self: *const T, hIMC: ?HIMC, pCompForm: ?*COMPOSITIONFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetCompositionWindow(@ptrCast(*const IActiveIMMApp, self), hIMC, pCompForm);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetConversionStatus(self: *const T, hIMC: ?HIMC, fdwConversion: u32, fdwSentence: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetConversionStatus(@ptrCast(*const IActiveIMMApp, self), hIMC, fdwConversion, fdwSentence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetOpenStatus(self: *const T, hIMC: ?HIMC, fOpen: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetOpenStatus(@ptrCast(*const IActiveIMMApp, self), hIMC, fOpen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SetStatusWindowPos(self: *const T, hIMC: ?HIMC, pptPos: ?*POINT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SetStatusWindowPos(@ptrCast(*const IActiveIMMApp, self), hIMC, pptPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_SimulateHotKey(self: *const T, hWnd: ?HWND, dwHotKeyID: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).SimulateHotKey(@ptrCast(*const IActiveIMMApp, self), hWnd, dwHotKeyID);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_UnregisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szUnregister: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).UnregisterWordA(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szUnregister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_UnregisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szUnregister: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).UnregisterWordW(@ptrCast(*const IActiveIMMApp, self), hKL, szReading, dwStyle, szUnregister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_Activate(self: *const T, fRestoreLayout: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).Activate(@ptrCast(*const IActiveIMMApp, self), fRestoreLayout);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_Deactivate(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).Deactivate(@ptrCast(*const IActiveIMMApp, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_OnDefWindowProc(self: *const T, hWnd: ?HWND, Msg: u32, wParam: WPARAM, lParam: LPARAM, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).OnDefWindowProc(@ptrCast(*const IActiveIMMApp, self), hWnd, Msg, wParam, lParam, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_FilterClientWindows(self: *const T, aaClassList: ?*u16, uSize: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).FilterClientWindows(@ptrCast(*const IActiveIMMApp, self), aaClassList, uSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetCodePageA(self: *const T, hKL: ?HKL, uCodePage: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetCodePageA(@ptrCast(*const IActiveIMMApp, self), hKL, uCodePage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetLangId(self: *const T, hKL: ?HKL, plid: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetLangId(@ptrCast(*const IActiveIMMApp, self), hKL, plid);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_AssociateContextEx(self: *const T, hWnd: ?HWND, hIMC: ?HIMC, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).AssociateContextEx(@ptrCast(*const IActiveIMMApp, self), hWnd, hIMC, dwFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_DisableIME(self: *const T, idThread: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).DisableIME(@ptrCast(*const IActiveIMMApp, self), idThread);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetImeMenuItemsA(self: *const T, hIMC: ?HIMC, dwFlags: u32, dwType: u32, pImeParentMenu: ?*IMEMENUITEMINFOA, pImeMenu: ?*IMEMENUITEMINFOA, dwSize: u32, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetImeMenuItemsA(@ptrCast(*const IActiveIMMApp, self), hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_GetImeMenuItemsW(self: *const T, hIMC: ?HIMC, dwFlags: u32, dwType: u32, pImeParentMenu: ?*IMEMENUITEMINFOW, pImeMenu: ?*IMEMENUITEMINFOW, dwSize: u32, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).GetImeMenuItemsW(@ptrCast(*const IActiveIMMApp, self), hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMApp_EnumInputContext(self: *const T, idThread: u32, ppEnum: ?*?*IEnumInputContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMApp.VTable, self.vtable).EnumInputContext(@ptrCast(*const IActiveIMMApp, self), idThread, ppEnum);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIMMIME_Value = @import("../../zig.zig").Guid.initString("08c03411-f96b-11d0-a475-00aa006bcc59");
pub const IID_IActiveIMMIME = &IID_IActiveIMMIME_Value;
pub const IActiveIMMIME = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AssociateContext: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
hIME: ?HIMC,
phPrev: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConfigureIMEA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hWnd: ?HWND,
dwMode: u32,
pData: ?*REGISTERWORDA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConfigureIMEW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hWnd: ?HWND,
dwMode: u32,
pData: ?*REGISTERWORDW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateContext: fn(
self: *const IActiveIMMIME,
phIMC: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DestroyContext: fn(
self: *const IActiveIMMIME,
hIME: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumRegisterWordA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szRegister: ?PSTR,
pData: ?*anyopaque,
pEnum: ?*?*IEnumRegisterWordA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumRegisterWordW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szRegister: ?PWSTR,
pData: ?*anyopaque,
pEnum: ?*?*IEnumRegisterWordW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EscapeA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hIMC: ?HIMC,
uEscape: u32,
pData: ?*anyopaque,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EscapeW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hIMC: ?HIMC,
uEscape: u32,
pData: ?*anyopaque,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
uBufLen: u32,
pCandList: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
uBufLen: u32,
pCandList: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListCountA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pdwListSize: ?*u32,
pdwBufLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateListCountW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pdwListSize: ?*u32,
pdwBufLen: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCandidateWindow: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
pCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionFontA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
plf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionFontW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
plf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionStringA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
plCopied: ?*i32,
pBuf: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionStringW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
plCopied: ?*i32,
pBuf: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCompositionWindow: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetContext: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
phIMC: ?*?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionListA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hIMC: ?HIMC,
pSrc: ?PSTR,
uBufLen: u32,
uFlag: u32,
pDst: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionListW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
hIMC: ?HIMC,
pSrc: ?PWSTR,
uBufLen: u32,
uFlag: u32,
pDst: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetConversionStatus: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pfdwConversion: ?*u32,
pfdwSentence: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDefaultIMEWnd: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
phDefWnd: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDescriptionA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
uBufLen: u32,
szDescription: ?PSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetDescriptionW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
uBufLen: u32,
szDescription: ?PWSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGuideLineA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
pBuf: ?PSTR,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetGuideLineW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
dwBufLen: u32,
pBuf: ?PWSTR,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMEFileNameA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
uBufLen: u32,
szFileName: ?PSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMEFileNameW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
uBufLen: u32,
szFileName: ?PWSTR,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetOpenStatus: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetProperty: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
fdwIndex: u32,
pdwProperty: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisterWordStyleA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
nItem: u32,
pStyleBuf: ?*STYLEBUFA,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisterWordStyleW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
nItem: u32,
pStyleBuf: ?*STYLEBUFW,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetStatusWindowPos: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVirtualKey: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
puVirtualKey: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstallIMEA: fn(
self: *const IActiveIMMIME,
szIMEFileName: ?PSTR,
szLayoutText: ?PSTR,
phKL: ?*?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstallIMEW: fn(
self: *const IActiveIMMIME,
szIMEFileName: ?PWSTR,
szLayoutText: ?PWSTR,
phKL: ?*?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsIME: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsUIMessageA: fn(
self: *const IActiveIMMIME,
hWndIME: ?HWND,
msg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsUIMessageW: fn(
self: *const IActiveIMMIME,
hWndIME: ?HWND,
msg: u32,
wParam: WPARAM,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NotifyIME: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwAction: u32,
dwIndex: u32,
dwValue: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWordA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szRegister: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWordW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szRegister: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReleaseContext: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCandidateWindow: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionFontA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
plf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionFontW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
plf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionStringA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
pComp: ?*anyopaque,
dwCompLen: u32,
pRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionStringW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwIndex: u32,
pComp: ?*anyopaque,
dwCompLen: u32,
pRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionWindow: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetConversionStatus: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
fdwConversion: u32,
fdwSentence: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetOpenStatus: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
fOpen: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetStatusWindowPos: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SimulateHotKey: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
dwHotKeyID: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWordA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PSTR,
dwStyle: u32,
szUnregister: ?PSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWordW: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
szReading: ?PWSTR,
dwStyle: u32,
szUnregister: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GenerateMessage: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LockIMC: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
ppIMC: ?*?*INPUTCONTEXT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnlockIMC: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMCLockCount: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
pdwLockCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateIMCC: fn(
self: *const IActiveIMMIME,
dwSize: u32,
phIMCC: ?*?HIMCC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DestroyIMCC: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LockIMCC: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnlockIMCC: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReSizeIMCC: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
dwSize: u32,
phIMCC: ?*?HIMCC,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMCCSize: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
pdwSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetIMCCLockCount: fn(
self: *const IActiveIMMIME,
hIMCC: ?HIMCC,
pdwLockCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetHotKey: fn(
self: *const IActiveIMMIME,
dwHotKeyID: u32,
puModifiers: ?*u32,
puVKey: ?*u32,
phKL: ?*?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetHotKey: fn(
self: *const IActiveIMMIME,
dwHotKeyID: u32,
uModifiers: u32,
uVKey: u32,
hKL: ?HKL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateSoftKeyboard: fn(
self: *const IActiveIMMIME,
uType: u32,
hOwner: ?HWND,
x: i32,
y: i32,
phSoftKbdWnd: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DestroySoftKeyboard: fn(
self: *const IActiveIMMIME,
hSoftKbdWnd: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ShowSoftKeyboard: fn(
self: *const IActiveIMMIME,
hSoftKbdWnd: ?HWND,
nCmdShow: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCodePageA: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
uCodePage: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLangId: fn(
self: *const IActiveIMMIME,
hKL: ?HKL,
plid: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
KeybdEvent: fn(
self: *const IActiveIMMIME,
lgidIME: u16,
bVk: u8,
bScan: u8,
dwFlags: u32,
dwExtraInfo: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
LockModal: fn(
self: *const IActiveIMMIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnlockModal: fn(
self: *const IActiveIMMIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AssociateContextEx: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
hIMC: ?HIMC,
dwFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DisableIME: fn(
self: *const IActiveIMMIME,
idThread: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetImeMenuItemsA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwFlags: u32,
dwType: u32,
pImeParentMenu: ?*IMEMENUITEMINFOA,
pImeMenu: ?*IMEMENUITEMINFOA,
dwSize: u32,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetImeMenuItemsW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
dwFlags: u32,
dwType: u32,
pImeParentMenu: ?*IMEMENUITEMINFOW,
pImeMenu: ?*IMEMENUITEMINFOW,
dwSize: u32,
pdwResult: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumInputContext: fn(
self: *const IActiveIMMIME,
idThread: u32,
ppEnum: ?*?*IEnumInputContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RequestMessageA: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RequestMessageW: fn(
self: *const IActiveIMMIME,
hIMC: ?HIMC,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendIMCA: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SendIMCW: fn(
self: *const IActiveIMMIME,
hWnd: ?HWND,
uMsg: u32,
wParam: WPARAM,
lParam: LPARAM,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsSleeping: fn(
self: *const IActiveIMMIME,
) 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 IActiveIMMIME_AssociateContext(self: *const T, hWnd: ?HWND, hIME: ?HIMC, phPrev: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).AssociateContext(@ptrCast(*const IActiveIMMIME, self), hWnd, hIME, phPrev);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_ConfigureIMEA(self: *const T, hKL: ?HKL, hWnd: ?HWND, dwMode: u32, pData: ?*REGISTERWORDA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).ConfigureIMEA(@ptrCast(*const IActiveIMMIME, self), hKL, hWnd, dwMode, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_ConfigureIMEW(self: *const T, hKL: ?HKL, hWnd: ?HWND, dwMode: u32, pData: ?*REGISTERWORDW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).ConfigureIMEW(@ptrCast(*const IActiveIMMIME, self), hKL, hWnd, dwMode, pData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_CreateContext(self: *const T, phIMC: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).CreateContext(@ptrCast(*const IActiveIMMIME, self), phIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_DestroyContext(self: *const T, hIME: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).DestroyContext(@ptrCast(*const IActiveIMMIME, self), hIME);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_EnumRegisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szRegister: ?PSTR, pData: ?*anyopaque, pEnum: ?*?*IEnumRegisterWordA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).EnumRegisterWordA(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szRegister, pData, pEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_EnumRegisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szRegister: ?PWSTR, pData: ?*anyopaque, pEnum: ?*?*IEnumRegisterWordW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).EnumRegisterWordW(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szRegister, pData, pEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_EscapeA(self: *const T, hKL: ?HKL, hIMC: ?HIMC, uEscape: u32, pData: ?*anyopaque, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).EscapeA(@ptrCast(*const IActiveIMMIME, self), hKL, hIMC, uEscape, pData, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_EscapeW(self: *const T, hKL: ?HKL, hIMC: ?HIMC, uEscape: u32, pData: ?*anyopaque, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).EscapeW(@ptrCast(*const IActiveIMMIME, self), hKL, hIMC, uEscape, pData, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCandidateListA(self: *const T, hIMC: ?HIMC, dwIndex: u32, uBufLen: u32, pCandList: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCandidateListA(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, uBufLen, pCandList, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCandidateListW(self: *const T, hIMC: ?HIMC, dwIndex: u32, uBufLen: u32, pCandList: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCandidateListW(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, uBufLen, pCandList, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCandidateListCountA(self: *const T, hIMC: ?HIMC, pdwListSize: ?*u32, pdwBufLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCandidateListCountA(@ptrCast(*const IActiveIMMIME, self), hIMC, pdwListSize, pdwBufLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCandidateListCountW(self: *const T, hIMC: ?HIMC, pdwListSize: ?*u32, pdwBufLen: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCandidateListCountW(@ptrCast(*const IActiveIMMIME, self), hIMC, pdwListSize, pdwBufLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCandidateWindow(self: *const T, hIMC: ?HIMC, dwIndex: u32, pCandidate: ?*CANDIDATEFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCandidateWindow(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, pCandidate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCompositionFontA(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCompositionFontA(@ptrCast(*const IActiveIMMIME, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCompositionFontW(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCompositionFontW(@ptrCast(*const IActiveIMMIME, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCompositionStringA(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, plCopied: ?*i32, pBuf: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCompositionStringA(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, dwBufLen, plCopied, pBuf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCompositionStringW(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, plCopied: ?*i32, pBuf: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCompositionStringW(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, dwBufLen, plCopied, pBuf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCompositionWindow(self: *const T, hIMC: ?HIMC, pCompForm: ?*COMPOSITIONFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCompositionWindow(@ptrCast(*const IActiveIMMIME, self), hIMC, pCompForm);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetContext(self: *const T, hWnd: ?HWND, phIMC: ?*?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetContext(@ptrCast(*const IActiveIMMIME, self), hWnd, phIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetConversionListA(self: *const T, hKL: ?HKL, hIMC: ?HIMC, pSrc: ?PSTR, uBufLen: u32, uFlag: u32, pDst: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetConversionListA(@ptrCast(*const IActiveIMMIME, self), hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetConversionListW(self: *const T, hKL: ?HKL, hIMC: ?HIMC, pSrc: ?PWSTR, uBufLen: u32, uFlag: u32, pDst: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetConversionListW(@ptrCast(*const IActiveIMMIME, self), hKL, hIMC, pSrc, uBufLen, uFlag, pDst, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetConversionStatus(self: *const T, hIMC: ?HIMC, pfdwConversion: ?*u32, pfdwSentence: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetConversionStatus(@ptrCast(*const IActiveIMMIME, self), hIMC, pfdwConversion, pfdwSentence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetDefaultIMEWnd(self: *const T, hWnd: ?HWND, phDefWnd: ?*?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetDefaultIMEWnd(@ptrCast(*const IActiveIMMIME, self), hWnd, phDefWnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetDescriptionA(self: *const T, hKL: ?HKL, uBufLen: u32, szDescription: ?PSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetDescriptionA(@ptrCast(*const IActiveIMMIME, self), hKL, uBufLen, szDescription, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetDescriptionW(self: *const T, hKL: ?HKL, uBufLen: u32, szDescription: ?PWSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetDescriptionW(@ptrCast(*const IActiveIMMIME, self), hKL, uBufLen, szDescription, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetGuideLineA(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, pBuf: ?PSTR, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetGuideLineA(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetGuideLineW(self: *const T, hIMC: ?HIMC, dwIndex: u32, dwBufLen: u32, pBuf: ?PWSTR, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetGuideLineW(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetIMEFileNameA(self: *const T, hKL: ?HKL, uBufLen: u32, szFileName: ?PSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetIMEFileNameA(@ptrCast(*const IActiveIMMIME, self), hKL, uBufLen, szFileName, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetIMEFileNameW(self: *const T, hKL: ?HKL, uBufLen: u32, szFileName: ?PWSTR, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetIMEFileNameW(@ptrCast(*const IActiveIMMIME, self), hKL, uBufLen, szFileName, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetOpenStatus(self: *const T, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetOpenStatus(@ptrCast(*const IActiveIMMIME, self), hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetProperty(self: *const T, hKL: ?HKL, fdwIndex: u32, pdwProperty: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetProperty(@ptrCast(*const IActiveIMMIME, self), hKL, fdwIndex, pdwProperty);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetRegisterWordStyleA(self: *const T, hKL: ?HKL, nItem: u32, pStyleBuf: ?*STYLEBUFA, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetRegisterWordStyleA(@ptrCast(*const IActiveIMMIME, self), hKL, nItem, pStyleBuf, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetRegisterWordStyleW(self: *const T, hKL: ?HKL, nItem: u32, pStyleBuf: ?*STYLEBUFW, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetRegisterWordStyleW(@ptrCast(*const IActiveIMMIME, self), hKL, nItem, pStyleBuf, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetStatusWindowPos(self: *const T, hIMC: ?HIMC, pptPos: ?*POINT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetStatusWindowPos(@ptrCast(*const IActiveIMMIME, self), hIMC, pptPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetVirtualKey(self: *const T, hWnd: ?HWND, puVirtualKey: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetVirtualKey(@ptrCast(*const IActiveIMMIME, self), hWnd, puVirtualKey);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_InstallIMEA(self: *const T, szIMEFileName: ?PSTR, szLayoutText: ?PSTR, phKL: ?*?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).InstallIMEA(@ptrCast(*const IActiveIMMIME, self), szIMEFileName, szLayoutText, phKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_InstallIMEW(self: *const T, szIMEFileName: ?PWSTR, szLayoutText: ?PWSTR, phKL: ?*?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).InstallIMEW(@ptrCast(*const IActiveIMMIME, self), szIMEFileName, szLayoutText, phKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_IsIME(self: *const T, hKL: ?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).IsIME(@ptrCast(*const IActiveIMMIME, self), hKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_IsUIMessageA(self: *const T, hWndIME: ?HWND, msg: u32, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).IsUIMessageA(@ptrCast(*const IActiveIMMIME, self), hWndIME, msg, wParam, lParam);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_IsUIMessageW(self: *const T, hWndIME: ?HWND, msg: u32, wParam: WPARAM, lParam: LPARAM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).IsUIMessageW(@ptrCast(*const IActiveIMMIME, self), hWndIME, msg, wParam, lParam);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_NotifyIME(self: *const T, hIMC: ?HIMC, dwAction: u32, dwIndex: u32, dwValue: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).NotifyIME(@ptrCast(*const IActiveIMMIME, self), hIMC, dwAction, dwIndex, dwValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_RegisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szRegister: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).RegisterWordA(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szRegister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_RegisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szRegister: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).RegisterWordW(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szRegister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_ReleaseContext(self: *const T, hWnd: ?HWND, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).ReleaseContext(@ptrCast(*const IActiveIMMIME, self), hWnd, hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCandidateWindow(self: *const T, hIMC: ?HIMC, pCandidate: ?*CANDIDATEFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCandidateWindow(@ptrCast(*const IActiveIMMIME, self), hIMC, pCandidate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCompositionFontA(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTA) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCompositionFontA(@ptrCast(*const IActiveIMMIME, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCompositionFontW(self: *const T, hIMC: ?HIMC, plf: ?*LOGFONTW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCompositionFontW(@ptrCast(*const IActiveIMMIME, self), hIMC, plf);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCompositionStringA(self: *const T, hIMC: ?HIMC, dwIndex: u32, pComp: ?*anyopaque, dwCompLen: u32, pRead: ?*anyopaque, dwReadLen: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCompositionStringA(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCompositionStringW(self: *const T, hIMC: ?HIMC, dwIndex: u32, pComp: ?*anyopaque, dwCompLen: u32, pRead: ?*anyopaque, dwReadLen: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCompositionStringW(@ptrCast(*const IActiveIMMIME, self), hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetCompositionWindow(self: *const T, hIMC: ?HIMC, pCompForm: ?*COMPOSITIONFORM) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetCompositionWindow(@ptrCast(*const IActiveIMMIME, self), hIMC, pCompForm);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetConversionStatus(self: *const T, hIMC: ?HIMC, fdwConversion: u32, fdwSentence: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetConversionStatus(@ptrCast(*const IActiveIMMIME, self), hIMC, fdwConversion, fdwSentence);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetOpenStatus(self: *const T, hIMC: ?HIMC, fOpen: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetOpenStatus(@ptrCast(*const IActiveIMMIME, self), hIMC, fOpen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetStatusWindowPos(self: *const T, hIMC: ?HIMC, pptPos: ?*POINT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetStatusWindowPos(@ptrCast(*const IActiveIMMIME, self), hIMC, pptPos);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SimulateHotKey(self: *const T, hWnd: ?HWND, dwHotKeyID: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SimulateHotKey(@ptrCast(*const IActiveIMMIME, self), hWnd, dwHotKeyID);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_UnregisterWordA(self: *const T, hKL: ?HKL, szReading: ?PSTR, dwStyle: u32, szUnregister: ?PSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).UnregisterWordA(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szUnregister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_UnregisterWordW(self: *const T, hKL: ?HKL, szReading: ?PWSTR, dwStyle: u32, szUnregister: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).UnregisterWordW(@ptrCast(*const IActiveIMMIME, self), hKL, szReading, dwStyle, szUnregister);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GenerateMessage(self: *const T, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GenerateMessage(@ptrCast(*const IActiveIMMIME, self), hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_LockIMC(self: *const T, hIMC: ?HIMC, ppIMC: ?*?*INPUTCONTEXT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).LockIMC(@ptrCast(*const IActiveIMMIME, self), hIMC, ppIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_UnlockIMC(self: *const T, hIMC: ?HIMC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).UnlockIMC(@ptrCast(*const IActiveIMMIME, self), hIMC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetIMCLockCount(self: *const T, hIMC: ?HIMC, pdwLockCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetIMCLockCount(@ptrCast(*const IActiveIMMIME, self), hIMC, pdwLockCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_CreateIMCC(self: *const T, dwSize: u32, phIMCC: ?*?HIMCC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).CreateIMCC(@ptrCast(*const IActiveIMMIME, self), dwSize, phIMCC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_DestroyIMCC(self: *const T, hIMCC: ?HIMCC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).DestroyIMCC(@ptrCast(*const IActiveIMMIME, self), hIMCC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_LockIMCC(self: *const T, hIMCC: ?HIMCC, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).LockIMCC(@ptrCast(*const IActiveIMMIME, self), hIMCC, ppv);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_UnlockIMCC(self: *const T, hIMCC: ?HIMCC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).UnlockIMCC(@ptrCast(*const IActiveIMMIME, self), hIMCC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_ReSizeIMCC(self: *const T, hIMCC: ?HIMCC, dwSize: u32, phIMCC: ?*?HIMCC) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).ReSizeIMCC(@ptrCast(*const IActiveIMMIME, self), hIMCC, dwSize, phIMCC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetIMCCSize(self: *const T, hIMCC: ?HIMCC, pdwSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetIMCCSize(@ptrCast(*const IActiveIMMIME, self), hIMCC, pdwSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetIMCCLockCount(self: *const T, hIMCC: ?HIMCC, pdwLockCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetIMCCLockCount(@ptrCast(*const IActiveIMMIME, self), hIMCC, pdwLockCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetHotKey(self: *const T, dwHotKeyID: u32, puModifiers: ?*u32, puVKey: ?*u32, phKL: ?*?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetHotKey(@ptrCast(*const IActiveIMMIME, self), dwHotKeyID, puModifiers, puVKey, phKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SetHotKey(self: *const T, dwHotKeyID: u32, uModifiers: u32, uVKey: u32, hKL: ?HKL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SetHotKey(@ptrCast(*const IActiveIMMIME, self), dwHotKeyID, uModifiers, uVKey, hKL);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_CreateSoftKeyboard(self: *const T, uType: u32, hOwner: ?HWND, x: i32, y: i32, phSoftKbdWnd: ?*?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).CreateSoftKeyboard(@ptrCast(*const IActiveIMMIME, self), uType, hOwner, x, y, phSoftKbdWnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_DestroySoftKeyboard(self: *const T, hSoftKbdWnd: ?HWND) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).DestroySoftKeyboard(@ptrCast(*const IActiveIMMIME, self), hSoftKbdWnd);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_ShowSoftKeyboard(self: *const T, hSoftKbdWnd: ?HWND, nCmdShow: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).ShowSoftKeyboard(@ptrCast(*const IActiveIMMIME, self), hSoftKbdWnd, nCmdShow);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetCodePageA(self: *const T, hKL: ?HKL, uCodePage: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetCodePageA(@ptrCast(*const IActiveIMMIME, self), hKL, uCodePage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetLangId(self: *const T, hKL: ?HKL, plid: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetLangId(@ptrCast(*const IActiveIMMIME, self), hKL, plid);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_KeybdEvent(self: *const T, lgidIME: u16, bVk: u8, bScan: u8, dwFlags: u32, dwExtraInfo: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).KeybdEvent(@ptrCast(*const IActiveIMMIME, self), lgidIME, bVk, bScan, dwFlags, dwExtraInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_LockModal(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).LockModal(@ptrCast(*const IActiveIMMIME, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_UnlockModal(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).UnlockModal(@ptrCast(*const IActiveIMMIME, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_AssociateContextEx(self: *const T, hWnd: ?HWND, hIMC: ?HIMC, dwFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).AssociateContextEx(@ptrCast(*const IActiveIMMIME, self), hWnd, hIMC, dwFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_DisableIME(self: *const T, idThread: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).DisableIME(@ptrCast(*const IActiveIMMIME, self), idThread);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetImeMenuItemsA(self: *const T, hIMC: ?HIMC, dwFlags: u32, dwType: u32, pImeParentMenu: ?*IMEMENUITEMINFOA, pImeMenu: ?*IMEMENUITEMINFOA, dwSize: u32, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetImeMenuItemsA(@ptrCast(*const IActiveIMMIME, self), hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_GetImeMenuItemsW(self: *const T, hIMC: ?HIMC, dwFlags: u32, dwType: u32, pImeParentMenu: ?*IMEMENUITEMINFOW, pImeMenu: ?*IMEMENUITEMINFOW, dwSize: u32, pdwResult: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).GetImeMenuItemsW(@ptrCast(*const IActiveIMMIME, self), hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_EnumInputContext(self: *const T, idThread: u32, ppEnum: ?*?*IEnumInputContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).EnumInputContext(@ptrCast(*const IActiveIMMIME, self), idThread, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_RequestMessageA(self: *const T, hIMC: ?HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).RequestMessageA(@ptrCast(*const IActiveIMMIME, self), hIMC, wParam, lParam, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_RequestMessageW(self: *const T, hIMC: ?HIMC, wParam: WPARAM, lParam: LPARAM, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).RequestMessageW(@ptrCast(*const IActiveIMMIME, self), hIMC, wParam, lParam, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SendIMCA(self: *const T, hWnd: ?HWND, uMsg: u32, wParam: WPARAM, lParam: LPARAM, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SendIMCA(@ptrCast(*const IActiveIMMIME, self), hWnd, uMsg, wParam, lParam, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_SendIMCW(self: *const T, hWnd: ?HWND, uMsg: u32, wParam: WPARAM, lParam: LPARAM, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).SendIMCW(@ptrCast(*const IActiveIMMIME, self), hWnd, uMsg, wParam, lParam, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIMMIME_IsSleeping(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIMMIME.VTable, self.vtable).IsSleeping(@ptrCast(*const IActiveIMMIME, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIME_Value = @import("../../zig.zig").Guid.initString("6fe20962-d077-11d0-8fe7-00aa006bcc59");
pub const IID_IActiveIME = &IID_IActiveIME_Value;
pub const IActiveIME = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Inquire: fn(
self: *const IActiveIME,
dwSystemInfoFlags: u32,
pIMEInfo: ?*IMEINFO,
szWndClass: ?PWSTR,
pdwPrivate: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ConversionList: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
szSource: ?PWSTR,
uFlag: u32,
uBufLen: u32,
pDest: ?*CANDIDATELIST,
puCopied: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Configure: fn(
self: *const IActiveIME,
hKL: ?HKL,
hWnd: ?HWND,
dwMode: u32,
pRegisterWord: ?*REGISTERWORDW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Destroy: fn(
self: *const IActiveIME,
uReserved: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Escape: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
uEscape: u32,
pData: ?*anyopaque,
plResult: ?*LRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetActiveContext: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
fFlag: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ProcessKey: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
uVirKey: u32,
lParam: u32,
pbKeyState: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Notify: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
dwAction: u32,
dwIndex: u32,
dwValue: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Select: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
fSelect: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetCompositionString: fn(
self: *const IActiveIME,
hIMC: ?HIMC,
dwIndex: u32,
pComp: ?*anyopaque,
dwCompLen: u32,
pRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ToAsciiEx: fn(
self: *const IActiveIME,
uVirKey: u32,
uScanCode: u32,
pbKeyState: ?*u8,
fuState: u32,
hIMC: ?HIMC,
pdwTransBuf: ?*u32,
puSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RegisterWord: fn(
self: *const IActiveIME,
szReading: ?PWSTR,
dwStyle: u32,
szString: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnregisterWord: fn(
self: *const IActiveIME,
szReading: ?PWSTR,
dwStyle: u32,
szString: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRegisterWordStyle: fn(
self: *const IActiveIME,
nItem: u32,
pStyleBuf: ?*STYLEBUFW,
puBufSize: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EnumRegisterWord: fn(
self: *const IActiveIME,
szReading: ?PWSTR,
dwStyle: u32,
szRegister: ?PWSTR,
pData: ?*anyopaque,
ppEnum: ?*?*IEnumRegisterWordW,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCodePageA: fn(
self: *const IActiveIME,
uCodePage: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetLangId: fn(
self: *const IActiveIME,
plid: ?*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 IActiveIME_Inquire(self: *const T, dwSystemInfoFlags: u32, pIMEInfo: ?*IMEINFO, szWndClass: ?PWSTR, pdwPrivate: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Inquire(@ptrCast(*const IActiveIME, self), dwSystemInfoFlags, pIMEInfo, szWndClass, pdwPrivate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_ConversionList(self: *const T, hIMC: ?HIMC, szSource: ?PWSTR, uFlag: u32, uBufLen: u32, pDest: ?*CANDIDATELIST, puCopied: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).ConversionList(@ptrCast(*const IActiveIME, self), hIMC, szSource, uFlag, uBufLen, pDest, puCopied);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_Configure(self: *const T, hKL: ?HKL, hWnd: ?HWND, dwMode: u32, pRegisterWord: ?*REGISTERWORDW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Configure(@ptrCast(*const IActiveIME, self), hKL, hWnd, dwMode, pRegisterWord);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_Destroy(self: *const T, uReserved: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Destroy(@ptrCast(*const IActiveIME, self), uReserved);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_Escape(self: *const T, hIMC: ?HIMC, uEscape: u32, pData: ?*anyopaque, plResult: ?*LRESULT) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Escape(@ptrCast(*const IActiveIME, self), hIMC, uEscape, pData, plResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_SetActiveContext(self: *const T, hIMC: ?HIMC, fFlag: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).SetActiveContext(@ptrCast(*const IActiveIME, self), hIMC, fFlag);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_ProcessKey(self: *const T, hIMC: ?HIMC, uVirKey: u32, lParam: u32, pbKeyState: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).ProcessKey(@ptrCast(*const IActiveIME, self), hIMC, uVirKey, lParam, pbKeyState);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_Notify(self: *const T, hIMC: ?HIMC, dwAction: u32, dwIndex: u32, dwValue: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Notify(@ptrCast(*const IActiveIME, self), hIMC, dwAction, dwIndex, dwValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_Select(self: *const T, hIMC: ?HIMC, fSelect: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).Select(@ptrCast(*const IActiveIME, self), hIMC, fSelect);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_SetCompositionString(self: *const T, hIMC: ?HIMC, dwIndex: u32, pComp: ?*anyopaque, dwCompLen: u32, pRead: ?*anyopaque, dwReadLen: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).SetCompositionString(@ptrCast(*const IActiveIME, self), hIMC, dwIndex, pComp, dwCompLen, pRead, dwReadLen);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_ToAsciiEx(self: *const T, uVirKey: u32, uScanCode: u32, pbKeyState: ?*u8, fuState: u32, hIMC: ?HIMC, pdwTransBuf: ?*u32, puSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).ToAsciiEx(@ptrCast(*const IActiveIME, self), uVirKey, uScanCode, pbKeyState, fuState, hIMC, pdwTransBuf, puSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_RegisterWord(self: *const T, szReading: ?PWSTR, dwStyle: u32, szString: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).RegisterWord(@ptrCast(*const IActiveIME, self), szReading, dwStyle, szString);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_UnregisterWord(self: *const T, szReading: ?PWSTR, dwStyle: u32, szString: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).UnregisterWord(@ptrCast(*const IActiveIME, self), szReading, dwStyle, szString);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_GetRegisterWordStyle(self: *const T, nItem: u32, pStyleBuf: ?*STYLEBUFW, puBufSize: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).GetRegisterWordStyle(@ptrCast(*const IActiveIME, self), nItem, pStyleBuf, puBufSize);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_EnumRegisterWord(self: *const T, szReading: ?PWSTR, dwStyle: u32, szRegister: ?PWSTR, pData: ?*anyopaque, ppEnum: ?*?*IEnumRegisterWordW) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).EnumRegisterWord(@ptrCast(*const IActiveIME, self), szReading, dwStyle, szRegister, pData, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_GetCodePageA(self: *const T, uCodePage: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).GetCodePageA(@ptrCast(*const IActiveIME, self), uCodePage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME_GetLangId(self: *const T, plid: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME.VTable, self.vtable).GetLangId(@ptrCast(*const IActiveIME, self), plid);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IActiveIME2_Value = @import("../../zig.zig").Guid.initString("e1c4bf0e-2d53-11d2-93e1-0060b067b86e");
pub const IID_IActiveIME2 = &IID_IActiveIME2_Value;
pub const IActiveIME2 = extern struct {
pub const VTable = extern struct {
base: IActiveIME.VTable,
Sleep: fn(
self: *const IActiveIME2,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unsleep: fn(
self: *const IActiveIME2,
fDead: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IActiveIME.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME2_Sleep(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME2.VTable, self.vtable).Sleep(@ptrCast(*const IActiveIME2, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IActiveIME2_Unsleep(self: *const T, fDead: BOOL) callconv(.Inline) HRESULT {
return @ptrCast(*const IActiveIME2.VTable, self.vtable).Unsleep(@ptrCast(*const IActiveIME2, self), fDead);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (82)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmInstallIMEA(
lpszIMEFileName: ?[*:0]const u8,
lpszLayoutText: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) ?HKL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmInstallIMEW(
lpszIMEFileName: ?[*:0]const u16,
lpszLayoutText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) ?HKL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetDefaultIMEWnd(
param0: ?HWND,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetDescriptionA(
param0: ?HKL,
lpszDescription: ?[*:0]u8,
uBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetDescriptionW(
param0: ?HKL,
lpszDescription: ?[*:0]u16,
uBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetIMEFileNameA(
param0: ?HKL,
lpszFileName: ?[*:0]u8,
uBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetIMEFileNameW(
param0: ?HKL,
lpszFileName: ?[*:0]u16,
uBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetProperty(
param0: ?HKL,
param1: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmIsIME(
param0: ?HKL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSimulateHotKey(
param0: ?HWND,
param1: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmCreateContext(
) callconv(@import("std").os.windows.WINAPI) ?HIMC;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmDestroyContext(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetContext(
param0: ?HWND,
) callconv(@import("std").os.windows.WINAPI) ?HIMC;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmReleaseContext(
param0: ?HWND,
param1: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmAssociateContext(
param0: ?HWND,
param1: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) ?HIMC;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmAssociateContextEx(
param0: ?HWND,
param1: ?HIMC,
param2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCompositionStringA(
param0: ?HIMC,
param1: u32,
// TODO: what to do with BytesParamIndex 3?
lpBuf: ?*anyopaque,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCompositionStringW(
param0: ?HIMC,
param1: u32,
// TODO: what to do with BytesParamIndex 3?
lpBuf: ?*anyopaque,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) i32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCompositionStringA(
param0: ?HIMC,
dwIndex: SET_COMPOSITION_STRING_TYPE,
// TODO: what to do with BytesParamIndex 3?
lpComp: ?*anyopaque,
dwCompLen: u32,
// TODO: what to do with BytesParamIndex 5?
lpRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCompositionStringW(
param0: ?HIMC,
dwIndex: SET_COMPOSITION_STRING_TYPE,
// TODO: what to do with BytesParamIndex 3?
lpComp: ?*anyopaque,
dwCompLen: u32,
// TODO: what to do with BytesParamIndex 5?
lpRead: ?*anyopaque,
dwReadLen: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCandidateListCountA(
param0: ?HIMC,
lpdwListCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCandidateListCountW(
param0: ?HIMC,
lpdwListCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCandidateListA(
param0: ?HIMC,
deIndex: u32,
// TODO: what to do with BytesParamIndex 3?
lpCandList: ?*CANDIDATELIST,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCandidateListW(
param0: ?HIMC,
deIndex: u32,
// TODO: what to do with BytesParamIndex 3?
lpCandList: ?*CANDIDATELIST,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetGuideLineA(
param0: ?HIMC,
dwIndex: GET_GUIDE_LINE_TYPE,
// TODO: what to do with BytesParamIndex 3?
lpBuf: ?PSTR,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetGuideLineW(
param0: ?HIMC,
dwIndex: GET_GUIDE_LINE_TYPE,
// TODO: what to do with BytesParamIndex 3?
lpBuf: ?PWSTR,
dwBufLen: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetConversionStatus(
param0: ?HIMC,
lpfdwConversion: ?*u32,
lpfdwSentence: ?*u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetConversionStatus(
param0: ?HIMC,
param1: u32,
param2: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetOpenStatus(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetOpenStatus(
param0: ?HIMC,
param1: BOOL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCompositionFontA(
param0: ?HIMC,
lplf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCompositionFontW(
param0: ?HIMC,
lplf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCompositionFontA(
param0: ?HIMC,
lplf: ?*LOGFONTA,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCompositionFontW(
param0: ?HIMC,
lplf: ?*LOGFONTW,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmConfigureIMEA(
param0: ?HKL,
param1: ?HWND,
param2: u32,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmConfigureIMEW(
param0: ?HKL,
param1: ?HWND,
param2: u32,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmEscapeA(
param0: ?HKL,
param1: ?HIMC,
param2: u32,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmEscapeW(
param0: ?HKL,
param1: ?HIMC,
param2: u32,
param3: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetConversionListA(
param0: ?HKL,
param1: ?HIMC,
lpSrc: ?[*:0]const u8,
// TODO: what to do with BytesParamIndex 4?
lpDst: ?*CANDIDATELIST,
dwBufLen: u32,
uFlag: GET_CONVERSION_LIST_FLAG,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetConversionListW(
param0: ?HKL,
param1: ?HIMC,
lpSrc: ?[*:0]const u16,
// TODO: what to do with BytesParamIndex 4?
lpDst: ?*CANDIDATELIST,
dwBufLen: u32,
uFlag: GET_CONVERSION_LIST_FLAG,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmNotifyIME(
param0: ?HIMC,
dwAction: NOTIFY_IME_ACTION,
dwIndex: NOTIFY_IME_INDEX,
dwValue: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetStatusWindowPos(
param0: ?HIMC,
lpptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetStatusWindowPos(
param0: ?HIMC,
lpptPos: ?*POINT,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCompositionWindow(
param0: ?HIMC,
lpCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCompositionWindow(
param0: ?HIMC,
lpCompForm: ?*COMPOSITIONFORM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetCandidateWindow(
param0: ?HIMC,
param1: u32,
lpCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmSetCandidateWindow(
param0: ?HIMC,
lpCandidate: ?*CANDIDATEFORM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmIsUIMessageA(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmIsUIMessageW(
param0: ?HWND,
param1: u32,
param2: WPARAM,
param3: LPARAM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetVirtualKey(
param0: ?HWND,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmRegisterWordA(
param0: ?HKL,
lpszReading: ?[*:0]const u8,
param2: u32,
lpszRegister: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmRegisterWordW(
param0: ?HKL,
lpszReading: ?[*:0]const u16,
param2: u32,
lpszRegister: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmUnregisterWordA(
param0: ?HKL,
lpszReading: ?[*:0]const u8,
param2: u32,
lpszUnregister: ?[*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmUnregisterWordW(
param0: ?HKL,
lpszReading: ?[*:0]const u16,
param2: u32,
lpszUnregister: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetRegisterWordStyleA(
param0: ?HKL,
nItem: u32,
lpStyleBuf: [*]STYLEBUFA,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetRegisterWordStyleW(
param0: ?HKL,
nItem: u32,
lpStyleBuf: [*]STYLEBUFW,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmEnumRegisterWordA(
param0: ?HKL,
param1: ?REGISTERWORDENUMPROCA,
lpszReading: ?[*:0]const u8,
param3: u32,
lpszRegister: ?[*:0]const u8,
param5: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmEnumRegisterWordW(
param0: ?HKL,
param1: ?REGISTERWORDENUMPROCW,
lpszReading: ?[*:0]const u16,
param3: u32,
lpszRegister: ?[*:0]const u16,
param5: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmDisableIME(
param0: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmEnumInputContext(
idThread: u32,
lpfn: ?IMCENUMPROC,
lParam: LPARAM,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetImeMenuItemsA(
param0: ?HIMC,
param1: u32,
param2: u32,
lpImeParentMenu: ?*IMEMENUITEMINFOA,
// TODO: what to do with BytesParamIndex 5?
lpImeMenu: ?*IMEMENUITEMINFOA,
dwSize: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmGetImeMenuItemsW(
param0: ?HIMC,
param1: u32,
param2: u32,
lpImeParentMenu: ?*IMEMENUITEMINFOW,
// TODO: what to do with BytesParamIndex 5?
lpImeMenu: ?*IMEMENUITEMINFOW,
dwSize: u32,
) callconv(@import("std").os.windows.WINAPI) u32;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmDisableTextFrameService(
idThread: u32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows8.0'
pub extern "IMM32" fn ImmDisableLegacyIME(
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmGetHotKey(
param0: u32,
lpuModifiers: ?*u32,
lpuVKey: ?*u32,
phKL: ?*isize,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmSetHotKey(
param0: u32,
param1: u32,
param2: u32,
param3: ?HKL,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmGenerateMessage(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmRequestMessageA(
param0: ?HIMC,
param1: WPARAM,
param2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
// TODO: this type is limited to platform 'windows5.1.2600'
pub extern "IMM32" fn ImmRequestMessageW(
param0: ?HIMC,
param1: WPARAM,
param2: LPARAM,
) callconv(@import("std").os.windows.WINAPI) LRESULT;
pub extern "IMM32" fn ImmCreateSoftKeyboard(
param0: u32,
param1: ?HWND,
param2: i32,
param3: i32,
) callconv(@import("std").os.windows.WINAPI) ?HWND;
pub extern "IMM32" fn ImmDestroySoftKeyboard(
param0: ?HWND,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmShowSoftKeyboard(
param0: ?HWND,
param1: i32,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmLockIMC(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) ?*INPUTCONTEXT;
pub extern "IMM32" fn ImmUnlockIMC(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmGetIMCLockCount(
param0: ?HIMC,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "IMM32" fn ImmCreateIMCC(
param0: u32,
) callconv(@import("std").os.windows.WINAPI) ?HIMCC;
pub extern "IMM32" fn ImmDestroyIMCC(
param0: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) ?HIMCC;
pub extern "IMM32" fn ImmLockIMCC(
param0: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
pub extern "IMM32" fn ImmUnlockIMCC(
param0: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) BOOL;
pub extern "IMM32" fn ImmGetIMCCLockCount(
param0: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) u32;
pub extern "IMM32" fn ImmReSizeIMCC(
param0: ?HIMCC,
param1: u32,
) callconv(@import("std").os.windows.WINAPI) ?HIMCC;
pub extern "IMM32" fn ImmGetIMCCSize(
param0: ?HIMCC,
) callconv(@import("std").os.windows.WINAPI) u32;
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (25)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
.ansi => struct {
pub const REGISTERWORD = thismodule.REGISTERWORDA;
pub const STYLEBUF = thismodule.STYLEBUFA;
pub const IMEMENUITEMINFO = thismodule.IMEMENUITEMINFOA;
pub const REGISTERWORDENUMPROC = thismodule.REGISTERWORDENUMPROCA;
pub const IEnumRegisterWord = thismodule.IEnumRegisterWordA;
pub const ImmInstallIME = thismodule.ImmInstallIMEA;
pub const ImmGetDescription = thismodule.ImmGetDescriptionA;
pub const ImmGetIMEFileName = thismodule.ImmGetIMEFileNameA;
pub const ImmGetCompositionString = thismodule.ImmGetCompositionStringA;
pub const ImmSetCompositionString = thismodule.ImmSetCompositionStringA;
pub const ImmGetCandidateListCount = thismodule.ImmGetCandidateListCountA;
pub const ImmGetCandidateList = thismodule.ImmGetCandidateListA;
pub const ImmGetGuideLine = thismodule.ImmGetGuideLineA;
pub const ImmGetCompositionFont = thismodule.ImmGetCompositionFontA;
pub const ImmSetCompositionFont = thismodule.ImmSetCompositionFontA;
pub const ImmConfigureIME = thismodule.ImmConfigureIMEA;
pub const ImmEscape = thismodule.ImmEscapeA;
pub const ImmGetConversionList = thismodule.ImmGetConversionListA;
pub const ImmIsUIMessage = thismodule.ImmIsUIMessageA;
pub const ImmRegisterWord = thismodule.ImmRegisterWordA;
pub const ImmUnregisterWord = thismodule.ImmUnregisterWordA;
pub const ImmGetRegisterWordStyle = thismodule.ImmGetRegisterWordStyleA;
pub const ImmEnumRegisterWord = thismodule.ImmEnumRegisterWordA;
pub const ImmGetImeMenuItems = thismodule.ImmGetImeMenuItemsA;
pub const ImmRequestMessage = thismodule.ImmRequestMessageA;
},
.wide => struct {
pub const REGISTERWORD = thismodule.REGISTERWORDW;
pub const STYLEBUF = thismodule.STYLEBUFW;
pub const IMEMENUITEMINFO = thismodule.IMEMENUITEMINFOW;
pub const REGISTERWORDENUMPROC = thismodule.REGISTERWORDENUMPROCW;
pub const IEnumRegisterWord = thismodule.IEnumRegisterWordW;
pub const ImmInstallIME = thismodule.ImmInstallIMEW;
pub const ImmGetDescription = thismodule.ImmGetDescriptionW;
pub const ImmGetIMEFileName = thismodule.ImmGetIMEFileNameW;
pub const ImmGetCompositionString = thismodule.ImmGetCompositionStringW;
pub const ImmSetCompositionString = thismodule.ImmSetCompositionStringW;
pub const ImmGetCandidateListCount = thismodule.ImmGetCandidateListCountW;
pub const ImmGetCandidateList = thismodule.ImmGetCandidateListW;
pub const ImmGetGuideLine = thismodule.ImmGetGuideLineW;
pub const ImmGetCompositionFont = thismodule.ImmGetCompositionFontW;
pub const ImmSetCompositionFont = thismodule.ImmSetCompositionFontW;
pub const ImmConfigureIME = thismodule.ImmConfigureIMEW;
pub const ImmEscape = thismodule.ImmEscapeW;
pub const ImmGetConversionList = thismodule.ImmGetConversionListW;
pub const ImmIsUIMessage = thismodule.ImmIsUIMessageW;
pub const ImmRegisterWord = thismodule.ImmRegisterWordW;
pub const ImmUnregisterWord = thismodule.ImmUnregisterWordW;
pub const ImmGetRegisterWordStyle = thismodule.ImmGetRegisterWordStyleW;
pub const ImmEnumRegisterWord = thismodule.ImmEnumRegisterWordW;
pub const ImmGetImeMenuItems = thismodule.ImmGetImeMenuItemsW;
pub const ImmRequestMessage = thismodule.ImmRequestMessageW;
},
.unspecified => if (@import("builtin").is_test) struct {
pub const REGISTERWORD = *opaque{};
pub const STYLEBUF = *opaque{};
pub const IMEMENUITEMINFO = *opaque{};
pub const REGISTERWORDENUMPROC = *opaque{};
pub const IEnumRegisterWord = *opaque{};
pub const ImmInstallIME = *opaque{};
pub const ImmGetDescription = *opaque{};
pub const ImmGetIMEFileName = *opaque{};
pub const ImmGetCompositionString = *opaque{};
pub const ImmSetCompositionString = *opaque{};
pub const ImmGetCandidateListCount = *opaque{};
pub const ImmGetCandidateList = *opaque{};
pub const ImmGetGuideLine = *opaque{};
pub const ImmGetCompositionFont = *opaque{};
pub const ImmSetCompositionFont = *opaque{};
pub const ImmConfigureIME = *opaque{};
pub const ImmEscape = *opaque{};
pub const ImmGetConversionList = *opaque{};
pub const ImmIsUIMessage = *opaque{};
pub const ImmRegisterWord = *opaque{};
pub const ImmUnregisterWord = *opaque{};
pub const ImmGetRegisterWordStyle = *opaque{};
pub const ImmEnumRegisterWord = *opaque{};
pub const ImmGetImeMenuItems = *opaque{};
pub const ImmRequestMessage = *opaque{};
} else struct {
pub const REGISTERWORD = @compileError("'REGISTERWORD' requires that UNICODE be set to true or false in the root module");
pub const STYLEBUF = @compileError("'STYLEBUF' requires that UNICODE be set to true or false in the root module");
pub const IMEMENUITEMINFO = @compileError("'IMEMENUITEMINFO' requires that UNICODE be set to true or false in the root module");
pub const REGISTERWORDENUMPROC = @compileError("'REGISTERWORDENUMPROC' requires that UNICODE be set to true or false in the root module");
pub const IEnumRegisterWord = @compileError("'IEnumRegisterWord' requires that UNICODE be set to true or false in the root module");
pub const ImmInstallIME = @compileError("'ImmInstallIME' requires that UNICODE be set to true or false in the root module");
pub const ImmGetDescription = @compileError("'ImmGetDescription' requires that UNICODE be set to true or false in the root module");
pub const ImmGetIMEFileName = @compileError("'ImmGetIMEFileName' requires that UNICODE be set to true or false in the root module");
pub const ImmGetCompositionString = @compileError("'ImmGetCompositionString' requires that UNICODE be set to true or false in the root module");
pub const ImmSetCompositionString = @compileError("'ImmSetCompositionString' requires that UNICODE be set to true or false in the root module");
pub const ImmGetCandidateListCount = @compileError("'ImmGetCandidateListCount' requires that UNICODE be set to true or false in the root module");
pub const ImmGetCandidateList = @compileError("'ImmGetCandidateList' requires that UNICODE be set to true or false in the root module");
pub const ImmGetGuideLine = @compileError("'ImmGetGuideLine' requires that UNICODE be set to true or false in the root module");
pub const ImmGetCompositionFont = @compileError("'ImmGetCompositionFont' requires that UNICODE be set to true or false in the root module");
pub const ImmSetCompositionFont = @compileError("'ImmSetCompositionFont' requires that UNICODE be set to true or false in the root module");
pub const ImmConfigureIME = @compileError("'ImmConfigureIME' requires that UNICODE be set to true or false in the root module");
pub const ImmEscape = @compileError("'ImmEscape' requires that UNICODE be set to true or false in the root module");
pub const ImmGetConversionList = @compileError("'ImmGetConversionList' requires that UNICODE be set to true or false in the root module");
pub const ImmIsUIMessage = @compileError("'ImmIsUIMessage' requires that UNICODE be set to true or false in the root module");
pub const ImmRegisterWord = @compileError("'ImmRegisterWord' requires that UNICODE be set to true or false in the root module");
pub const ImmUnregisterWord = @compileError("'ImmUnregisterWord' requires that UNICODE be set to true or false in the root module");
pub const ImmGetRegisterWordStyle = @compileError("'ImmGetRegisterWordStyle' requires that UNICODE be set to true or false in the root module");
pub const ImmEnumRegisterWord = @compileError("'ImmEnumRegisterWord' requires that UNICODE be set to true or false in the root module");
pub const ImmGetImeMenuItems = @compileError("'ImmGetImeMenuItems' requires that UNICODE be set to true or false in the root module");
pub const ImmRequestMessage = @compileError("'ImmRequestMessage' requires that UNICODE be set to true or false in the root module");
},
};
//--------------------------------------------------------------------------------
// Section: Imports (24)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const BSTR = @import("../../foundation.zig").BSTR;
const CHAR = @import("../../foundation.zig").CHAR;
const HBITMAP = @import("../../graphics/gdi.zig").HBITMAP;
const HICON = @import("../../ui/windows_and_messaging.zig").HICON;
const HIMC = @import("../../globalization.zig").HIMC;
const HIMCC = @import("../../globalization.zig").HIMCC;
const HKL = @import("../../ui/text_services.zig").HKL;
const HRESULT = @import("../../foundation.zig").HRESULT;
const HWND = @import("../../foundation.zig").HWND;
const IClassFactory = @import("../../system/com.zig").IClassFactory;
const IUnknown = @import("../../system/com.zig").IUnknown;
const LOGFONTA = @import("../../graphics/gdi.zig").LOGFONTA;
const LOGFONTW = @import("../../graphics/gdi.zig").LOGFONTW;
const LPARAM = @import("../../foundation.zig").LPARAM;
const LRESULT = @import("../../foundation.zig").LRESULT;
const MSG = @import("../../ui/windows_and_messaging.zig").MSG;
const POINT = @import("../../foundation.zig").POINT;
const PSTR = @import("../../foundation.zig").PSTR;
const PWSTR = @import("../../foundation.zig").PWSTR;
const RECT = @import("../../foundation.zig").RECT;
const SAFEARRAY = @import("../../system/com.zig").SAFEARRAY;
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(), "IMCENUMPROC")) { _ = IMCENUMPROC; }
if (@hasDecl(@This(), "REGISTERWORDENUMPROCA")) { _ = REGISTERWORDENUMPROCA; }
if (@hasDecl(@This(), "REGISTERWORDENUMPROCW")) { _ = REGISTERWORDENUMPROCW; }
if (@hasDecl(@This(), "PFNLOG")) { _ = PFNLOG; }
if (@hasDecl(@This(), "fpCreateIFECommonInstanceType")) { _ = fpCreateIFECommonInstanceType; }
if (@hasDecl(@This(), "fpCreateIFELanguageInstanceType")) { _ = fpCreateIFELanguageInstanceType; }
if (@hasDecl(@This(), "fpCreateIFEDictionaryInstanceType")) { _ = fpCreateIFEDictionaryInstanceType; }
@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/ui/input/ime.zig |
const std = @import("std");
const math = std.math;
usingnamespace @import("vec.zig");
usingnamespace @import("rotor.zig");
usingnamespace @import("xform.zig");
/// A 3x3 matrix. When required to choose, this library uses
/// the column-major convention.
pub const Mat3 = extern struct {
x: Vec3,
y: Vec3,
z: Vec3,
pub const Identity = Mat3{
.x = Vec3.X,
.y = Vec3.Y,
.z = Vec3.Z,
};
pub inline fn row(self: Mat3, comptime n: usize) Vec3 {
return switch (n) {
0 => Vec3.init(self.x.x, self.y.x, self.z.x),
1 => Vec3.init(self.x.y, self.y.y, self.z.y),
2 => Vec3.init(self.x.z, self.y.z, self.z.z),
else => @compileError("row must be 0, 1, or 2"),
};
}
pub inline fn col(self: Mat3, comptime n: usize) Vec3 {
return switch (n) {
0 => self.x,
1 => self.y,
2 => self.z,
else => @compileError("col must be 0, 1, or 2"),
};
}
pub fn preScaleVec(l: Mat3, r: Vec3) Mat3 {
return Mat3{
.x = l.x.scale(r.x),
.y = l.y.scale(r.y),
.z = l.z.scale(r.z),
};
}
pub fn postScaleVec(l: Mat3, r: Vec3) Mat3 {
return Mat3{
.x = l.x.mul(r),
.y = l.y.mul(r),
.z = l.z.mul(r),
};
}
pub fn scale(l: Mat3, r: f32) Mat3 {
return Mat3{
.x = l.x.scale(r),
.y = l.y.scale(r),
.z = l.z.scale(r),
};
}
pub fn preRotate(self: Mat3, r: Rotor3) Mat3 {
return Generic.preRotateMat3(self, r);
}
pub fn postRotate(self: Mat3, r: Rotor3) Mat3 {
return Generic.preRotateMat3(self, r);
}
pub fn mulVec(l: Mat3, r: Vec3) Vec3 {
return Generic.mulMat3Vec3(l, r);
}
pub fn transpose(self: Mat3) Mat3 {
return Generic.transpose3x3(self);
}
pub fn determinant(m: Mat3) f32 {
return Generic.determinant3x3(m);
}
pub fn inverse(m: Mat3) !Mat3 {
return try Generic.inverse3x3(m);
}
pub fn transposedInverse(m: Mat3) !Mat3 {
return try Generic.transposedInverse3x3(m);
}
pub fn mulMat(l: Mat3, r: Mat3) Mat3 {
return Generic.mulMat3Mat3(l, r);
}
pub fn mulMat4x3(l: Mat3, r: Mat4x3) Mat4x3 {
return Generic.mulMat3Mat4x3(l, r);
}
pub fn mulMat4(l: Mat3, r: Mat4) Mat4 {
return Generic.mulMat3Mat4(l, r);
}
pub inline fn asBuf(self: *Mat3) *[9]f32 {
return @ptrCast(*[9]f32, self);
}
pub inline fn asGrid(self: *Mat3) *[3][3]f32 {
return @ptrCast(*[3][3]f32, self);
}
pub inline fn toMat4x3(self: Mat3, translation: Vec3) Mat4x3 {
return Mat4x3{
.x = self.x,
.y = self.y,
.z = self.z,
.w = translation,
};
}
pub inline fn toMat4(self: Mat3, translation: Vec3) Mat4 {
return Mat4{
.x = self.x.toVec4(0),
.y = self.y.toVec4(0),
.z = self.z.toVec4(0),
.w = translation.toVec4(1),
};
}
/// Constructs a Mat4 with this matrix as the rotation/scale part,
pub inline fn toMat4Projection(self: Mat3, translation: Vec3, projection: Vec4) Mat4 {
return Mat4{
.x = self.x.toVec4(projection.x),
.y = self.y.toVec4(projection.y),
.z = self.z.toVec4(projection.z),
.w = translation.toVec4(projection.w),
};
}
};
/// A 4x3 matrix. When required to choose, this library uses
/// the column-major convention.
pub const Mat4x3 = extern struct {
x: Vec3,
y: Vec3,
z: Vec3,
w: Vec3,
pub const Identity = Mat4x3{
.x = Vec3.X,
.y = Vec3.Y,
.z = Vec3.Z,
.w = Vec3.Zero,
};
pub inline fn row(self: Mat4x3, comptime n: usize) Vec4 {
return switch (n) {
0 => Vec4.init(self.x.x, self.y.x, self.z.x, self.w.x),
1 => Vec4.init(self.x.y, self.y.y, self.z.y, self.w.y),
2 => Vec4.init(self.x.z, self.y.z, self.z.z, self.w.z),
else => @compileError("row must be 0, 1, or 2"),
};
}
pub inline fn col(self: Mat4x3, comptime n: usize) Vec3 {
return switch (n) {
0 => self.x,
1 => self.y,
2 => self.z,
3 => self.w,
else => @compileError("col must be 0, 1, 2, or 3"),
};
}
pub fn preScaleVec(l: Mat4x3, r: Vec3) Mat4x3 {
return Mat4x3{
.x = l.x.scale(r.x),
.y = l.y.scale(r.y),
.z = l.z.scale(r.z),
.w = l.w,
};
}
pub fn postScaleVec(l: Mat4x3, r: Vec3) Mat4x3 {
return Mat4x3{
.x = l.x.mul(r),
.y = l.y.mul(r),
.z = l.z.mul(r),
.w = l.w.mul(r),
};
}
pub fn preScale(l: Mat4x3, r: f32) Mat4x3 {
return Mat4x3{
.x = l.x.scale(r),
.y = l.y.scale(r),
.z = l.z.scale(r),
.w = l.w,
};
}
pub fn postScale(l: Mat4x3, r: f32) Mat4x3 {
return Mat4x3{
.x = l.x.scale(r),
.y = l.y.scale(r),
.z = l.z.scale(r),
.w = l.w.scale(r),
};
}
pub inline fn preTranslate(l: Mat4x3, trans: Vec3) Mat4x3 {
return Mat4x3{
.x = l.x,
.y = l.y,
.z = l.z,
.w = Vec3{
.x = l.x.x * trans.x + l.y.x * trans.y + l.z.x * trans.z + l.w.x,
.y = l.x.y * trans.x + l.y.y * trans.y + l.z.y * trans.z + l.w.y,
.z = l.x.z * trans.x + l.y.z * trans.y + l.z.z * trans.z + l.w.z,
},
};
}
pub inline fn postTranslate(l: Mat4x3, trans: Vec3) Mat4x3 {
return Mat4x3{
.x = l.x,
.y = l.y,
.z = l.z,
.w = l.w.add(trans),
};
}
pub fn preRotate(self: Mat4x3, r: Rotor3) Mat4x3 {
return Generic.preRotateMat4x3(self, r);
}
pub fn postRotate(self: Mat4x3, r: Rotor3) Mat4x3 {
return Generic.preRotateMat4x3(self, r);
}
pub fn mul3x3Vec(l: Mat4x3, r: Vec3) Vec3 {
return Generic.mulMat3Vec3(l, r);
}
pub fn mulVec3(l: Mat4x3, r: Vec3) Vec3 {
return Generic.mulMat4x3Vec3(l, r);
}
pub fn mulVec(l: Mat4x3, r: Vec4) Vec3 {
return Generic.mulMat4x3Vec4(l, r);
}
pub fn inverse(self: Mat4x3) !Mat4x3 {
return try Generic.inverse4x3(self);
}
pub fn mulMat3(l: Mat4x3, r: Mat3) Mat4x3 {
return Generic.mulMat4x3Mat3(l, r);
}
pub fn mulMat(l: Mat4x3, r: Mat4x3) Mat4x3 {
return Generic.mulMat4x3Mat4x3(l, r);
}
pub fn mulMat4(l: Mat4x3, r: Mat4) Mat4 {
return Generic.mulMat4x3Mat4(l, r);
}
pub inline fn asBuf(self: *Mat4x3) *[12]f32 {
return @ptrCast(*[12]f32, self);
}
pub inline fn asGrid(self: *Mat4x3) *[4][3]f32 {
return @ptrCast(*[4][3]f32, self);
}
pub inline fn asMat3(self: *Mat4x3) *Mat3 {
return @ptrCast(*Mat3, self);
}
pub inline fn toMat3(self: Mat4x3) Mat3 {
return Mat3{
.x = self.x,
.y = self.y,
.z = self.z,
};
}
/// Constructs a Mat4 with this matrix as the rotation/scale/translation part,
pub inline fn toMat4(self: Mat4x3) Mat4 {
return Mat4{
.x = self.x.toVec4(0),
.y = self.y.toVec4(0),
.z = self.z.toVec4(0),
.w = self.w.toVec4(1),
};
}
/// Constructs a Mat4 with this matrix as the rotation/scale/translation part,
pub inline fn toMat4Projection(self: Mat4x3, projection: Vec4) Mat4 {
return Mat4{
.x = self.x.toVec4(projection.x),
.y = self.y.toVec4(projection.y),
.z = self.z.toVec4(projection.z),
.w = self.w.toVec4(projection.w),
};
}
};
/// A 4x4 matrix. When required to choose, this library uses
/// the column-major convention.
pub const Mat4 = extern struct {
x: Vec4,
y: Vec4,
z: Vec4,
w: Vec4,
pub const Identity = Mat4{
.x = Vec4.X,
.y = Vec4.Y,
.z = Vec4.Z,
.w = Vec4.W,
};
pub inline fn row(self: Mat4, comptime n: usize) Vec4 {
return switch (n) {
0 => Vec4.init(self.x.x, self.y.x, self.z.x, self.w.x),
1 => Vec4.init(self.x.y, self.y.y, self.z.y, self.w.y),
2 => Vec4.init(self.x.z, self.y.z, self.z.z, self.w.z),
3 => Vec4.init(self.x.w, self.y.w, self.z.w, self.w.w),
else => @compileError("row must be 0, 1, 2, or 3"),
};
}
pub inline fn col(self: Mat4, comptime n: usize) Vec4 {
return switch (n) {
0 => self.x,
1 => self.y,
2 => self.z,
3 => self.w,
else => @compileError("col must be 0, 1, 2, or 3"),
};
}
pub fn preScaleVec(l: Mat4, r: Vec3) Mat4 {
return Mat4{
.x = l.x.scale(r.x),
.y = l.y.scale(r.y),
.z = l.z.scale(r.z),
.w = l.w,
};
}
pub fn postScaleVec(l: Mat4, r: Vec3) Mat4 {
return Mat4{
.x = Vec4.init(l.x.x * r.x, l.x.y * r.y, l.x.z * r.z, l.x.w),
.y = Vec4.init(l.y.x * r.x, l.y.y * r.y, l.y.z * r.z, l.y.w),
.z = Vec4.init(l.z.x * r.x, l.z.y * r.y, l.z.z * r.z, l.z.w),
.w = Vec4.init(l.w.z * r.x, l.w.y * r.y, l.w.z * r.z, l.w.w),
};
}
pub fn preScale(l: Mat4, r: f32) Mat4 {
return Mat4{
.x = l.x.scale(r),
.y = l.y.scale(r),
.z = l.z.scale(r),
.w = l.w,
};
}
pub fn postScale(l: Mat4, r: f32) Mat4 {
return Mat4{
.x = l.x.scale(r),
.y = l.y.scale(r),
.z = l.z.scale(r),
.w = l.w.scale(r),
};
}
pub inline fn preTranslate(l: Mat4, trans: Vec3) Mat4 {
return Mat4{
.x = l.x,
.y = l.y,
.z = l.z,
.w = Vec4{
.x = l.x.x * trans.x + l.y.x * trans.y + l.z.x * trans.z + l.w.x,
.y = l.x.y * trans.x + l.y.y * trans.y + l.z.y * trans.z + l.w.y,
.z = l.x.z * trans.x + l.y.z * trans.y + l.z.z * trans.z + l.w.z,
.w = l.w.w,
},
};
}
pub inline fn postTranslate(l: Mat4, trans: Vec3) Mat4 {
return Mat4{
.x = l.x,
.y = l.y,
.z = l.z,
.w = Vec4{
.x = l.w.x + trans.x,
.y = l.w.y + trans.y,
.z = l.w.z + trans.z,
.w = l.w.w,
},
};
}
pub fn project(l: Mat4, r: Vec3) Vec3 {
const raw = Generic.mulMat4x3Vec3(l, r);
const w = l.x.w * r.x + l.y.w * r.y + l.z.w * r.z + l.w.w;
return raw.scale(1.0 / w);
}
pub fn mulVec(l: Mat4, r: Vec4) Vec4 {
return Generic.mulMat4Vec4(l, r);
}
pub fn mulMat3(l: Mat4, r: Mat3) Mat4 {
return Generic.mulMat4Mat3(l, r);
}
pub fn mulMat4x3(l: Mat4, r: Mat4x3) Mat4 {
return Generic.mulMat4Mat4x3(l, r);
}
pub fn mulMat(l: Mat4, r: Mat4) Mat4 {
return Generic.mulMat4Mat4(l, r);
}
pub inline fn asBuf(self: *Mat4) *[16]f32 {
return @ptrCast(*[16]f32, self);
}
pub inline fn asGrid(self: *Mat4) *[4][4]f32 {
return @ptrCast(*[4][4]f32, self);
}
pub inline fn toMat3(self: Mat4) Mat3 {
return Mat3{
.x = self.x.toVec3(),
.y = self.y.toVec3(),
.z = self.z.toVec3(),
};
}
pub inline fn toMat4x3(self: Mat4) Mat4x3 {
return Mat4x3{
.x = self.x.toVec3(),
.y = self.y.toVec3(),
.z = self.z.toVec3(),
.w = self.w.toVec3(),
};
}
};
pub const Generic = struct {
pub fn determinant3x3(m: var) f32 {
return m.x.x * (m.y.y * m.z.z - m.y.z * m.z.y) -
m.x.y * (m.y.x * m.z.z - m.y.z * m.z.x) +
m.x.z * (m.y.x * m.z.y - m.y.y * m.z.x);
}
pub fn inverse3x3(m: var) !Mat3 {
const det = @call(.{ .modifier = .always_inline }, determinant3x3, .{m});
const mult = 1.0 / det;
if (!math.isFinite(mult)) return error.Singular;
return Mat3{
.x = Vec3{
.x = (m.y.y * m.z.z - m.z.y * m.y.z) * mult,
.y = (m.x.z * m.z.y - m.x.y * m.z.z) * mult,
.z = (m.x.y * m.y.z - m.x.z * m.y.y) * mult,
},
.y = Vec3{
.x = (m.y.z * m.z.x - m.y.x * m.z.z) * mult,
.y = (m.x.x * m.z.z - m.x.z * m.z.x) * mult,
.z = (m.y.x * m.x.z - m.x.x * m.y.z) * mult,
},
.z = Vec3{
.x = (m.y.x * m.z.y - m.z.x * m.y.y) * mult,
.y = (m.z.x * m.x.y - m.x.x * m.z.y) * mult,
.z = (m.x.x * m.y.y - m.y.x * m.x.y) * mult,
},
};
}
pub fn transposedInverse3x3(m: var) !Mat3 {
const det = @call(.{ .modifier = .always_inline }, determinant3x3, .{m});
const mult = 1.0 / det;
if (!math.isFinite(mult)) return error.Singular;
return Mat3{
.x = Vec3{
.x = (m.y.y * m.z.z - m.z.y * m.y.z) * mult,
.y = (m.y.z * m.z.x - m.y.x * m.z.z) * mult,
.z = (m.y.x * m.z.y - m.z.x * m.y.y) * mult,
},
.y = Vec3{
.x = (m.x.z * m.z.y - m.x.y * m.z.z) * mult,
.y = (m.x.x * m.z.z - m.x.z * m.z.x) * mult,
.z = (m.z.x * m.x.y - m.x.x * m.z.y) * mult,
},
.z = Vec3{
.x = (m.x.y * m.y.z - m.x.z * m.y.y) * mult,
.y = (m.y.x * m.x.z - m.x.x * m.y.z) * mult,
.z = (m.x.x * m.y.y - m.y.x * m.x.y) * mult,
},
};
}
pub fn transpose3x3(m: var) Mat3 {
return Mat3{
.x = Vec3{
.x = m.x.x,
.y = m.y.x,
.z = m.z.x,
},
.y = Vec3{
.x = m.x.y,
.y = m.y.y,
.z = m.z.y,
},
.z = Vec3{
.x = m.x.z,
.y = m.y.z,
.z = m.z.z,
},
};
}
pub fn inverse4x3(m: var) !Mat4x3 {
var result: Mat4x3 = undefined;
result.asMat3().* = try inverse3x3(m);
result.w = Vec3.init(-m.w.x, -m.w.y, -m.w.z);
return result;
}
pub fn mulMat3Vec3(l: var, r: var) Vec3 {
return Vec3{
.x = l.x.x * r.x + l.y.x * r.y + l.z.x * r.z,
.y = l.x.y * r.x + l.y.y * r.y + l.z.y * r.z,
.z = l.x.z * r.x + l.y.z * r.y + l.z.z * r.z,
};
}
pub fn mulMat4x3Vec3(l: var, r: var) Vec3 {
return Vec3{
.x = l.x.x * r.x + l.y.x * r.y + l.z.x * r.z + l.w.x,
.y = l.x.y * r.x + l.y.y * r.y + l.z.y * r.z + l.w.y,
.z = l.x.z * r.x + l.y.z * r.y + l.z.z * r.z + l.w.z,
};
}
pub fn mulMat4x3Vec4(l: var, r: var) Vec3 {
return Vec3{
.x = l.x.x * r.x + l.y.x * r.y + l.z.x * r.z + l.w.x * r.w,
.y = l.x.y * r.x + l.y.y * r.y + l.z.y * r.z + l.w.y * r.w,
.z = l.x.z * r.x + l.y.z * r.y + l.z.z * r.z + l.w.z * r.w,
};
}
pub fn mulMat4Vec4(l: var, r: var) Vec4 {
return Vec4{
.x = l.x.x * r.x + l.y.x * r.y + l.z.x * r.z + l.w.x * r.w,
.y = l.x.y * r.x + l.y.y * r.y + l.z.y * r.z + l.w.y * r.w,
.z = l.x.z * r.x + l.y.z * r.y + l.z.z * r.z + l.w.z * r.w,
.w = l.x.w * r.x + l.y.w * r.y + l.z.w * r.z + l.w.w * r.w,
};
}
pub fn mulMat3Mat3(l: var, r: var) Mat3 {
return Mat3{
.x = Vec3{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
},
.y = Vec3{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
},
.z = Vec3{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
},
};
}
pub fn mulMat3Mat4x3(l: var, r: var) Mat4x3 {
return Mat4x3{
.x = Vec3{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
},
.y = Vec3{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
},
.z = Vec3{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
},
.w = Vec3{
.x = l.x.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z,
.y = l.x.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z,
.z = l.x.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z,
},
};
}
pub fn mulMat4x3Mat3(l: var, r: var) Mat4x3 {
return Mat4x3{
.x = Vec3{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
},
.y = Vec3{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
},
.z = Vec3{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
},
.w = l.w,
};
}
pub fn mulMat3Mat4(l: var, r: var) Mat4 {
return Mat4{
.x = Vec4{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
.w = r.x.w,
},
.y = Vec4{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
.w = r.y.w,
},
.z = Vec4{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
.w = r.z.w,
},
.w = Vec4{
.x = l.x.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z,
.y = l.x.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z,
.z = l.x.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z,
.w = r.w.w,
},
};
}
pub fn mulMat4Mat3(l: var, r: var) Mat4 {
return Mat4{
.x = Vec4{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
.w = l.x.w * r.x.x + l.y.w * r.x.y + l.z.w * r.x.z,
},
.y = Vec4{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
.w = l.x.w * r.y.x + l.y.w * r.y.y + l.z.w * r.y.z,
},
.z = Vec4{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
.w = l.x.w * r.z.x + l.y.w * r.z.y + l.z.w * r.z.z,
},
.w = l.w,
};
}
pub fn mulMat4x3Mat4x3(l: var, r: var) Mat4x3 {
return Mat4x3{
.x = Vec3{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
},
.y = Vec3{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
},
.z = Vec3{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
},
.w = Vec3{
.x = l.x.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z + l.w.x,
.y = l.x.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z + l.w.y,
.z = l.x.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z + l.w.z,
},
};
}
pub fn mulMat4Mat4x3(l: var, r: var) Mat4 {
return Mat4{
.x = Vec4{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z,
.w = l.x.w * r.x.x + l.y.w * r.x.y + l.z.w * r.x.z,
},
.y = Vec4{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z,
.w = l.x.w * r.y.x + l.y.w * r.y.y + l.z.w * r.y.z,
},
.z = Vec4{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z,
.w = l.x.w * r.z.x + l.y.w * r.z.y + l.z.w * r.z.z,
},
.w = Vec4{
.x = l.w.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z + l.w.x,
.y = l.w.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z + l.w.y,
.z = l.w.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z + l.w.z,
.w = l.w.w * r.w.x + l.y.w * r.w.y + l.z.w * r.w.z + l.w.w,
},
};
}
pub fn mulMat4x3Mat4(l: var, r: var) Mat4 {
return Mat4{
.x = Vec4{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z + l.w.x * r.x.w,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z + l.w.y * r.x.w,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z + l.w.z * r.x.w,
.w = r.x.w,
},
.y = Vec4{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z + l.w.x * r.y.w,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z + l.w.y * r.y.w,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z + l.w.z * r.y.w,
.w = r.y.w,
},
.z = Vec4{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z + l.w.x * r.z.w,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z + l.w.y * r.z.w,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z + l.w.z * r.z.w,
.w = r.z.w,
},
.w = Vec4{
.x = l.x.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z + l.w.x * r.w.w,
.y = l.x.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z + l.w.y * r.w.w,
.z = l.x.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z + l.w.z * r.w.w,
.w = r.w.w,
},
};
}
pub fn mulMat4Mat4(l: var, r: var) Mat4 {
return Mat4{
.x = Vec4{
.x = l.x.x * r.x.x + l.y.x * r.x.y + l.z.x * r.x.z + l.w.x * r.x.w,
.y = l.x.y * r.x.x + l.y.y * r.x.y + l.z.y * r.x.z + l.w.y * r.x.w,
.z = l.x.z * r.x.x + l.y.z * r.x.y + l.z.z * r.x.z + l.w.z * r.x.w,
.w = l.x.w * r.x.x + l.y.w * r.x.y + l.z.w * r.x.z + l.w.w * r.x.w,
},
.y = Vec4{
.x = l.x.x * r.y.x + l.y.x * r.y.y + l.z.x * r.y.z + l.w.x * r.y.w,
.y = l.x.y * r.y.x + l.y.y * r.y.y + l.z.y * r.y.z + l.w.y * r.y.w,
.z = l.x.z * r.y.x + l.y.z * r.y.y + l.z.z * r.y.z + l.w.z * r.y.w,
.w = l.x.w * r.y.x + l.y.w * r.y.y + l.z.w * r.y.z + l.w.w * r.y.w,
},
.z = Vec4{
.x = l.x.x * r.z.x + l.y.x * r.z.y + l.z.x * r.z.z + l.w.x * r.z.w,
.y = l.x.y * r.z.x + l.y.y * r.z.y + l.z.y * r.z.z + l.w.y * r.z.w,
.z = l.x.z * r.z.x + l.y.z * r.z.y + l.z.z * r.z.z + l.w.z * r.z.w,
.w = l.x.w * r.z.x + l.y.w * r.z.y + l.z.w * r.z.z + l.w.w * r.z.w,
},
.w = Vec4{
.x = l.x.x * r.w.x + l.y.x * r.w.y + l.z.x * r.w.z + l.w.x * r.w.w,
.y = l.x.y * r.w.x + l.y.y * r.w.y + l.z.y * r.w.z + l.w.y * r.w.w,
.z = l.x.z * r.w.x + l.y.z * r.w.y + l.z.z * r.w.z + l.w.z * r.w.w,
.w = l.x.w * r.w.x + l.y.w * r.w.y + l.z.w * r.w.z + l.w.w * r.w.w,
},
};
}
pub fn preScaleMat3Vec(l: var, r: Vec3) Mat3 {
return Mat3{
.x = Vec3.init(l.x.x, l.x.y, l.x.z).scale(r.x),
.y = Vec3.init(l.y.x, l.y.y, l.z.z).scale(r.y),
.z = Vec3.init(l.z.x, l.z.y, l.z.z).scale(r.z),
};
}
pub fn postScaleMat3Vec(l: var, r: Vec3) Mat3 {
return Mat3{
.x = Vec3.init(l.x.x, l.x.y, l.x.z).mul(r),
.y = Vec3.init(l.y.x, l.y.y, l.z.z).mul(r),
.z = Vec3.init(l.z.x, l.z.y, l.z.z).mul(r),
};
}
pub fn postRotateMat3(l: var, r: Rotor3) Mat3 {
return Mat3{
.x = @call(.{ .modifier = .always_inline }, Rotor3.apply, .{ r, Vec3.init(l.x.x, l.x.y, l.x.z) }),
.y = @call(.{ .modifier = .always_inline }, Rotor3.apply, .{ r, Vec3.init(l.y.x, l.y.y, l.y.z) }),
.z = @call(.{ .modifier = .always_inline }, Rotor3.apply, .{ r, Vec3.init(l.z.x, l.z.y, l.z.z) }),
};
}
pub fn postRotateMat4x3(l: var, r: Rotor3) Mat4x3 {
var result: Mat4x3 = undefined;
setMat3(&result, postRotateMat3(l, r));
result.w = Vec3.init(l.w.x, l.w.y, l.w.z);
return result;
}
pub fn preRotateMat3(l: var, r: Rotor3) Mat3 {
return mulMat3Mat3(l, r.toMat3());
}
pub fn preRotateMat4x3(l: var, r: Rotor3) Mat4x3 {
return mulMat4x3Mat3(l, r.toMat3());
}
pub inline fn setMat3(dest: var, src: var) void {
dest.x.x = src.x.x;
dest.x.y = src.x.y;
dest.x.z = src.x.z;
dest.y.x = src.y.x;
dest.y.y = src.y.y;
dest.y.z = src.y.z;
dest.z.x = src.z.x;
dest.z.y = src.z.y;
dest.z.z = src.z.z;
}
pub inline fn setMat4x3(dest: var, src: var) void {
dest.x.x = src.x.x;
dest.x.y = src.x.y;
dest.x.z = src.x.z;
dest.y.x = src.y.x;
dest.y.y = src.y.y;
dest.y.z = src.y.z;
dest.z.x = src.z.x;
dest.z.y = src.z.y;
dest.z.z = src.z.z;
dest.w.x = src.w.x;
dest.w.y = src.w.y;
dest.w.z = src.w.z;
}
pub inline fn extractPreScale3NoFlip(m: var) Vec3 {
return Vec3{
.x = Vec3.init(m.x.x, m.x.y, m.x.z).len(),
.y = Vec3.init(m.y.x, m.y.y, m.y.z).len(),
.z = Vec3.init(m.z.x, m.z.y, m.z.z).len(),
};
}
pub inline fn extractPreScale3(m: var) Vec3 {
var scale = extractPreScale3NoFlip(m);
scale.x = math.copysign(determinant3x3(m), scale.x);
}
pub fn extractTransform3x3(m: var) Transform3 {
var scale = extractPreScale3NoFlip(m);
const invScale = Vec3.init(1 / scale.x, 1 / scale.y, 1 / scale.z);
var unit = postScaleMat3Vec(m, invScale);
const det = determinant3x3(unit);
// If the determinant is not approx 1, this matrix has shear and
// we cannot decompose it.
assert(math.approxEq(f32, 1, math.fabs(det), 1e-4));
if (det < 0) {
// this matrix inverts chirality. Flip a scale and one of the matrix bases.
scale.x = -scale.x;
unit.x = unit.x.negate();
}
return Transform3{
.rotation = Rotor3.fromMatrix(unit),
.translation = Vec3.Zero,
.scale = scale,
};
}
pub fn extractTransform4x3(m: var) Transform3 {
var scale = extractPreScale3NoFlip(m);
const invScale = Vec3.init(1 / scale.x, 1 / scale.y, 1 / scale.z);
var unit = postScaleMat3Vec(m, invScale);
const det = determinant3x3(unit);
// If the determinant is not approx 1, this matrix has shear and
// we cannot decompose it.
assert(math.approxEq(f32, 1, math.fabs(det), 1e-4));
if (det < 0) {
// this matrix inverts chirality. Flip a scale and one of the matrix bases.
scale.x = -scale.x;
unit.x = unit.x.negate();
}
return Transform3{
.rotation = Rotor3.fromMatrix(unit),
.translation = Vec3.init(m.w.x, m.w.y, m.w.z),
.scale = scale,
};
}
};
pub fn symmetricOrtho(width: f32, height: f32, near: f32, far: f32) Mat4 {
return ortho(-width * 0.5, width * 0.5, height * 0.5, -height * 0.5, near, far);
}
pub fn ortho(left: f32, right: f32, top: f32, bottom: f32, near: f32, far: f32) Mat4 {
return Mat4{
.x = Vec4{
.x = 1 / (right - left),
.y = 0,
.z = 0,
.w = 0,
},
.y = Vec4{
.x = 0,
.y = 1 / (top - bottom),
.z = 0,
.w = 0,
},
.z = Vec4{
.x = 0,
.y = 0,
.z = 1 / (far - near),
.w = 0,
},
.w = Vec4{
.x = -(right + left) / (right - left),
.y = -(top + bottom) / (top - bottom),
.z = -(far + near) / (far - near) + 0.5,
.w = 1,
},
};
}
test "compile Mat3" {
var a = Mat3.Identity;
var b = a;
_ = a.row(0);
_ = a.row(1);
_ = a.row(2);
_ = a.col(0);
_ = a.col(1);
_ = a.col(2);
_ = a.preScaleVec(Vec3.X);
_ = a.postScaleVec(Vec3.Y);
_ = a.scale(4);
_ = a.preRotate(Rotor3.Identity);
_ = a.postRotate(Rotor3.Identity);
_ = a.mulVec(Vec3.Z);
_ = a.transpose();
_ = a.determinant();
_ = try a.inverse();
_ = try a.transposedInverse();
_ = a.mulMat(b);
_ = a.mulMat4x3(Mat4x3.Identity);
_ = a.mulMat4(Mat4.Identity);
_ = a.asBuf();
_ = a.asGrid();
_ = a.toMat4x3(Vec3.Zero);
_ = a.toMat4(Vec3.Zero);
_ = a.toMat4Projection(Vec3.Zero, Vec4.W);
}
test "compile Mat4x3" {
var a = Mat4x3.Identity;
var b = a;
_ = a.row(0);
_ = a.row(1);
_ = a.row(2);
_ = a.col(0);
_ = a.col(1);
_ = a.col(2);
_ = a.col(3);
_ = a.preScaleVec(Vec3.X);
_ = a.postScaleVec(Vec3.Y);
_ = a.preScale(4);
_ = a.postScale(0.25);
_ = a.preTranslate(Vec3.X);
_ = a.postTranslate(Vec3.Y);
_ = a.preRotate(Rotor3.Identity);
_ = a.postRotate(Rotor3.Identity);
_ = a.mul3x3Vec(Vec3.Z);
_ = a.mulVec3(Vec3.X);
_ = a.mulVec(Vec4.W);
_ = try a.inverse();
_ = a.mulMat3(Mat3.Identity);
_ = a.mulMat(b);
_ = a.mulMat4(Mat4.Identity);
_ = a.asBuf();
_ = a.asGrid();
_ = a.asMat3();
_ = a.toMat3();
_ = a.toMat4();
_ = a.toMat4Projection(Vec4.W);
}
test "compile Mat4" {
var a = Mat4.Identity;
var b = a;
_ = a.row(0);
_ = a.row(1);
_ = a.row(2);
_ = a.row(3);
_ = a.col(0);
_ = a.col(1);
_ = a.col(2);
_ = a.col(3);
_ = a.preScaleVec(Vec3.X);
_ = a.postScaleVec(Vec3.Y);
_ = a.preScale(4);
_ = a.postScale(0.25);
_ = a.preTranslate(Vec3.Y);
_ = a.postTranslate(Vec3.Z);
_ = a.project(Vec3.X);
_ = a.mulVec(Vec4.W);
_ = a.mulMat3(Mat3.Identity);
_ = a.mulMat4x3(Mat4x3.Identity);
_ = a.mulMat(b);
_ = a.asBuf();
_ = a.asGrid();
_ = a.toMat3();
_ = a.toMat4x3();
} | src/geo/mat.zig |
const std = @import("std");
const Allocator = mem.Allocator;
const event = std.event;
const fifo = std.fifo;
const fmt = std.fmt;
const io = std.io;
const json = std.json;
const mem = std.mem;
const meta = std.meta;
const net = std.net;
const nkeys = @import("nkeys");
const nuid = @import("nuid.zig");
const testing = std.testing;
const tls = @import("iguanaTLS");
const uri = @import("uri");
const CountingWriter = struct {
const Self = @This();
const WriteError = error{};
pub const Writer = io.Writer(*Self, WriteError, write);
count: usize = 0,
fn write(self: *Self, bytes: []const u8) WriteError!usize {
self.count += bytes.len;
return bytes.len;
}
fn writer(self: *Self) Writer {
return .{ .context = self };
}
};
// TODO(rutgerbrf): Cancellation!
pub const Conn = struct {
const Self = @This();
// TODO(rutgerbrf): has_protocol? (the 4th param)
const TlsClient = tls.Client(net.Stream.Reader, net.Stream.Writer, tls.ciphersuites.all, false);
const ReadError = net.Stream.Reader.Error || TlsClient.Reader.Error;
const WriteError = net.Stream.Writer.Error || TlsClient.Writer.Error;
const Reader = io.Reader(*Self, ReadError, read);
const Writer = io.Writer(*Self, WriteError, write);
allocator: *Allocator,
strm: net.Stream,
tlsc: ?TlsClient = null,
headers: bool,
fn read(self: *Self, dest: []u8) ReadError!usize {
return if (self.tlsc) |*tlss| try tlss.read(dest) else try self.strm.read(dest);
}
fn write(self: *Self, bytes: []const u8) WriteError!usize {
return if (self.tlsc) |*tlss| try tlss.write(bytes) else try self.strm.write(bytes);
}
fn reader(self: *Self) Reader {
return .{ .context = self };
}
fn writer(self: *Self) Writer {
return .{ .context = self };
}
fn readServerOp(self: *Self) !ServerOp {
return ServerOp.readFrom(self.allocator, self.reader());
}
fn freeServerOp(self: *const Self, op: *ServerOp) void {
// TODO(rutgerbrf): wipe the memory before freeing it
op.readFromFree(self.allocator);
}
fn writeClientOp(self: *Self, op: *const ClientOp) !void {
return ClientOp.writeTo(op, self.writer());
}
fn fromNewStream(allocator: *Allocator, server: Server, strm: net.Stream) !Conn {
var c = Conn{ .allocator = allocator, .strm = strm, .headers = false };
std.debug.print("Reading server op\n", .{});
var server_op = try c.readServerOp();
defer c.freeServerOp(&server_op);
std.debug.print("Read server op\n", .{});
var tls_required = server.tls_required;
switch (server_op) {
.info => |info| {
c.headers = info.headers orelse false;
tls_required = tls_required or (info.tls_required orelse false);
},
else => return error.UnexpectedServerOp,
}
if (c.headers) std.debug.print("Server has support for headers\n", .{});
if (tls_required) {
c.tlsc = try tls.client_connect(.{
.cert_verifier = .none,
.reader = c.strm.reader(),
.writer = c.strm.writer(),
.temp_allocator = allocator,
}, server.host); // TODO(rutgerbrf): make sure the DNS name is valid, or do some stuff with it
}
var connect_op = ConnectOp{
.verbose = false,
.pedantic = false,
.user_jwt = null,
.nkey = null,
.signature = null,
.name = "hello",
// .name = opts.name,
// .echo = opts.echo,
.echo = false,
.lang = "zig",
.version = "who knows", // TODO(rutgerbrf)
.tls_required = tls_required,
.user = null,
.pass = <PASSWORD>,
.auth_token = null,
.headers = true,
};
try c.writeClientOp(&.{ .connect = connect_op });
const ping: ClientOp = .ping;
const pong: ClientOp = .pong;
try c.writeClientOp(&ping);
while (true) {
var maybe_pong = try c.readServerOp();
defer c.freeServerOp(&maybe_pong);
switch (maybe_pong) {
.pong => break,
.ping => try c.writeClientOp(&pong),
else => return error.InvalidData,
}
}
return c;
}
};
const ClientStatus = enum {
disconnected,
connected,
closed,
reconnecting,
connecting,
draining_subs,
draining_pubs,
};
pub const Client = struct {
const Self = @This();
allocator: *Allocator,
loop: *event.Loop,
conn: Conn,
last_subscription_id: u64 = 0,
subscriptions: std.AutoHashMap(u64, *Subscription),
lock: event.Lock = .{},
status: ClientStatus = .disconnected,
fn _isClosed(self: *Self) bool {
return self.status == .closed;
}
fn _isConnecting(self: *Self) bool {
return self.status == .connecting;
}
fn _isReconnecting(self: *Self) bool {
return self.status == .reconnecting;
}
fn _isConnected(self: *Self) bool {
return self.status == .connected or self._isDraining();
}
fn _isDraining(self: *Self) bool {
return self.status == .draining_subs or self.status == .draining_pubs;
}
fn _isDrainingPubs(self: *Self) bool {
return self.status == .draining_pubs;
}
pub fn isDraining(self: *Self) bool {
const lock = self.lock.acquire();
defer lock.release();
return self._isDraining();
}
pub fn isClosed(self: *Self) bool {
const lock = self.lock.acquire();
defer lock.release();
return self._isClosed();
}
fn queue(self: *Self, op: *const ClientOp) void {
// TODO(rutgerbrf): make this safe, report errors and stuff,
// deliver messages with another worker, instead of waiting for writeClientOp to return
self.conn.writeClientOp(op) catch |e| std.log.err("oops: {}", .{e});
}
fn run(self: *Self) void {
var count: usize = 0;
std.log.info("Running client", .{});
while (true) {
var server_op = self.conn.readServerOp() catch |e| {
std.log.err("Error reading server op: {}", .{e});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return;
}; // TODO(rutgerbrf): handle this correctly
// TODO(rutgerbrf): free memory
count += 1;
const pong: ClientOp = .pong;
switch (server_op) {
.ping => self.queue(&pong),
.msg => |msg| {
if (self.subscriptions.get(msg.subscription_id)) |sub| {
var msgp = moveToHeap(self.allocator, Msg{
.subject = msg.subject,
.reply_to = msg.reply_to,
.payload = msg.payload,
.subscription = sub,
}) catch |e| {
std.log.err("Could not allocate message: {}", .{e});
continue;
};
sub.push(self.allocator, msgp) catch |e| {
std.log.err("Could not push message to subscriber: {}", .{e});
continue;
};
} else {
self.conn.freeServerOp(&server_op);
}
},
.hmsg => |msg| {
if (self.subscriptions.get(msg.subscription_id)) |sub| {
var msgp = moveToHeap(self.allocator, Msg{
.subject = msg.subject,
.reply_to = msg.reply_to,
.headers = msg.headers,
.payload = msg.payload,
.subscription = sub,
}) catch |e| {
std.log.err("Could not allocate message: {}", .{e});
continue;
};
sub.push(self.allocator, msgp) catch |e| {
std.log.err("Could not push message to subscriber: {}", .{e});
continue;
};
} else {
self.conn.freeServerOp(&server_op);
}
},
else => {
self.conn.freeServerOp(&server_op);
},
}
}
}
fn newSubscriptionId(self: *Self) u64 {
self.last_subscription_id += 1;
return self.last_subscription_id;
}
pub fn subscribe(self: *Self, subject: []const u8, cb: MsgCallback) !*Subscription {
const id = self.newSubscriptionId();
var op = SubOp{
.subject = subject,
.subscription_id = id,
};
self.queue(&.{ .subscribe = op });
var sub = try moveToHeap(self.allocator, Subscription{
.loop = self.loop,
.id = id,
.client = self,
.cb = cb,
.subject = subject,
.msgq = fifo.LinearFifo(*Msg, .Dynamic).init(self.allocator),
});
try self.subscriptions.put(op.subscription_id, sub);
return sub;
}
pub fn publish(self: *Self, subject: []const u8, data: []const u8) void {
var op = PubOp{
.subject = subject,
.payload = data,
};
self.queue(&.{ .publish = op });
}
fn unsubscribe(self: *Self, sub: *Subscription, max: u64, drain_mode: bool) !void {
const present = self.subscriptions.contains(sub.id);
std.log.info("Client.unsubscribe called: present={}, subject={s}, max={}, drain_mode={}", .{present, sub.subject, max, drain_mode});
}
fn init(allocator: *Allocator, loop: *event.Loop, conn: Conn) !*Self {
const self = try allocator.create(Self);
self.* = Self{
.allocator = allocator,
.loop = loop,
.conn = conn,
.subscriptions = std.AutoHashMap(u64, *Subscription).init(allocator),
};
try self.loop.runDetached(self.allocator, Self.run, .{self});
return self;
}
pub fn deinit(self: *Self) void {
// TODO(rutgerbrf): close the connection
self.allocator.destroy(self);
}
};
pub const Msg = struct {
const Self = @This();
subject: []const u8,
reply_to: ?[]const u8 = null,
headers: ?Headers = null,
payload: []const u8 = &[_]u8{},
subscription: ?*Subscription = null,
};
pub const Subscription = struct {
const Self = @This();
id: u64,
subject: []const u8,
client: ?*Client,
loop: *event.Loop,
cb: ?MsgCallback,
msgq: fifo.LinearFifo(*Msg, .Dynamic),
lock: event.Lock = .{},
queue_group: ?[]const u8 = null,
recvd_msgs: u64 = 0,
closed: bool = false,
fn push(self: *Self, allocator: *Allocator, msg: *Msg) !void {
const lock = self.lock.acquire();
defer lock.release();
self.recvd_msgs += 1;
if (self.cb) |cb| {
try cb.callDetached(allocator, self.loop, msg);
} else {
try self.msgq.writeItem(msg);
}
}
pub fn unsubscribe(self: *Self) !void {
const client = locked: {
const lock = self.lock.acquire();
defer lock.release();
if (self.client) |c| {
if (c.isClosed()) return error.ConnectionClosed;
if (self.closed) return error.BadSubscription;
if (c.isDraining()) return error.ConnectionDraining;
break :locked c;
} else return error.ConnectionClosed;
};
return client.unsubscribe(self, 0, false);
}
};
pub fn connect(allocator: *Allocator, options: ClientOptions, loop: ?*event.Loop) !*Client {
const server = try Server.fromUrl(options.url);
const strm = try net.tcpConnectToHost(allocator, server.host, server.port);
const conn = try Conn.fromNewStream(allocator, server, strm);
const actual_loop = loop orelse event.Loop.instance orelse return error.NoEventLoop;
const client = try Client.init(allocator, actual_loop, conn);
return client;
}
const Server = struct {
const Self = @This();
host: []const u8,
port: u16,
tls_required: bool,
fn fromUrl(url: []const u8) !Self {
const tls_required = mem.startsWith(u8, url, "tls://");
const host_port = if (mem.indexOf(u8, url, "://")) |sep_idx| url[sep_idx..] else url;
if (host_port.len == 0) return error.BadHostPort; // TODO
var addr = splitHostPort(host_port) catch HostPort{ .host = host_port, .port = "4222" };
for (addr.port) |c| if (!std.ascii.isDigit(c)) return error.NonNumericalPort;
var port = fmt.parseInt(u16, addr.port, 10) catch return error.PortTooLong;
return Self{
.host = addr.host,
.port = port,
.tls_required = tls_required,
};
}
const HostPort = struct {
host: []const u8,
port: []const u8,
};
// Taken from the Go standard library.
fn splitHostPort(host_port: []const u8) !HostPort {
var host: []const u8 = host_port;
var j: usize = 0;
var k: usize = 0;
// The port starts after the last colon.
var i = mem.lastIndexOf(u8, host_port, ":") orelse return error.MissingPort;
if (host_port[0] == '[') {
var end = mem.indexOf(u8, host_port, "]") orelse return error.MissingClosingBracket;
if (end + 1 == host_port.len) return error.MissingPort; // There can't be a ':' behind the ']' now.
if (end + 1 != i) {
// Either ']' isn't followed by a colon, or it is followed by a colon that is not the last one.
if (host_port[end + 1] == ':') return error.TooManyColons;
return error.MissingPort;
}
host = host_port[1..end];
j = 1;
k = end + 1;
} else {
host = host_port[0..i];
if (mem.indexOf(u8, host, ":") != null) return error.TooManyColons;
}
if (mem.indexOf(u8, host_port[j..], "[") != null) return error.UnexpectedOpeningBracket;
if (mem.indexOf(u8, host_port[k..], "]") != null) return error.UnexpectedClosingBracket;
var port = host_port[i + 1 ..];
return HostPort{ .host = host, .port = port };
}
};
pub const ClientOptions = struct {
url: []const u8,
servers: []const []const Server,
// no_randomize: bool,
name: []const u8,
// verbose: bool,
// pedantic: bool,
// secure: bool,
// tls_config: TlsConfig // dependent on TLS lib
// allow_reconnect: bool = true,
// max_reconnect: usize = default_max_reconnect,
// reconnect_wait: time.Duration,
// custom_reconnect_delay_cb: ReconnectDelayHandler,
// reconnect_jitter: time.Duration,
// reconnect_jitter_tls: time.Duration,
// drain_timeout: time.Duration,
// flusher_timeout: time.Duration,
// ping_interval: time.Duration,
// max_pings_out: usize,
// closed_cb: ConnHandler,
// disconnected_err_cb: ConnErrHandler,
// reconnected_cb: ConnHandler,
// discovered_servers_cb: ConnHandler,
// async_error_cb: ErrHandler,
// reconnect_buf_size: usize,
// sub_chan_len: usize, // may not be applicable
// user_jwt: UserJwtHandler,
// nkey: []const u8,
// sinature_cb: SignatureHandler,
// user: []const u8,
// password: []const u8,
// token: []const u8,
// token_handler: AuthTokenHandler,
// custom_dialer: CustomDialer, // may not be applicable, Go-specific?
// use_old_request_style: bool,
// no_callbacks_after_client_close: bool,
// lame_duck_mode_handler: ConnHandler,
// retry_on_failed_connect: bool,
// compression: bool, // only for WebSockets, add support later on
};
pub const Headers = struct {
const Self = @This();
entries: std.StringHashMap(std.ArrayList([]const u8)),
fn init(allocator: *Allocator) Self {
return .{
.entries = std.StringHashMap(std.ArrayList([]const u8)).init(allocator),
};
}
fn deinit(self: *Self) void {
var iterator = self.entries.iterator();
while (iterator.next()) |it| it.value_ptr.deinit();
self.entries.deinit();
}
fn calcSize(self: *const Self) usize {
var w = CountingWriter{};
self.writeTo(w.writer()) catch unreachable; // TODO(rutgerbrf): this unreachable won't be quite so unreachable anymore if writeTo starts returning errors of its own
return w.count;
}
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
var iterator = self.entries.iterator();
try out_stream.writeAll("NATS/1.0");
if (self.entries.get("Status")) |statuses| {
if (statuses.items.len > 0) {
try out_stream.writeAll(" ");
// TODO(rutgerbrf): check value
try out_stream.writeAll(statuses.items[0]);
}
}
try out_stream.writeAll("\r\n");
while (iterator.next()) |it| {
var values = it.value_ptr.items;
if (std.mem.eql(u8, it.key_ptr.*, "Status") and values.len > 0) {
values = it.value_ptr.items[1..];
}
for (values) |val| {
// TODO(rutgerbrf): check key
try out_stream.writeAll(it.key_ptr.*);
try out_stream.writeAll(": ");
// TODO(rutgerbrf): check value
try out_stream.writeAll(val);
try out_stream.writeAll("\r\n");
}
}
try out_stream.writeAll("\r\n");
}
fn readFrom(allocator: *Allocator, buf: []const u8) !Self {
const header_first_line = "NATS/1.0";
const status_header = "Status";
const space = &[_]u8{ ' ', '\t', 0x0B, 0x0C };
var self = Self.init(allocator);
errdefer self.deinit();
var first_line = true;
var lines = mem.split(buf, "\r\n");
while (lines.next()) |line| {
if (line.len > 0 and lines.index == null) return error.BadHeaderMsg;
if (first_line) {
first_line = false;
if (!mem.startsWith(u8, line, header_first_line)) {
return error.BadHeaderMsg;
}
if (line.len > header_first_line.len) {
var i = header_first_line.len;
for (line[header_first_line.len..]) |c| {
if (mem.indexOf(u8, space, &.{c}) == null) break;
i += 1;
}
if (i == header_first_line.len) return error.BadHeaderMsg;
var status = mem.trim(u8, line[i..], space);
if (status.len != 3) return error.BadHeaderMsg; // 3.., 4.., 5..
var list = std.ArrayList([]const u8).init(allocator);
try list.append(status);
try self.entries.put(status_header, list);
}
continue;
}
if (line.len == 0) break;
var i = mem.indexOf(u8, line, ":") orelse return error.BadHeaderMsg;
const key = line[0..i];
if (key.len == 0) continue;
i += 1;
while (i < line.len and (line[i] == ' ' or line[i] == '\t')) {
i += 1;
}
const value = line[i..];
const result = try self.entries.getOrPut(key);
if (!result.found_existing) {
result.value_ptr.* = std.ArrayList([]const u8).init(allocator);
}
try result.value_ptr.append(value);
}
return self;
}
};
const ClientOp = union(enum) {
const Self = @This();
connect: ConnectOp,
publish: PubOp,
hpublish: HpubOp,
subscribe: SubOp,
unsubscribe: UnsubOp,
ping,
pong,
fn writeTo(self: *const Self, out_stream: anytype) !void {
switch (self.*) {
.connect => |*op| try op.writeTo(out_stream),
.publish => |*op| try op.writeTo(out_stream),
.hpublish => |*op| try op.writeTo(out_stream),
.subscribe => |*op| try op.writeTo(out_stream),
.unsubscribe => |*op| try op.writeTo(out_stream),
.ping => try out_stream.writeAll("PING\r\n"),
.pong => try out_stream.writeAll("PONG\r\n"),
}
}
};
const ConnectOp = struct {
const Self = @This();
verbose: bool,
pedantic: bool,
user_jwt: ?[]const u8,
nkey: ?[]const u8,
signature: ?[]const u8,
name: ?[]const u8,
echo: bool,
lang: []const u8,
version: []const u8,
tls_required: bool,
user: ?[]const u8,
pass: ?[]const u8,
auth_token: ?[]const u8,
headers: bool,
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
try out_stream.writeAll("CONNECT ");
try json.stringify(self.*, .{}, out_stream);
try out_stream.writeAll("\r\n");
}
};
const PubOp = struct {
const Self = @This();
subject: []const u8,
reply_to: ?[]const u8 = null,
payload: []const u8,
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
try out_stream.writeAll("PUB ");
// TODO(rutgerbrf): validate subject, reply_to?
try out_stream.writeAll(self.subject);
try out_stream.writeAll(" ");
if (self.reply_to) |reply_to| {
try out_stream.writeAll(reply_to);
try out_stream.writeAll(" ");
}
try fmt.formatInt(self.payload.len, 10, .lower, .{}, out_stream);
try out_stream.writeAll("\r\n");
try out_stream.writeAll(self.payload);
try out_stream.writeAll("\r\n");
}
};
const HpubOp = struct {
const Self = @This();
subject: []const u8,
reply_to: ?[]const u8 = null,
headers: Headers,
payload: []const u8,
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
try out_stream.writeAll("HPUB ");
// TODO(rutgerbrf): validate subject, reply_to?
try out_stream.writeAll(self.subject);
try out_stream.writeAll(" ");
if (self.reply_to) |reply_to| {
try out_stream.writeAll(reply_to);
try out_stream.writeAll(" ");
}
const headers_size = self.headers.calcSize();
try fmt.formatInt(headers_size, 10, .lower, .{}, out_stream);
try out_stream.writeAll(" ");
const total_size = headers_size + self.payload.len;
try fmt.formatInt(total_size, 10, .lower, .{}, out_stream);
try out_stream.writeAll("\r\n");
try self.headers.writeTo(out_stream);
try out_stream.writeAll(self.payload);
try out_stream.writeAll("\r\n");
}
};
const SubOp = struct {
const Self = @This();
subject: []const u8,
queue_group: ?[]const u8 = null,
subscription_id: u64,
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
try out_stream.writeAll("SUB ");
// TODO(rutgerbrf): validate subject, queue_group?
try out_stream.writeAll(self.subject);
try out_stream.writeAll(" ");
if (self.queue_group) |queue_group| {
try out_stream.writeAll(queue_group);
try out_stream.writeAll(" ");
}
try fmt.formatInt(self.subscription_id, 10, .lower, .{}, out_stream);
try out_stream.writeAll("\r\n");
}
};
const UnsubOp = struct {
const Self = @This();
subscription_id: u64,
max_msgs: ?u64 = null,
fn writeTo(self: *const Self, out_stream: anytype) @TypeOf(out_stream).Error!void {
try out_stream.writeAll("UNSUB ");
try fmt.formatInt(self.subscription_id, 10, .lower, .{}, out_stream);
if (self.max_msgs) |max_msgs| {
try out_stream.writeAll(" ");
try fmt.formatInt(max_msgs, 10, .lower, .{}, out_stream);
}
try out_stream.writeAll("\r\n");
}
};
const ProtocolError = error{ InvalidData, EndOfStream };
const ServerOp = union(enum) {
const Self = @This();
info: InfoOp,
msg: MsgOp,
hmsg: HmsgOp,
ping,
pong,
err: ErrOp,
ok,
unknown: []const u8,
fn readFromFree(self: *Self, allocator: *Allocator) void {
switch (self.*) {
.info => |*op| op.readFromFree(allocator),
.msg => |*op| op.readFromFree(allocator),
.hmsg => |*op| op.readFromFree(allocator),
.err => |*op| op.readFromFree(allocator),
else => {},
}
}
fn assertNext(comptime bs: []const u8, in_stream: anytype) (@TypeOf(in_stream).Error || ProtocolError)!void {
for (bs) |b| {
const read = try in_stream.readByte();
if (read != b) return error.InvalidData;
}
}
fn readFrom(allocator: *Allocator, in_stream: anytype) !Self {
// INFO / MSG / HMSG / PING / PONG / ERR / ?S
// TODO(rutgerbrf): don't return an error when this fails. Instead, return Self{ .unknown = "..." }
var b0 = try in_stream.readByte();
switch (b0) {
'I' => {
try assertNext("NFO ", in_stream);
return Self{ .info = try InfoOp.readFrom(allocator, in_stream) };
},
'M' => {
try assertNext("SG ", in_stream);
return Self{ .msg = try MsgOp.readFrom(allocator, in_stream) };
},
'H' => {
try assertNext("MSG ", in_stream);
return Self{ .hmsg = try HmsgOp.readFrom(allocator, in_stream) };
},
'P' => {
var b1 = try in_stream.readByte();
switch (b1) {
'I' => {
try assertNext("NG\r\n", in_stream);
return Self.ping;
},
'O' => {
try assertNext("NG\r\n", in_stream);
return Self.pong;
},
else => return error.InvalidData,
}
},
'-' => {
try assertNext("ERR ", in_stream);
return Self{ .err = try ErrOp.readFrom(allocator, in_stream) };
},
'+' => {
try assertNext("OK\r\n", in_stream);
return Self.ok;
},
else => return error.InvalidData,
}
}
};
const InfoOp = struct {
const Self = @This();
server_id: []const u8,
server_name: []const u8,
proto: i32,
host: []const u8,
port: u16,
max_payload: i64,
headers: ?bool = null,
auth_required: ?bool = null,
tls_required: ?bool = null,
tls_available: ?bool = null,
client_id: ?u64 = null,
client_ip: ?[]const u8 = null,
nonce: ?[]const u8 = null,
cluster: ?[]const u8 = null,
connect_urls: ?[][]const u8 = null,
lame_duck_mode: ?bool = null,
fn parseOpts(allocator: *Allocator) json.ParseOptions {
return .{ .allocator = allocator, .ignore_unknown_fields = true };
}
fn readFromFree(self: *Self, allocator: *Allocator) void {
return json.parseFree(Self, self.*, parseOpts(allocator));
}
fn readFrom(allocator: *Allocator, in_stream: anytype) !Self {
var buf = try in_stream.readUntilDelimiterAlloc(allocator, '\r', std.math.maxInt(usize)); // TODO(rutgerbrf): make the limit configurable
const json_buf = buf[0 .. buf.len - 1]; // without the '\r'
defer allocator.free(buf);
var lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
std.debug.print("Parsing the following JSON: '{s}'\n", .{json_buf});
@setEvalBranchQuota(1_000_000); // TODO(rutgerbrf): this might be somewhat excessive
return json.parse(Self, &json.TokenStream.init(json_buf), parseOpts(allocator));
}
};
const MsgOp = struct {
const Self = @This();
_ctrl_buf: []const u8,
subject: []const u8,
subscription_id: u64,
reply_to: ?[]const u8,
payload: []const u8,
fn readFromFree(self: *Self, allocator: *Allocator) void {
allocator.free(self._ctrl_buf);
allocator.free(self.payload);
}
fn readFrom(allocator: *Allocator, in_stream: anytype) !Self {
var control = try in_stream.readUntilDelimiterAlloc(allocator, '\r', std.math.maxInt(usize)); // TODO(rutgerbrf): make the limit configurable
var lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
var parts = [_]?[]const u8{null} ** 4;
var tokens = mem.tokenize(control, " ");
var i: usize = 0;
while (tokens.next()) |token| {
parts[i] = token;
i += 1;
}
if (i < 3 or i > 4) return error.InvalidData;
var has_reply_to = i == 4;
var subject = parts[0].?;
var subscription_id = try fmt.parseInt(u64, parts[1].?, 10);
var reply_to = if (i == 4) parts[2].? else null;
var payload_len = try fmt.parseInt(u64, if (has_reply_to) parts[3].? else parts[2].?, 10);
var payload_buf = try allocator.alloc(u8, payload_len);
try in_stream.readNoEof(payload_buf);
var cr = try in_stream.readByte();
if (cr != '\r') return error.InvalidData;
lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
return Self{
._ctrl_buf = control,
.subject = subject,
.subscription_id = subscription_id,
.reply_to = reply_to,
.payload = payload_buf,
};
}
};
const HmsgOp = struct {
const Self = @This();
_ctrl_buf: []const u8,
subject: []const u8,
subscription_id: u64,
reply_to: ?[]const u8,
_hdrs_buf: []const u8,
headers: Headers,
payload: []const u8,
fn readFromFree(self: *Self, allocator: *Allocator) void {
allocator.free(self._ctrl_buf);
self.headers.deinit();
allocator.free(self._hdrs_buf);
}
fn readFrom(allocator: *Allocator, in_stream: anytype) !Self {
var control = try in_stream.readUntilDelimiterAlloc(allocator, '\r', std.math.maxInt(usize)); // TODO(rutgerbrf): make the limit configurable
var lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
var parts = [_]?[]const u8{null} ** 5;
var tokens = mem.tokenize(control, " ");
var i: usize = 0;
while (tokens.next()) |token| {
parts[i] = token;
i += 1;
}
if (i < 4 or i > 5) return error.InvalidData;
var has_reply_to = i == 5;
var subject = parts[0].?;
var subscription_id = try fmt.parseInt(u64, parts[1].?, 10);
var reply_to = if (i == 5) parts[2].? else null;
var header_len = try fmt.parseInt(u64, if (has_reply_to) parts[3].? else parts[2].?, 10);
var total_len = try fmt.parseInt(u64, if (has_reply_to) parts[4].? else parts[3].?, 10);
std.debug.assert(total_len >= header_len);
var headers_buf = try allocator.alloc(u8, header_len);
try in_stream.readNoEof(headers_buf);
var payload_buf = try allocator.alloc(u8, total_len - header_len);
try in_stream.readNoEof(payload_buf);
var headers = try Headers.readFrom(allocator, headers_buf);
var cr = try in_stream.readByte();
if (cr != '\r') return error.InvalidData;
lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
return Self{
._ctrl_buf = control,
.subject = subject,
.subscription_id = subscription_id,
.reply_to = reply_to,
._hdrs_buf = headers_buf,
.headers = headers,
.payload = payload_buf,
};
}
};
const ErrOp = struct {
const Self = @This();
message: []const u8,
fn readFromFree(self: *Self, allocator: *Allocator) void {
allocator.free(self.message);
}
fn readFrom(allocator: *Allocator, in_stream: anytype) !Self {
var buf = try in_stream.readUntilDelimiterAlloc(allocator, '\r', std.math.maxInt(usize)); // TODO(rutgerbrf): make the limit configurable
var lf = try in_stream.readByte();
if (lf != '\n') return error.InvalidData;
return Self{ .message = buf };
}
};
const Auth = union(enum) {
none,
user_pass: struct {
user: []const u8,
pass: []const u8,
},
token: []const u8,
credentials: struct {},
nkey: struct {},
};
pub const MsgCallback = struct {
const Self = @This();
const CallFn = fn (context: usize, msg: *Msg) void;
internal: struct {
context: usize,
call: CallFn,
},
pub fn from(context: anytype, cb: fn (context: @TypeOf(context), msg: *Msg) void) Self {
return .{
.internal = .{
.context = @ptrToInt(context),
.call = @intToPtr(CallFn, @ptrToInt(cb)),
},
};
}
fn call(self: Self, msg: *Msg) void {
return self.internal.call(self.internal.context, msg);
}
fn callDetached(self: Self, allocator: *Allocator, loop: *event.Loop, msg: *Msg) error{OutOfMemory}!void {
// TODO(rutgerbrf): what about the ownership of msg?
return loop.runDetached(allocator, Self.call, .{ self, msg });
}
};
fn moveToHeap(allocator: *Allocator, v: anytype) !*@TypeOf(v) {
var vp = try allocator.create(@TypeOf(v));
vp.* = v;
return vp;
}
test {
testing.refAllDecls(@This());
testing.refAllDecls(Conn);
testing.refAllDecls(Headers);
testing.refAllDecls(ClientOp);
testing.refAllDecls(ConnectOp);
testing.refAllDecls(PubOp);
testing.refAllDecls(HpubOp);
testing.refAllDecls(SubOp);
testing.refAllDecls(UnsubOp);
testing.refAllDecls(ServerOp);
testing.refAllDecls(InfoOp);
testing.refAllDecls(MsgOp);
testing.refAllDecls(HmsgOp);
testing.refAllDecls(ErrOp);
testing.refAllDecls(Server);
testing.refAllDecls(MsgCallback);
}
test "parse header" {
const wrong1 = "NATS/1.0";
try testing.expectError(error.BadHeaderMsg, Headers.readFrom(testing.allocator, wrong1));
const wrong2 = "NATS/1.0418";
try testing.expectError(error.BadHeaderMsg, Headers.readFrom(testing.allocator, wrong2));
const right1 = "NATS/1.0\r\n";
var right1_res = try Headers.readFrom(testing.allocator, right1);
defer right1_res.deinit();
const right2 = "NATS/1.0 418\r\n";
var right2_res = try Headers.readFrom(testing.allocator, right2);
defer right2_res.deinit();
try testing.expect(mem.eql(u8, right2_res.entries.get("Status").?.items[0], "418"));
const wrong3 = "NATS/1.0 418\r\nStatus: 420";
try testing.expectError(error.BadHeaderMsg, Headers.readFrom(testing.allocator, wrong3));
const right3 = "NATS/1.0 418\r\nStatus: 420\r\n";
var right3_res = try Headers.readFrom(testing.allocator, right3);
defer right3_res.deinit();
try testing.expect(mem.eql(u8, right3_res.entries.get("Status").?.items[0], "418"));
try testing.expect(mem.eql(u8, right3_res.entries.get("Status").?.items[1], "420"));
const wrong4 = "NATS/1.0\r\nExample: test";
try testing.expectError(error.BadHeaderMsg, Headers.readFrom(testing.allocator, wrong4));
const right4 = "NATS/1.0\r\nExample: test\r\n";
var right4_res = try Headers.readFrom(testing.allocator, right4);
defer right4_res.deinit();
try testing.expect(mem.eql(u8, right4_res.entries.get("Example").?.items[0], "test"));
} | src/main.zig |
export fn _LIB_VERSION() void {}
export fn __acos_finite() void {}
export fn __acosf128_finite() void {}
export fn __acosf_finite() void {}
export fn __acosh_finite() void {}
export fn __acoshf128_finite() void {}
export fn __acoshf_finite() void {}
export fn __acoshl_finite() void {}
export fn __acosl_finite() void {}
export fn __asin_finite() void {}
export fn __asinf128_finite() void {}
export fn __asinf_finite() void {}
export fn __asinl_finite() void {}
export fn __atan2_finite() void {}
export fn __atan2f128_finite() void {}
export fn __atan2f_finite() void {}
export fn __atan2l_finite() void {}
export fn __atanh_finite() void {}
export fn __atanhf128_finite() void {}
export fn __atanhf_finite() void {}
export fn __atanhl_finite() void {}
export fn __clog10() void {}
export fn __clog10f() void {}
export fn __clog10l() void {}
export fn __cosh_finite() void {}
export fn __coshf128_finite() void {}
export fn __coshf_finite() void {}
export fn __coshl_finite() void {}
export fn __exp10_finite() void {}
export fn __exp10f128_finite() void {}
export fn __exp10f_finite() void {}
export fn __exp10l_finite() void {}
export fn __exp2_finite() void {}
export fn __exp2f128_finite() void {}
export fn __exp2f_finite() void {}
export fn __exp2l_finite() void {}
export fn __exp_finite() void {}
export fn __expf128_finite() void {}
export fn __expf_finite() void {}
export fn __expl_finite() void {}
export fn __finite() void {}
export fn __finitef() void {}
export fn __finitef128() void {}
export fn __finitel() void {}
export fn __fmod_finite() void {}
export fn __fmodf128_finite() void {}
export fn __fmodf_finite() void {}
export fn __fmodl_finite() void {}
export fn __fpclassify() void {}
export fn __fpclassifyf() void {}
export fn __fpclassifyf128() void {}
export fn __fpclassifyl() void {}
export fn __gamma_r_finite() void {}
export fn __gammaf128_r_finite() void {}
export fn __gammaf_r_finite() void {}
export fn __gammal_r_finite() void {}
export fn __hypot_finite() void {}
export fn __hypotf128_finite() void {}
export fn __hypotf_finite() void {}
export fn __hypotl_finite() void {}
export fn __iscanonicall() void {}
export fn __iseqsig() void {}
export fn __iseqsigf() void {}
export fn __iseqsigf128() void {}
export fn __iseqsigl() void {}
export fn __isinff128() void {}
export fn __isnanf128() void {}
export fn __issignaling() void {}
export fn __issignalingf() void {}
export fn __issignalingf128() void {}
export fn __issignalingl() void {}
export fn __j0_finite() void {}
export fn __j0f128_finite() void {}
export fn __j0f_finite() void {}
export fn __j0l_finite() void {}
export fn __j1_finite() void {}
export fn __j1f128_finite() void {}
export fn __j1f_finite() void {}
export fn __j1l_finite() void {}
export fn __jn_finite() void {}
export fn __jnf128_finite() void {}
export fn __jnf_finite() void {}
export fn __jnl_finite() void {}
export fn __lgamma_r_finite() void {}
export fn __lgammaf128_r_finite() void {}
export fn __lgammaf_r_finite() void {}
export fn __lgammal_r_finite() void {}
export fn __log10_finite() void {}
export fn __log10f128_finite() void {}
export fn __log10f_finite() void {}
export fn __log10l_finite() void {}
export fn __log2_finite() void {}
export fn __log2f128_finite() void {}
export fn __log2f_finite() void {}
export fn __log2l_finite() void {}
export fn __log_finite() void {}
export fn __logf128_finite() void {}
export fn __logf_finite() void {}
export fn __logl_finite() void {}
export fn __pow_finite() void {}
export fn __powf128_finite() void {}
export fn __powf_finite() void {}
export fn __powl_finite() void {}
export fn __remainder_finite() void {}
export fn __remainderf128_finite() void {}
export fn __remainderf_finite() void {}
export fn __remainderl_finite() void {}
export fn __scalb_finite() void {}
export fn __scalbf_finite() void {}
export fn __scalbl_finite() void {}
export fn __signbit() void {}
export fn __signbitf() void {}
export fn __signbitf128() void {}
export fn __signbitl() void {}
export fn __signgam() void {}
export fn __sinh_finite() void {}
export fn __sinhf128_finite() void {}
export fn __sinhf_finite() void {}
export fn __sinhl_finite() void {}
export fn __sqrt_finite() void {}
export fn __sqrtf128_finite() void {}
export fn __sqrtf_finite() void {}
export fn __sqrtl_finite() void {}
export fn __y0_finite() void {}
export fn __y0f128_finite() void {}
export fn __y0f_finite() void {}
export fn __y0l_finite() void {}
export fn __y1_finite() void {}
export fn __y1f128_finite() void {}
export fn __y1f_finite() void {}
export fn __y1l_finite() void {}
export fn __yn_finite() void {}
export fn __ynf128_finite() void {}
export fn __ynf_finite() void {}
export fn __ynl_finite() void {}
export fn acos() void {}
export fn acosf() void {}
export fn acosf128() void {}
export fn acosf32() void {}
export fn acosf32x() void {}
export fn acosf64() void {}
export fn acosf64x() void {}
export fn acosh() void {}
export fn acoshf() void {}
export fn acoshf128() void {}
export fn acoshf32() void {}
export fn acoshf32x() void {}
export fn acoshf64() void {}
export fn acoshf64x() void {}
export fn acoshl() void {}
export fn acosl() void {}
export fn asin() void {}
export fn asinf() void {}
export fn asinf128() void {}
export fn asinf32() void {}
export fn asinf32x() void {}
export fn asinf64() void {}
export fn asinf64x() void {}
export fn asinh() void {}
export fn asinhf() void {}
export fn asinhf128() void {}
export fn asinhf32() void {}
export fn asinhf32x() void {}
export fn asinhf64() void {}
export fn asinhf64x() void {}
export fn asinhl() void {}
export fn asinl() void {}
export fn atan() void {}
export fn atan2() void {}
export fn atan2f() void {}
export fn atan2f128() void {}
export fn atan2f32() void {}
export fn atan2f32x() void {}
export fn atan2f64() void {}
export fn atan2f64x() void {}
export fn atan2l() void {}
export fn atanf() void {}
export fn atanf128() void {}
export fn atanf32() void {}
export fn atanf32x() void {}
export fn atanf64() void {}
export fn atanf64x() void {}
export fn atanh() void {}
export fn atanhf() void {}
export fn atanhf128() void {}
export fn atanhf32() void {}
export fn atanhf32x() void {}
export fn atanhf64() void {}
export fn atanhf64x() void {}
export fn atanhl() void {}
export fn atanl() void {}
export fn cabs() void {}
export fn cabsf() void {}
export fn cabsf128() void {}
export fn cabsf32() void {}
export fn cabsf32x() void {}
export fn cabsf64() void {}
export fn cabsf64x() void {}
export fn cabsl() void {}
export fn cacos() void {}
export fn cacosf() void {}
export fn cacosf128() void {}
export fn cacosf32() void {}
export fn cacosf32x() void {}
export fn cacosf64() void {}
export fn cacosf64x() void {}
export fn cacosh() void {}
export fn cacoshf() void {}
export fn cacoshf128() void {}
export fn cacoshf32() void {}
export fn cacoshf32x() void {}
export fn cacoshf64() void {}
export fn cacoshf64x() void {}
export fn cacoshl() void {}
export fn cacosl() void {}
export fn canonicalize() void {}
export fn canonicalizef() void {}
export fn canonicalizef128() void {}
export fn canonicalizef32() void {}
export fn canonicalizef32x() void {}
export fn canonicalizef64() void {}
export fn canonicalizef64x() void {}
export fn canonicalizel() void {}
export fn carg() void {}
export fn cargf() void {}
export fn cargf128() void {}
export fn cargf32() void {}
export fn cargf32x() void {}
export fn cargf64() void {}
export fn cargf64x() void {}
export fn cargl() void {}
export fn casin() void {}
export fn casinf() void {}
export fn casinf128() void {}
export fn casinf32() void {}
export fn casinf32x() void {}
export fn casinf64() void {}
export fn casinf64x() void {}
export fn casinh() void {}
export fn casinhf() void {}
export fn casinhf128() void {}
export fn casinhf32() void {}
export fn casinhf32x() void {}
export fn casinhf64() void {}
export fn casinhf64x() void {}
export fn casinhl() void {}
export fn casinl() void {}
export fn catan() void {}
export fn catanf() void {}
export fn catanf128() void {}
export fn catanf32() void {}
export fn catanf32x() void {}
export fn catanf64() void {}
export fn catanf64x() void {}
export fn catanh() void {}
export fn catanhf() void {}
export fn catanhf128() void {}
export fn catanhf32() void {}
export fn catanhf32x() void {}
export fn catanhf64() void {}
export fn catanhf64x() void {}
export fn catanhl() void {}
export fn catanl() void {}
export fn cbrt() void {}
export fn cbrtf() void {}
export fn cbrtf128() void {}
export fn cbrtf32() void {}
export fn cbrtf32x() void {}
export fn cbrtf64() void {}
export fn cbrtf64x() void {}
export fn cbrtl() void {}
export fn ccos() void {}
export fn ccosf() void {}
export fn ccosf128() void {}
export fn ccosf32() void {}
export fn ccosf32x() void {}
export fn ccosf64() void {}
export fn ccosf64x() void {}
export fn ccosh() void {}
export fn ccoshf() void {}
export fn ccoshf128() void {}
export fn ccoshf32() void {}
export fn ccoshf32x() void {}
export fn ccoshf64() void {}
export fn ccoshf64x() void {}
export fn ccoshl() void {}
export fn ccosl() void {}
export fn ceil() void {}
export fn ceilf() void {}
export fn ceilf128() void {}
export fn ceilf32() void {}
export fn ceilf32x() void {}
export fn ceilf64() void {}
export fn ceilf64x() void {}
export fn ceill() void {}
export fn cexp() void {}
export fn cexpf() void {}
export fn cexpf128() void {}
export fn cexpf32() void {}
export fn cexpf32x() void {}
export fn cexpf64() void {}
export fn cexpf64x() void {}
export fn cexpl() void {}
export fn cimag() void {}
export fn cimagf() void {}
export fn cimagf128() void {}
export fn cimagf32() void {}
export fn cimagf32x() void {}
export fn cimagf64() void {}
export fn cimagf64x() void {}
export fn cimagl() void {}
export fn clog() void {}
export fn clog10() void {}
export fn clog10f() void {}
export fn clog10f128() void {}
export fn clog10f32() void {}
export fn clog10f32x() void {}
export fn clog10f64() void {}
export fn clog10f64x() void {}
export fn clog10l() void {}
export fn clogf() void {}
export fn clogf128() void {}
export fn clogf32() void {}
export fn clogf32x() void {}
export fn clogf64() void {}
export fn clogf64x() void {}
export fn clogl() void {}
export fn conj() void {}
export fn conjf() void {}
export fn conjf128() void {}
export fn conjf32() void {}
export fn conjf32x() void {}
export fn conjf64() void {}
export fn conjf64x() void {}
export fn conjl() void {}
export fn copysign() void {}
export fn copysignf() void {}
export fn copysignf128() void {}
export fn copysignf32() void {}
export fn copysignf32x() void {}
export fn copysignf64() void {}
export fn copysignf64x() void {}
export fn copysignl() void {}
export fn cos() void {}
export fn cosf() void {}
export fn cosf128() void {}
export fn cosf32() void {}
export fn cosf32x() void {}
export fn cosf64() void {}
export fn cosf64x() void {}
export fn cosh() void {}
export fn coshf() void {}
export fn coshf128() void {}
export fn coshf32() void {}
export fn coshf32x() void {}
export fn coshf64() void {}
export fn coshf64x() void {}
export fn coshl() void {}
export fn cosl() void {}
export fn cpow() void {}
export fn cpowf() void {}
export fn cpowf128() void {}
export fn cpowf32() void {}
export fn cpowf32x() void {}
export fn cpowf64() void {}
export fn cpowf64x() void {}
export fn cpowl() void {}
export fn cproj() void {}
export fn cprojf() void {}
export fn cprojf128() void {}
export fn cprojf32() void {}
export fn cprojf32x() void {}
export fn cprojf64() void {}
export fn cprojf64x() void {}
export fn cprojl() void {}
export fn creal() void {}
export fn crealf() void {}
export fn crealf128() void {}
export fn crealf32() void {}
export fn crealf32x() void {}
export fn crealf64() void {}
export fn crealf64x() void {}
export fn creall() void {}
export fn csin() void {}
export fn csinf() void {}
export fn csinf128() void {}
export fn csinf32() void {}
export fn csinf32x() void {}
export fn csinf64() void {}
export fn csinf64x() void {}
export fn csinh() void {}
export fn csinhf() void {}
export fn csinhf128() void {}
export fn csinhf32() void {}
export fn csinhf32x() void {}
export fn csinhf64() void {}
export fn csinhf64x() void {}
export fn csinhl() void {}
export fn csinl() void {}
export fn csqrt() void {}
export fn csqrtf() void {}
export fn csqrtf128() void {}
export fn csqrtf32() void {}
export fn csqrtf32x() void {}
export fn csqrtf64() void {}
export fn csqrtf64x() void {}
export fn csqrtl() void {}
export fn ctan() void {}
export fn ctanf() void {}
export fn ctanf128() void {}
export fn ctanf32() void {}
export fn ctanf32x() void {}
export fn ctanf64() void {}
export fn ctanf64x() void {}
export fn ctanh() void {}
export fn ctanhf() void {}
export fn ctanhf128() void {}
export fn ctanhf32() void {}
export fn ctanhf32x() void {}
export fn ctanhf64() void {}
export fn ctanhf64x() void {}
export fn ctanhl() void {}
export fn ctanl() void {}
export fn daddl() void {}
export fn ddivl() void {}
export fn dmull() void {}
export fn drem() void {}
export fn dremf() void {}
export fn dreml() void {}
export fn dsubl() void {}
export fn erf() void {}
export fn erfc() void {}
export fn erfcf() void {}
export fn erfcf128() void {}
export fn erfcf32() void {}
export fn erfcf32x() void {}
export fn erfcf64() void {}
export fn erfcf64x() void {}
export fn erfcl() void {}
export fn erff() void {}
export fn erff128() void {}
export fn erff32() void {}
export fn erff32x() void {}
export fn erff64() void {}
export fn erff64x() void {}
export fn erfl() void {}
export fn exp() void {}
export fn exp10() void {}
export fn exp10f() void {}
export fn exp10f128() void {}
export fn exp10f32() void {}
export fn exp10f32x() void {}
export fn exp10f64() void {}
export fn exp10f64x() void {}
export fn exp10l() void {}
export fn exp2() void {}
export fn exp2f() void {}
export fn exp2f128() void {}
export fn exp2f32() void {}
export fn exp2f32x() void {}
export fn exp2f64() void {}
export fn exp2f64x() void {}
export fn exp2l() void {}
export fn expf() void {}
export fn expf128() void {}
export fn expf32() void {}
export fn expf32x() void {}
export fn expf64() void {}
export fn expf64x() void {}
export fn expl() void {}
export fn expm1() void {}
export fn expm1f() void {}
export fn expm1f128() void {}
export fn expm1f32() void {}
export fn expm1f32x() void {}
export fn expm1f64() void {}
export fn expm1f64x() void {}
export fn expm1l() void {}
export fn f32addf128() void {}
export fn f32addf32x() void {}
export fn f32addf64() void {}
export fn f32addf64x() void {}
export fn f32divf128() void {}
export fn f32divf32x() void {}
export fn f32divf64() void {}
export fn f32divf64x() void {}
export fn f32mulf128() void {}
export fn f32mulf32x() void {}
export fn f32mulf64() void {}
export fn f32mulf64x() void {}
export fn f32subf128() void {}
export fn f32subf32x() void {}
export fn f32subf64() void {}
export fn f32subf64x() void {}
export fn f32xaddf128() void {}
export fn f32xaddf64() void {}
export fn f32xaddf64x() void {}
export fn f32xdivf128() void {}
export fn f32xdivf64() void {}
export fn f32xdivf64x() void {}
export fn f32xmulf128() void {}
export fn f32xmulf64() void {}
export fn f32xmulf64x() void {}
export fn f32xsubf128() void {}
export fn f32xsubf64() void {}
export fn f32xsubf64x() void {}
export fn f64addf128() void {}
export fn f64addf64x() void {}
export fn f64divf128() void {}
export fn f64divf64x() void {}
export fn f64mulf128() void {}
export fn f64mulf64x() void {}
export fn f64subf128() void {}
export fn f64subf64x() void {}
export fn f64xaddf128() void {}
export fn f64xdivf128() void {}
export fn f64xmulf128() void {}
export fn f64xsubf128() void {}
export fn fabs() void {}
export fn fabsf() void {}
export fn fabsf128() void {}
export fn fabsf32() void {}
export fn fabsf32x() void {}
export fn fabsf64() void {}
export fn fabsf64x() void {}
export fn fabsl() void {}
export fn fadd() void {}
export fn faddl() void {}
export fn fdim() void {}
export fn fdimf() void {}
export fn fdimf128() void {}
export fn fdimf32() void {}
export fn fdimf32x() void {}
export fn fdimf64() void {}
export fn fdimf64x() void {}
export fn fdiml() void {}
export fn fdiv() void {}
export fn fdivl() void {}
export fn feclearexcept() void {}
export fn fedisableexcept() void {}
export fn feenableexcept() void {}
export fn fegetenv() void {}
export fn fegetexcept() void {}
export fn fegetexceptflag() void {}
export fn fegetmode() void {}
export fn fegetround() void {}
export fn feholdexcept() void {}
export fn feraiseexcept() void {}
export fn fesetenv() void {}
export fn fesetexcept() void {}
export fn fesetexceptflag() void {}
export fn fesetmode() void {}
export fn fesetround() void {}
export fn fetestexcept() void {}
export fn fetestexceptflag() void {}
export fn feupdateenv() void {}
export fn finite() void {}
export fn finitef() void {}
export fn finitel() void {}
export fn floor() void {}
export fn floorf() void {}
export fn floorf128() void {}
export fn floorf32() void {}
export fn floorf32x() void {}
export fn floorf64() void {}
export fn floorf64x() void {}
export fn floorl() void {}
export fn fma() void {}
export fn fmaf() void {}
export fn fmaf128() void {}
export fn fmaf32() void {}
export fn fmaf32x() void {}
export fn fmaf64() void {}
export fn fmaf64x() void {}
export fn fmal() void {}
export fn fmax() void {}
export fn fmaxf() void {}
export fn fmaxf128() void {}
export fn fmaxf32() void {}
export fn fmaxf32x() void {}
export fn fmaxf64() void {}
export fn fmaxf64x() void {}
export fn fmaxl() void {}
export fn fmaxmag() void {}
export fn fmaxmagf() void {}
export fn fmaxmagf128() void {}
export fn fmaxmagf32() void {}
export fn fmaxmagf32x() void {}
export fn fmaxmagf64() void {}
export fn fmaxmagf64x() void {}
export fn fmaxmagl() void {}
export fn fmin() void {}
export fn fminf() void {}
export fn fminf128() void {}
export fn fminf32() void {}
export fn fminf32x() void {}
export fn fminf64() void {}
export fn fminf64x() void {}
export fn fminl() void {}
export fn fminmag() void {}
export fn fminmagf() void {}
export fn fminmagf128() void {}
export fn fminmagf32() void {}
export fn fminmagf32x() void {}
export fn fminmagf64() void {}
export fn fminmagf64x() void {}
export fn fminmagl() void {}
export fn fmod() void {}
export fn fmodf() void {}
export fn fmodf128() void {}
export fn fmodf32() void {}
export fn fmodf32x() void {}
export fn fmodf64() void {}
export fn fmodf64x() void {}
export fn fmodl() void {}
export fn fmul() void {}
export fn fmull() void {}
export fn frexp() void {}
export fn frexpf() void {}
export fn frexpf128() void {}
export fn frexpf32() void {}
export fn frexpf32x() void {}
export fn frexpf64() void {}
export fn frexpf64x() void {}
export fn frexpl() void {}
export fn fromfp() void {}
export fn fromfpf() void {}
export fn fromfpf128() void {}
export fn fromfpf32() void {}
export fn fromfpf32x() void {}
export fn fromfpf64() void {}
export fn fromfpf64x() void {}
export fn fromfpl() void {}
export fn fromfpx() void {}
export fn fromfpxf() void {}
export fn fromfpxf128() void {}
export fn fromfpxf32() void {}
export fn fromfpxf32x() void {}
export fn fromfpxf64() void {}
export fn fromfpxf64x() void {}
export fn fromfpxl() void {}
export fn fsub() void {}
export fn fsubl() void {}
export fn gamma() void {}
export fn gammaf() void {}
export fn gammal() void {}
export fn getpayload() void {}
export fn getpayloadf() void {}
export fn getpayloadf128() void {}
export fn getpayloadf32() void {}
export fn getpayloadf32x() void {}
export fn getpayloadf64() void {}
export fn getpayloadf64x() void {}
export fn getpayloadl() void {}
export fn hypot() void {}
export fn hypotf() void {}
export fn hypotf128() void {}
export fn hypotf32() void {}
export fn hypotf32x() void {}
export fn hypotf64() void {}
export fn hypotf64x() void {}
export fn hypotl() void {}
export fn ilogb() void {}
export fn ilogbf() void {}
export fn ilogbf128() void {}
export fn ilogbf32() void {}
export fn ilogbf32x() void {}
export fn ilogbf64() void {}
export fn ilogbf64x() void {}
export fn ilogbl() void {}
export fn j0() void {}
export fn j0f() void {}
export fn j0f128() void {}
export fn j0f32() void {}
export fn j0f32x() void {}
export fn j0f64() void {}
export fn j0f64x() void {}
export fn j0l() void {}
export fn j1() void {}
export fn j1f() void {}
export fn j1f128() void {}
export fn j1f32() void {}
export fn j1f32x() void {}
export fn j1f64() void {}
export fn j1f64x() void {}
export fn j1l() void {}
export fn jn() void {}
export fn jnf() void {}
export fn jnf128() void {}
export fn jnf32() void {}
export fn jnf32x() void {}
export fn jnf64() void {}
export fn jnf64x() void {}
export fn jnl() void {}
export fn ldexp() void {}
export fn ldexpf() void {}
export fn ldexpf128() void {}
export fn ldexpf32() void {}
export fn ldexpf32x() void {}
export fn ldexpf64() void {}
export fn ldexpf64x() void {}
export fn ldexpl() void {}
export fn lgamma() void {}
export fn lgamma_r() void {}
export fn lgammaf() void {}
export fn lgammaf128() void {}
export fn lgammaf128_r() void {}
export fn lgammaf32() void {}
export fn lgammaf32_r() void {}
export fn lgammaf32x() void {}
export fn lgammaf32x_r() void {}
export fn lgammaf64() void {}
export fn lgammaf64_r() void {}
export fn lgammaf64x() void {}
export fn lgammaf64x_r() void {}
export fn lgammaf_r() void {}
export fn lgammal() void {}
export fn lgammal_r() void {}
export fn llogb() void {}
export fn llogbf() void {}
export fn llogbf128() void {}
export fn llogbf32() void {}
export fn llogbf32x() void {}
export fn llogbf64() void {}
export fn llogbf64x() void {}
export fn llogbl() void {}
export fn llrint() void {}
export fn llrintf() void {}
export fn llrintf128() void {}
export fn llrintf32() void {}
export fn llrintf32x() void {}
export fn llrintf64() void {}
export fn llrintf64x() void {}
export fn llrintl() void {}
export fn llround() void {}
export fn llroundf() void {}
export fn llroundf128() void {}
export fn llroundf32() void {}
export fn llroundf32x() void {}
export fn llroundf64() void {}
export fn llroundf64x() void {}
export fn llroundl() void {}
export fn log() void {}
export fn log10() void {}
export fn log10f() void {}
export fn log10f128() void {}
export fn log10f32() void {}
export fn log10f32x() void {}
export fn log10f64() void {}
export fn log10f64x() void {}
export fn log10l() void {}
export fn log1p() void {}
export fn log1pf() void {}
export fn log1pf128() void {}
export fn log1pf32() void {}
export fn log1pf32x() void {}
export fn log1pf64() void {}
export fn log1pf64x() void {}
export fn log1pl() void {}
export fn log2() void {}
export fn log2f() void {}
export fn log2f128() void {}
export fn log2f32() void {}
export fn log2f32x() void {}
export fn log2f64() void {}
export fn log2f64x() void {}
export fn log2l() void {}
export fn logb() void {}
export fn logbf() void {}
export fn logbf128() void {}
export fn logbf32() void {}
export fn logbf32x() void {}
export fn logbf64() void {}
export fn logbf64x() void {}
export fn logbl() void {}
export fn logf() void {}
export fn logf128() void {}
export fn logf32() void {}
export fn logf32x() void {}
export fn logf64() void {}
export fn logf64x() void {}
export fn logl() void {}
export fn lrint() void {}
export fn lrintf() void {}
export fn lrintf128() void {}
export fn lrintf32() void {}
export fn lrintf32x() void {}
export fn lrintf64() void {}
export fn lrintf64x() void {}
export fn lrintl() void {}
export fn lround() void {}
export fn lroundf() void {}
export fn lroundf128() void {}
export fn lroundf32() void {}
export fn lroundf32x() void {}
export fn lroundf64() void {}
export fn lroundf64x() void {}
export fn lroundl() void {}
export fn matherr() void {}
export fn modf() void {}
export fn modff() void {}
export fn modff128() void {}
export fn modff32() void {}
export fn modff32x() void {}
export fn modff64() void {}
export fn modff64x() void {}
export fn modfl() void {}
export fn nan() void {}
export fn nanf() void {}
export fn nanf128() void {}
export fn nanf32() void {}
export fn nanf32x() void {}
export fn nanf64() void {}
export fn nanf64x() void {}
export fn nanl() void {}
export fn nearbyint() void {}
export fn nearbyintf() void {}
export fn nearbyintf128() void {}
export fn nearbyintf32() void {}
export fn nearbyintf32x() void {}
export fn nearbyintf64() void {}
export fn nearbyintf64x() void {}
export fn nearbyintl() void {}
export fn nextafter() void {}
export fn nextafterf() void {}
export fn nextafterf128() void {}
export fn nextafterf32() void {}
export fn nextafterf32x() void {}
export fn nextafterf64() void {}
export fn nextafterf64x() void {}
export fn nextafterl() void {}
export fn nextdown() void {}
export fn nextdownf() void {}
export fn nextdownf128() void {}
export fn nextdownf32() void {}
export fn nextdownf32x() void {}
export fn nextdownf64() void {}
export fn nextdownf64x() void {}
export fn nextdownl() void {}
export fn nexttoward() void {}
export fn nexttowardf() void {}
export fn nexttowardl() void {}
export fn nextup() void {}
export fn nextupf() void {}
export fn nextupf128() void {}
export fn nextupf32() void {}
export fn nextupf32x() void {}
export fn nextupf64() void {}
export fn nextupf64x() void {}
export fn nextupl() void {}
export fn pow() void {}
export fn pow10() void {}
export fn pow10f() void {}
export fn pow10l() void {}
export fn powf() void {}
export fn powf128() void {}
export fn powf32() void {}
export fn powf32x() void {}
export fn powf64() void {}
export fn powf64x() void {}
export fn powl() void {}
export fn remainder() void {}
export fn remainderf() void {}
export fn remainderf128() void {}
export fn remainderf32() void {}
export fn remainderf32x() void {}
export fn remainderf64() void {}
export fn remainderf64x() void {}
export fn remainderl() void {}
export fn remquo() void {}
export fn remquof() void {}
export fn remquof128() void {}
export fn remquof32() void {}
export fn remquof32x() void {}
export fn remquof64() void {}
export fn remquof64x() void {}
export fn remquol() void {}
export fn rint() void {}
export fn rintf() void {}
export fn rintf128() void {}
export fn rintf32() void {}
export fn rintf32x() void {}
export fn rintf64() void {}
export fn rintf64x() void {}
export fn rintl() void {}
export fn round() void {}
export fn roundeven() void {}
export fn roundevenf() void {}
export fn roundevenf128() void {}
export fn roundevenf32() void {}
export fn roundevenf32x() void {}
export fn roundevenf64() void {}
export fn roundevenf64x() void {}
export fn roundevenl() void {}
export fn roundf() void {}
export fn roundf128() void {}
export fn roundf32() void {}
export fn roundf32x() void {}
export fn roundf64() void {}
export fn roundf64x() void {}
export fn roundl() void {}
export fn scalb() void {}
export fn scalbf() void {}
export fn scalbl() void {}
export fn scalbln() void {}
export fn scalblnf() void {}
export fn scalblnf128() void {}
export fn scalblnf32() void {}
export fn scalblnf32x() void {}
export fn scalblnf64() void {}
export fn scalblnf64x() void {}
export fn scalblnl() void {}
export fn scalbn() void {}
export fn scalbnf() void {}
export fn scalbnf128() void {}
export fn scalbnf32() void {}
export fn scalbnf32x() void {}
export fn scalbnf64() void {}
export fn scalbnf64x() void {}
export fn scalbnl() void {}
export fn setpayload() void {}
export fn setpayloadf() void {}
export fn setpayloadf128() void {}
export fn setpayloadf32() void {}
export fn setpayloadf32x() void {}
export fn setpayloadf64() void {}
export fn setpayloadf64x() void {}
export fn setpayloadl() void {}
export fn setpayloadsig() void {}
export fn setpayloadsigf() void {}
export fn setpayloadsigf128() void {}
export fn setpayloadsigf32() void {}
export fn setpayloadsigf32x() void {}
export fn setpayloadsigf64() void {}
export fn setpayloadsigf64x() void {}
export fn setpayloadsigl() void {}
export fn signgam() void {}
export fn significand() void {}
export fn significandf() void {}
export fn significandl() void {}
export fn sin() void {}
export fn sincos() void {}
export fn sincosf() void {}
export fn sincosf128() void {}
export fn sincosf32() void {}
export fn sincosf32x() void {}
export fn sincosf64() void {}
export fn sincosf64x() void {}
export fn sincosl() void {}
export fn sinf() void {}
export fn sinf128() void {}
export fn sinf32() void {}
export fn sinf32x() void {}
export fn sinf64() void {}
export fn sinf64x() void {}
export fn sinh() void {}
export fn sinhf() void {}
export fn sinhf128() void {}
export fn sinhf32() void {}
export fn sinhf32x() void {}
export fn sinhf64() void {}
export fn sinhf64x() void {}
export fn sinhl() void {}
export fn sinl() void {}
export fn sqrt() void {}
export fn sqrtf() void {}
export fn sqrtf128() void {}
export fn sqrtf32() void {}
export fn sqrtf32x() void {}
export fn sqrtf64() void {}
export fn sqrtf64x() void {}
export fn sqrtl() void {}
export fn tan() void {}
export fn tanf() void {}
export fn tanf128() void {}
export fn tanf32() void {}
export fn tanf32x() void {}
export fn tanf64() void {}
export fn tanf64x() void {}
export fn tanh() void {}
export fn tanhf() void {}
export fn tanhf128() void {}
export fn tanhf32() void {}
export fn tanhf32x() void {}
export fn tanhf64() void {}
export fn tanhf64x() void {}
export fn tanhl() void {}
export fn tanl() void {}
export fn tgamma() void {}
export fn tgammaf() void {}
export fn tgammaf128() void {}
export fn tgammaf32() void {}
export fn tgammaf32x() void {}
export fn tgammaf64() void {}
export fn tgammaf64x() void {}
export fn tgammal() void {}
export fn totalorder() void {}
export fn totalorderf() void {}
export fn totalorderf128() void {}
export fn totalorderf32() void {}
export fn totalorderf32x() void {}
export fn totalorderf64() void {}
export fn totalorderf64x() void {}
export fn totalorderl() void {}
export fn totalordermag() void {}
export fn totalordermagf() void {}
export fn totalordermagf128() void {}
export fn totalordermagf32() void {}
export fn totalordermagf32x() void {}
export fn totalordermagf64() void {}
export fn totalordermagf64x() void {}
export fn totalordermagl() void {}
export fn trunc() void {}
export fn truncf() void {}
export fn truncf128() void {}
export fn truncf32() void {}
export fn truncf32x() void {}
export fn truncf64() void {}
export fn truncf64x() void {}
export fn truncl() void {}
export fn ufromfp() void {}
export fn ufromfpf() void {}
export fn ufromfpf128() void {}
export fn ufromfpf32() void {}
export fn ufromfpf32x() void {}
export fn ufromfpf64() void {}
export fn ufromfpf64x() void {}
export fn ufromfpl() void {}
export fn ufromfpx() void {}
export fn ufromfpxf() void {}
export fn ufromfpxf128() void {}
export fn ufromfpxf32() void {}
export fn ufromfpxf32x() void {}
export fn ufromfpxf64() void {}
export fn ufromfpxf64x() void {}
export fn ufromfpxl() void {}
export fn y0() void {}
export fn y0f() void {}
export fn y0f128() void {}
export fn y0f32() void {}
export fn y0f32x() void {}
export fn y0f64() void {}
export fn y0f64x() void {}
export fn y0l() void {}
export fn y1() void {}
export fn y1f() void {}
export fn y1f128() void {}
export fn y1f32() void {}
export fn y1f32x() void {}
export fn y1f64() void {}
export fn y1f64x() void {}
export fn y1l() void {}
export fn yn() void {}
export fn ynf() void {}
export fn ynf128() void {}
export fn ynf32() void {}
export fn ynf32x() void {}
export fn ynf64() void {}
export fn ynf64x() void {}
export fn ynl() void {} | libc/dummy/m.zig |
const std = @import("std");
const token = @import("./token.zig");
const Token = token.Token;
const Cursor = token.Cursor;
pub const Block = @import("./token/block.zig").Block;
pub const @"Type" = @import("./token/type.zig").Type;
pub const Kw = @import("./token/kw.zig").Kw;
pub const Op = @import("./token/op.zig").Op;
// TODO Figure out why this comes out all messed up
pub const Expr = union(enum(u16)) {
decl: Op,
infix: Infix,
prefix: Prefix,
postfix: Postfix,
pub const Infix = packed struct {
op: *Op,
lhs: *@"Type",
rhs: *@"Type",
};
pub const Prefix = packed struct {
op: **Op,
ta: *@"Type",
tb: *@"Type",
};
pub const Postfix = packed struct {
ta: *@"Type",
tb: *@"Type",
op: *Op,
};
pub const Out = union(enum(i32)) {
boolean: bool,
int: i32,
float: f32,
str: []const u8,
byte: u8,
seq,
};
};
pub const ExprBlock = struct {
pos: Cursor,
sblock: Block,
alloc: std.mem.Allocator,
tokens: std.ArrayList(Token),
const Self = @This();
pub fn init(ln: usize, co: usize, block: Block, alloc: std.mem.Allocator) Self {
const tk = std.ArrayList(Token).init(alloc);
return Self{
.pos = Cursor{ .line = ln, .col = co },
.sblock = block,
.alloc = alloc,
.tokens = tk,
};
}
};
pub const LoopExpr = union(enum) {
forall: []token,
whhile: struct {
wexpr: []Token,
else_expr: []Token,
},
labeled: struct {
name: []const u8,
loop: *LoopExpr,
},
loop: []Token,
};
pub const Conditional = struct {}{};
pub const ConditionalExpr = enum(u3) {
If,
When,
Where,
While,
While,
Who,
};
/// A declaration is performed in the infix-operator pattern:
/// <Ident> <Kind> <Vis?> <Declaratio.Block?>
/// In some cases <Declaration.Value> can be multiple "words", indicating enumerationr of categories
/// Declaration.Block's contents or lack thereof are determined by the value
pub const Declaration = struct {
@"export": false,
ident: []const u8,
/// Must be in the set of
global: false,
kind: Declaration.Kind,
pub const Kind = union(enum(u8)) {
local: bool = true, // will actually be the result of (is in global scope or ()
};
}; | src/lang/expr.zig |
const fun = @import("fun");
const std = @import("std");
const debug = std.debug;
const heap = std.heap;
const io = std.io;
const math = std.math;
const mem = std.mem;
const os = std.os;
const scan = fun.scan.scan;
pub fn main() !void {
const stdin = &(try io.getStdIn()).inStream().stream;
const stdout = &(try io.getStdOut()).outStream().stream;
var ps = io.PeekStream(1, os.File.InStream.Error).init(stdin);
var direct_allocator = heap.DirectAllocator.init();
const allocator = &direct_allocator.allocator;
defer direct_allocator.deinit();
const records = try readRecords(allocator, &ps);
defer allocator.free(records);
std.sort.sort(Record, records, Record.lessThan);
var schedule = try sleepSchedule(allocator, records);
defer schedule.deinit();
try stdout.print("{}\n", strategy1(schedule));
try stdout.print("{}\n", strategy2(schedule));
}
fn readRecords(allocator: *mem.Allocator, ps: var) ![]Record {
var records = std.ArrayList(Record).init(allocator);
defer records.deinit();
while (readRecord(ps)) |record| {
try records.append(record);
} else |err| switch (err) {
error.EndOfStream => {},
else => return err,
}
return records.toOwnedSlice();
}
fn readRecord(ps: var) !Record {
const time = try scan(ps, "[{}-{}-{} {}:{}] ", Time);
const next = try ps.stream.readByte();
const kind = switch (next) {
'G' => blk: {
const res = try scan(ps, "uard #{} begins shift\n", struct {
id: u16,
});
break :blk Record.Kind{ .ShiftBegins = res.id };
},
'f' => blk: {
_ = try scan(ps, "alls asleep\n", struct {});
break :blk Record.Kind{ .FallsAsleep = {} };
},
'w' => blk: {
_ = try scan(ps, "akes up\n", struct {});
break :blk Record.Kind{ .WakesUp = {} };
},
else => return error.InvalidCharacter,
};
return Record{
.time = time,
.kind = kind,
};
}
fn sleepSchedule(allocator: *mem.Allocator, records: []const Record) !SleepSchedule {
const State = union(enum) {
Begin,
Awake: *SleepSchedule.KV,
Sleeps: Sleeps,
const Sleeps = struct {
start: Time,
guard: *SleepSchedule.KV,
};
};
var state: State = State.Begin;
var res = SleepSchedule.init(allocator);
errdefer {
var iter = res.iterator();
while (iter.next()) |guard|
guard.value.deinit();
res.deinit();
}
for (records) |record|
switch (state) {
State.Begin => switch (record.kind) {
Record.Kind.ShiftBegins => |guard_id| {
const kv = try res.getOrPutValue(guard_id, std.ArrayList(Sleep).init(allocator));
state = State{ .Awake = kv };
},
else => return error.InvalidInput,
},
State.Awake => |guard| switch (record.kind) {
Record.Kind.ShiftBegins => |guard_id| {
const kv = try res.getOrPutValue(guard_id, std.ArrayList(Sleep).init(allocator));
state = State{ .Awake = kv };
},
Record.Kind.FallsAsleep => state = State{
.Sleeps = State.Sleeps{
.start = record.time,
.guard = guard,
},
},
else => return error.InvalidInput,
},
@TagType(State).Sleeps => |sleeps| switch (record.kind) {
Record.Kind.WakesUp => {
try sleeps.guard.value.append(Sleep{
.start = sleeps.start,
.end = record.time,
});
state = State{ .Awake = sleeps.guard };
},
else => return error.InvalidInput,
},
};
switch (state) {
State.Begin => {},
State.Awake => {},
@TagType(State).Sleeps => return error.InvalidInput,
}
return res;
}
fn strategy1(schedule: SleepSchedule) usize {
const Best = struct {
guard: u16,
minutes: u64,
minut_most_asleep: usize,
};
var best = Best{
.guard = 0,
.minutes = 0,
.minut_most_asleep = 0,
};
var iter = schedule.iterator();
while (iter.next()) |guard| {
var minutes = []usize{0} ** 60;
for (guard.value.toSlice()) |sleep| {
var min = sleep.start.min;
while (min < sleep.end.min) : (min += 1)
minutes[min] += 1;
}
const asleep_for = sum(usize, minutes);
if (best.minutes < asleep_for) {
best = Best{
.guard = guard.key,
.minutes = asleep_for,
.minut_most_asleep = maxIndex(usize, minutes).?,
};
}
}
return best.guard * best.minut_most_asleep;
}
fn strategy2(schedule: SleepSchedule) usize {
const Best = struct {
guard: u16,
minutes: u64,
minut_most_asleep: usize,
};
var best = Best{
.guard = 0,
.minutes = 0,
.minut_most_asleep = 0,
};
var iter = schedule.iterator();
while (iter.next()) |guard| {
var minutes = []usize{0} ** 60;
for (guard.value.toSlice()) |sleep| {
var min = sleep.start.min;
while (min < sleep.end.min) : (min += 1)
minutes[min] += 1;
}
const minut_most_asleep = maxIndex(usize, minutes).?;
if (best.minutes < minutes[minut_most_asleep]) {
best = Best{
.guard = guard.key,
.minutes = minutes[minut_most_asleep],
.minut_most_asleep = minut_most_asleep,
};
}
}
return best.guard * best.minut_most_asleep;
}
fn sum(comptime T: type, buf: []const T) u64 {
var res: u64 = 0;
for (buf) |item|
res += item;
return res;
}
fn maxIndex(comptime T: type, buf: []const T) ?usize {
if (buf.len == 0)
return null;
var res: usize = 0;
for (buf[1..]) |item, i| {
if (buf[res] < item)
res = i + 1;
}
return res;
}
const Record = struct {
time: Time,
kind: Kind,
const Kind = union(enum) {
ShiftBegins: u16,
FallsAsleep,
WakesUp,
};
fn lessThan(a: Record, b: Record) bool {
return a.time.lessThan(b.time);
}
};
const Time = struct {
year: u16,
month: u8,
day: u8,
hour: u8,
min: u8,
fn lessThan(a: Time, b: Time) bool {
inline for (@typeInfo(Time).Struct.fields) |f| {
if (@field(a, f.name) < @field(b, f.name))
return true;
if (@field(a, f.name) > @field(b, f.name))
return false;
}
return false;
}
};
const SleepSchedule = std.AutoHashMap(u16, std.ArrayList(Sleep));
const Sleep = struct {
start: Time,
end: Time,
}; | src/day4.zig |
// TODO: Use atomicRmw?
// https://reddit.com/comments/u4kc0j/comment/i4wycmb?context=3
const assert = @import("std").debug.assert;
pub fn Register(comptime Inner: type, comptime ReadWrite: type) type {
return AsymmetricRegister(Inner, ReadWrite, ReadWrite);
}
pub fn AsymmetricRegister(comptime Inner: type, comptime Read: type, comptime Write: type) type {
comptime {
assert(@bitSizeOf(Read) == @bitSizeOf(Inner));
assert(@bitSizeOf(Write) == @bitSizeOf(Inner));
}
return struct {
raw_ptr: *volatile Inner,
const Self = @This();
pub fn init(address: usize) Self {
return .{ .raw_ptr = @intToPtr(*volatile Inner, address) };
}
pub fn read_raw(self: Self) Inner {
return self.raw_ptr.*;
}
pub fn write_raw(self: Self, value: Inner) void {
self.raw_ptr.* = value;
}
pub fn read(self: Self) Read {
return @bitCast(Read, self.raw_ptr.*);
}
pub fn write(self: Self, value: Write) void {
self.raw_ptr.* = @bitCast(Inner, value);
}
pub fn modify(self: Self, new_value: anytype) void {
if (Read != Write) {
@compileError("can't modify because read and write types for this register aren't the same");
}
var value = self.read();
const info = @typeInfo(@TypeOf(new_value));
// new_value is an anonymous struct type with just the fields specified
// in it. We try to set fields with the same name in the register
// struct type to the values in new_value. If the types don't match,
// or if there are fields in new_value that aren't in the register
// struct, a compile error naturally occurs.
inline for (info.Struct.fields) |field| {
@field(value, field.name) = @field(new_value, field.name);
}
self.write(value);
}
};
}
test "register" {
const pin_cnf_val = packed struct {
dir: enum(u1) {
input = 0,
output = 1,
} = .input,
input: enum(u1) {
connect = 0,
disconnect = 1,
} = .disconnect,
pull: enum(u2) {
disabled = 0,
pulldown = 1,
pullup = 3,
} = .disabled,
_unused4: u4 = 0,
drive: enum(u3) {
s0s1 = 0,
h0s1 = 1,
s0h1 = 2,
h0h1 = 3,
d0s1 = 4,
d0h1 = 5,
s0d1 = 6,
h0d1 = 7,
} = .s0s1,
_unused11: u5 = 0,
sense: enum(u2) {
disabled = 0,
high = 2,
low = 3,
} = .disabled,
_unused18: u14 = 0,
};
const reg = Register(u32, pin_cnf_val, pin_cnf_val).new(0x708);
_ = reg;
} | src/mmio_register.zig |
const std = @import("std");
const pike = @import("pike.zig");
const Waker = @import("waker.zig").Waker;
const os = std.os;
pub const Event = struct {
const Self = @This();
handle: pike.Handle = .{
.inner = -1,
.wake_fn = wake,
},
waker: Waker = .{},
inner: os.Kevent,
notifier: os.fd_t,
var count: u32 = 0;
pub fn init() !Self {
const ident = @atomicRmw(u32, &count, .Add, 1, .SeqCst);
return Self{
.inner = .{
.ident = @intCast(usize, ident),
.filter = os.EVFILT_USER,
.flags = os.EV_ADD | os.EV_DISABLE,
.fflags = 0,
.data = 0,
.udata = 0,
},
.notifier = -1,
};
}
pub fn deinit(self: *Self) void {
_ = @atomicRmw(u32, &count, .Sub, 1, .SeqCst);
self.inner.flags = os.EV_DELETE;
self.inner.fflags = 0;
if ((os.kevent(self.notifier, @as(*const [1]os.Kevent, &self.inner), &[0]os.Kevent{}, null) catch unreachable) != 0) {
@panic("pike/event (darwin): unexpectedly registered new events while calling deinit()");
}
if (self.waker.shutdown()) |task| pike.dispatch(task, .{});
}
pub fn registerTo(self: *Self, notifier: *const pike.Notifier) !void {
self.notifier = notifier.handle;
self.inner.udata = @ptrToInt(self);
if ((try os.kevent(self.notifier, @as(*const [1]os.Kevent, &self.inner), &[0]os.Kevent{}, null)) != 0) {
return error.Unexpected;
}
self.inner.flags = os.EV_ENABLE;
self.inner.fflags = os.NOTE_TRIGGER;
}
inline fn wake(handle: *pike.Handle, batch: *pike.Batch, opts: pike.WakeOptions) void {
const self = @fieldParentPtr(Self, "handle", handle);
if (opts.write_ready) @panic("pike/event (darwin): kqueue unexpectedly reported write-readiness");
if (opts.read_ready) @panic("pike/event (darwin): kqueue unexpectedly reported read-readiness");
if (opts.notify) if (self.waker.notify()) |task| batch.push(task);
if (opts.shutdown) if (self.waker.shutdown()) |task| batch.push(task);
}
pub fn post(self: *Self) callconv(.Async) !void {
if ((try os.kevent(self.notifier, @as(*const [1]os.Kevent, &self.inner), &[0]os.Kevent{}, null)) != 0) {
return error.Unexpected;
}
try self.waker.wait(.{});
}
}; | event_kqueue.zig |
const std = @import("std");
pub const OptionType = enum {
long,
short,
};
pub const OptionInterpretation = struct {
option_type: OptionType,
name: []const u8,
value: ?[]const u8 = null,
};
pub const ArgumentInterpretation = union(enum) {
option: OptionInterpretation,
double_dash: void,
other: []const u8,
};
pub fn interpret(arg: []const u8) !ArgumentInterpretation {
if (arg.len == 0) return ArgumentInterpretation{ .other = arg };
if (arg[0] == '-') {
if (arg.len == 1) return ArgumentInterpretation{ .other = arg };
var name = arg[1..];
var option_type = OptionType.short;
if (arg[1] == '-') {
if (arg.len == 2) return ArgumentInterpretation.double_dash;
name = arg[2..];
option_type = .long;
}
if (std.mem.indexOfScalar(u8, name, '=')) |ix| {
if (name.len < ix + 2) return error.MissingOptionArgument;
return ArgumentInterpretation{ .option = OptionInterpretation{
.option_type = option_type,
.name = name[0..ix],
.value = name[ix + 1 ..],
} };
} else {
return ArgumentInterpretation{ .option = OptionInterpretation{
.option_type = option_type,
.name = name,
} };
}
} else {
return ArgumentInterpretation{ .other = arg };
}
}
const expect = std.testing.expect;
test "long without value" {
const out = try interpret("--abc");
try expect(out.option.option_type == .long);
try expect(std.mem.eql(u8, out.option.name, "abc"));
try expect(out.option.value == null);
}
test "long with value" {
const out = try interpret("--abc=val");
try expect(out.option.option_type == .long);
try expect(std.mem.eql(u8, out.option.name, "abc"));
try expect(std.mem.eql(u8, out.option.value.?, "val"));
}
test "short without value" {
const out = try interpret("-a");
try expect(out.option.option_type == .short);
try expect(std.mem.eql(u8, out.option.name, "a"));
try expect(out.option.value == null);
}
test "short with value" {
const out = try interpret("-c=val");
try expect(out.option.option_type == .short);
try expect(std.mem.eql(u8, out.option.name, "c"));
try expect(std.mem.eql(u8, out.option.value.?, "val"));
}
test "multi short with value" {
const out = try interpret("-abc=val");
try expect(out.option.option_type == .short);
try expect(std.mem.eql(u8, out.option.name, "abc"));
try expect(std.mem.eql(u8, out.option.value.?, "val"));
}
test "dashes" {
const out = try interpret("--");
try expect(out == ArgumentInterpretation.double_dash);
}
test "others" {
var out = try interpret("abc");
try expect(std.mem.eql(u8, out.other, "abc"));
out = try interpret("-");
try expect(std.mem.eql(u8, out.other, "-"));
}
test "missing option value" {
if (interpret("--abc=")) |_| {
try expect(false);
} else |err| {
try expect(err == error.MissingOptionArgument);
}
} | src/arg.zig |
const std = @import("std");
const zupnp = @import("../../lib.zig");
const ActionError = zupnp.upnp.definition.ActionError;
const ActionRequest = zupnp.upnp.device.ActionRequest;
const ActionResult = zupnp.upnp.device.ActionResult;
const EventSubscriptionRequest = zupnp.upnp.device.EventSubscriptionRequest;
const EventSubscriptionResult = zupnp.upnp.device.EventSubscriptionResult;
pub fn AbstractDevice(comptime DeviceType: type, logger: anytype, services: anytype) type {
return struct {
pub fn handleAction(self: *DeviceType, request: ActionRequest) ActionResult {
const service_id = request.getServiceId();
logger.debug(
"Received action request for service ID {s} action {s} from {s}",
.{service_id, request.getActionName(), request.getClientAddress().toString()}
);
inline for (services) |service_str| {
const ServiceClass = @TypeOf(@field(self, service_str));
if (std.mem.eql(u8, service_id, ServiceClass.service_definition.service_id)) {
return @field(self, service_str).handleAction(request);
}
}
logger.debug("Unhandled action service ID {s}", .{service_id});
return ActionResult.createError(ActionError.UnhandledActionServiceId.toErrorCode());
}
pub fn handleEventSubscription(self: *DeviceType, request: EventSubscriptionRequest) EventSubscriptionResult {
const service_id = request.getServiceId();
logger.debug("Received event subscription request for service ID {s} SID {s}", .{service_id, request.getSid()});
inline for (services) |service_str| {
const ServiceClass = @TypeOf(@field(self, service_str));
if (std.mem.eql(u8, service_id, ServiceClass.service_definition.service_id)) {
return @field(self, service_str).handleEventSubscription(request);
}
}
logger.debug("Unhandled event subscription service ID {s}", .{service_id});
return EventSubscriptionResult.createError();
}
};
}
pub fn AbstractService(comptime ServiceType: type, logger: anytype, actions_to_functions: anytype) type {
return struct {
pub fn handleAction(self: *ServiceType, request: ActionRequest) ActionResult {
const action_name = request.getActionName();
inline for (actions_to_functions) |action_to_function| {
const target_action_name = action_to_function.@"0".action_name;
if (std.mem.eql(u8, action_name, target_action_name)) {
return action_to_function.@"1"(self, request) catch |err| blk: {
logger.err("Failed to create action request: {s}", .{@errorName(err)});
break :blk ActionResult.createError(ActionError.ActionFailed.toErrorCode());
};
}
}
logger.debug("Unhandled action {s}", .{action_name});
return ActionResult.createError(ActionError.InvalidAction.toErrorCode());
}
pub fn handleEventSubscription(self: *ServiceType, _: EventSubscriptionRequest) EventSubscriptionResult {
return EventSubscriptionResult.createResult(self.state) catch |err| blk: {
logger.err("Failed to create event subscription request: {s}", .{@errorName(err)});
break :blk EventSubscriptionResult.createError();
};
}
};
} | src/upnp/device/abstract.zig |
const c = @import("c.zig").c;
// Input focus window hint and attribute
/// Input focus window hit or window attribute.
pub const focused = c.GLFW_FOCUSED;
/// Window iconification window attribute.
pub const iconified = c.GLFW_ICONIFIED;
// Window resize-ability window hint and attribute
pub const resizable = c.GLFW_RESIZABLE;
/// Window visibility window hint and attribute
pub const visible = c.GLFW_VISIBLE;
/// Window decoration window hint and attribute
pub const decorated = c.GLFW_DECORATED;
/// Window auto-iconification window hint and attribute
pub const auto_iconify = c.GLFW_AUTO_ICONIFY;
/// Window decoration window hint and attribute
pub const floating = c.GLFW_FLOATING;
/// Window maximization window hint and attribute
pub const maximized = c.GLFW_MAXIMIZED;
/// Cursor centering window hint
pub const center = c.GLFW_CENTER_CURSOR;
/// Window framebuffer transparency hint and attribute
pub const transparent_framebuffer = c.GLFW_TRANSPARENT_FRAMEBUFFER;
/// Mouse cursor hover window attribute.
pub const hovered = c.GLFW_HOVERED;
/// Input focus on calling show window hint and attribute
pub const focus_on_show = c.GLFW_FOCUS_ON_SHOW;
/// Framebuffer bit depth hint.
pub const red_bits = c.GLFW_RED_BITS;
/// Framebuffer bit depth hint.
pub const green_bits = c.GLFW_GREEN_BITS;
/// Framebuffer bit depth hint.
pub const blue_bits = c.GLFW_BLUE_BITS;
/// Framebuffer bit depth hint.
pub const alpha_bits = c.GLFW_ALPHA_BITS;
/// Framebuffer bit depth hint.
pub const depth_bits = c.GLFW_DEPTH_BITS;
/// Framebuffer bit depth hint.
pub const stencil_bits = c.GLFW_STENCIL_BITS;
/// Framebuffer bit depth hint.
pub const accum_red_bits = c.GLFW_ACCUM_RED_BITS;
/// Framebuffer bit depth hint.
pub const accum_green_bits = c.GLFW_ACCUM_GREEN_BITS;
/// Framebuffer bit depth hint.
pub const accum_blue_bits = c.GLFW_ACCUM_BLUE_BITS;
/// Framebuffer bit depth hint.
pub const accum_alpha_bits = c.GLFW_ACCUM_ALPHA_BITS;
/// Framebuffer auxiliary buffer hint.
pub const aux_buffers = c.GLFW_AUX_BUFFERS;
/// OpenGL stereoscopic rendering hint.
pub const stereo = c.GLFW_STEREO;
/// Framebuffer MSAA samples hint.
pub const samples = c.GLFW_SAMPLES;
/// Framebuffer sRGB hint.
pub const srgb_capable = c.GLFW_SRGB_CAPABLE;
/// Monitor refresh rate hint.
pub const refresh_rate = c.GLFW_REFRESH_RATE;
/// Framebuffer double buffering hint.
pub const doublebuffer = c.GLFW_DOUBLEBUFFER;
/// Context client API hint and attribute.
pub const client_api = c.GLFW_CLIENT_API;
/// Context client API major version hint and attribute.
pub const context_version_major = c.GLFW_CONTEXT_VERSION_MAJOR;
/// Context client API minor version hint and attribute.
pub const context_version_minor = c.GLFW_CONTEXT_VERSION_MINOR;
/// Context client API revision number hint and attribute.
pub const context_revision = c.GLFW_CONTEXT_REVISION;
/// Context robustness hint and attribute.
pub const context_robustness = c.GLFW_CONTEXT_ROBUSTNESS;
/// OpenGL forward-compatibility hint and attribute.
pub const opengl_foward_compat = c.GLFW_OPENGL_FORWARD_COMPAT;
/// Debug mode context hint and attribute.
pub const opengl_debug_context = c.GLFW_OPENGL_DEBUG_CONTEXT;
/// OpenGL profile hint and attribute.
pub const opengl_profile = c.GLFW_OPENGL_PROFILE;
/// Context flush-on-release hint and attribute.
pub const context_release_behavior = c.GLFW_CONTEXT_RELEASE_BEHAVIOR;
/// Context error suppression hint and attribute.
pub const context_no_error = c.GLFW_CONTEXT_NO_ERROR;
/// Context creation API hint and attribute.
pub const context_creation_api = c.GLFW_CONTEXT_CREATION_API;
/// Window content area scaling window
pub const scale_to_monitor = c.GLFW_SCALE_TO_MONITOR;
/// macOS specific
pub const cocoa_retina_framebuffer = c.GLFW_COCOA_RETINA_FRAMEBUFFER;
/// macOS specific
pub const cocoa_frame_name = c.GLFW_COCOA_FRAME_NAME;
/// macOS specific
pub const cocoa_graphics_switching = c.GLFW_COCOA_GRAPHICS_SWITCHING;
/// X11 specific
pub const x11_class_name = c.GLFW_X11_CLASS_NAME;
/// X11 specific
pub const x11_instance_name = c.GLFW_X11_INSTANCE_NAME;
pub const no_api = c.GLFW_NO_API;
pub const opengl_api = c.GLFW_OPENGL_API;
pub const opengl_es_api = c.GLFW_OPENGL_ES_API;
pub const no_robustness = c.GLFW_NO_ROBUSTNESS;
pub const no_reset_notification = c.GLFW_NO_RESET_NOTIFICATION;
pub const lose_context_on_reset = c.GLFW_LOSE_CONTEXT_ON_RESET;
pub const opengl_any_profile = c.GLFW_OPENGL_ANY_PROFILE;
pub const opengl_core_profile = c.GLFW_OPENGL_CORE_PROFILE;
pub const opengl_compat_profile = c.GLFW_OPENGL_COMPAT_PROFILE;
pub const cursor = c.GLFW_CURSOR;
pub const sticky_keys = c.GLFW_STICKY_KEYS;
pub const sticky_mouse_buttons = c.GLFW_STICKY_MOUSE_BUTTONS;
pub const lock_key_mods = c.GLFW_LOCK_KEY_MODS;
pub const raw_mouse_motion = c.GLFW_RAW_MOUSE_MOTION;
pub const cursor_normal = c.GLFW_CURSOR_NORMAL;
pub const cursor_hidden = c.GLFW_CURSOR_HIDDEN;
pub const cursor_disabled = c.GLFW_CURSOR_DISABLED;
pub const any_release_behavior = c.GLFW_ANY_RELEASE_BEHAVIOR;
pub const release_behavior_flush = c.GLFW_RELEASE_BEHAVIOR_FLUSH;
pub const release_behavior_none = c.GLFW_RELEASE_BEHAVIOR_NONE;
pub const native_context_api = c.GLFW_NATIVE_CONTEXT_API;
pub const egl_context_api = c.GLFW_EGL_CONTEXT_API;
pub const osmesa_context_api = c.GLFW_OSMESA_CONTEXT_API;
// Standard system cursor shapes.
/// The regular arrow cursor shape.
pub const arrow_cursor = c.GLFW_ARROW_CURSOR;
/// The text input I-beam cursor shape.
pub const ibeam_cursor = c.GLFW_IBEAM_CURSOR;
/// The crosshair shape.
pub const crosshair_cursor = c.GLFW_CROSSHAIR_CURSOR;
/// The hand shape.
pub const hand_cursor = c.GLFW_HAND_CURSOR;
/// The horizontal resize arrow shape.
pub const hresize_cursor = c.GLFW_HRESIZE_CURSOR;
/// The vertical resize arrow shape.
pub const vresize_cursor = c.GLFW_VRESIZE_CURSOR;
pub const connected = c.GLFW_CONNECTED;
pub const disconnected = c.GLFW_DISCONNECTED;
/// Joystick hat buttons init hint.
pub const joystick_hat_buttons = c.GLFW_JOYSTICK_HAT_BUTTONS;
/// macOS specific init hint.
pub const cocoa_chdir_resources = c.GLFW_COCOA_CHDIR_RESOURCES;
/// macOS specific init hint.
pub const cocoa_menubar = c.GLFW_COCOA_MENUBAR;
pub const dont_care = c.GLFW_DONT_CARE; | glfw/src/consts.zig |
const std = @import("../index.zig");
const assert = std.debug.assert;
const ArrayList = std.ArrayList;
const mem = std.mem;
const ast = std.zig.ast;
const Tokenizer = std.zig.Tokenizer;
const Token = std.zig.Token;
const builtin = @import("builtin");
const io = std.io;
// TODO when we make parse errors into error types instead of printing directly,
// get rid of this
const warn = std.debug.warn;
pub const Parser = struct {
util_allocator: &mem.Allocator,
tokenizer: &Tokenizer,
put_back_tokens: [2]Token,
put_back_count: usize,
source_file_name: []const u8,
pub const Tree = struct {
root_node: &ast.Node.Root,
arena_allocator: std.heap.ArenaAllocator,
pub fn deinit(self: &Tree) void {
self.arena_allocator.deinit();
}
};
// This memory contents are used only during a function call. It's used to repurpose memory;
// we reuse the same bytes for the stack data structure used by parsing, tree rendering, and
// source rendering.
const utility_bytes_align = @alignOf( union { a: RenderAstFrame, b: State, c: RenderState } );
utility_bytes: []align(utility_bytes_align) u8,
/// allocator must outlive the returned Parser and all the parse trees you create with it.
pub fn init(tokenizer: &Tokenizer, allocator: &mem.Allocator, source_file_name: []const u8) Parser {
return Parser {
.util_allocator = allocator,
.tokenizer = tokenizer,
.put_back_tokens = undefined,
.put_back_count = 0,
.source_file_name = source_file_name,
.utility_bytes = []align(utility_bytes_align) u8{},
};
}
pub fn deinit(self: &Parser) void {
self.util_allocator.free(self.utility_bytes);
}
const TopLevelDeclCtx = struct {
decls: &ArrayList(&ast.Node),
visib_token: ?Token,
extern_export_inline_token: ?Token,
lib_name: ?&ast.Node,
};
const VarDeclCtx = struct {
mut_token: Token,
visib_token: ?Token,
comptime_token: ?Token,
extern_export_token: ?Token,
lib_name: ?&ast.Node,
list: &ArrayList(&ast.Node),
comments: ?&ast.Node.LineComment,
};
const TopLevelExternOrFieldCtx = struct {
visib_token: Token,
container_decl: &ast.Node.ContainerDecl,
};
const ExternTypeCtx = struct {
opt_ctx: OptionalCtx,
extern_token: Token,
comments: ?&ast.Node.LineComment,
};
const ContainerKindCtx = struct {
opt_ctx: OptionalCtx,
ltoken: Token,
layout: ast.Node.ContainerDecl.Layout,
};
const ExpectTokenSave = struct {
id: Token.Id,
ptr: &Token,
};
const OptionalTokenSave = struct {
id: Token.Id,
ptr: &?Token,
};
const ExprListCtx = struct {
list: &ArrayList(&ast.Node),
end: Token.Id,
ptr: &Token,
};
fn ListSave(comptime T: type) type {
return struct {
list: &ArrayList(T),
ptr: &Token,
};
}
const MaybeLabeledExpressionCtx = struct {
label: Token,
opt_ctx: OptionalCtx,
};
const LabelCtx = struct {
label: ?Token,
opt_ctx: OptionalCtx,
};
const InlineCtx = struct {
label: ?Token,
inline_token: ?Token,
opt_ctx: OptionalCtx,
};
const LoopCtx = struct {
label: ?Token,
inline_token: ?Token,
loop_token: Token,
opt_ctx: OptionalCtx,
};
const AsyncEndCtx = struct {
ctx: OptionalCtx,
attribute: &ast.Node.AsyncAttribute,
};
const ErrorTypeOrSetDeclCtx = struct {
opt_ctx: OptionalCtx,
error_token: Token,
};
const ParamDeclEndCtx = struct {
fn_proto: &ast.Node.FnProto,
param_decl: &ast.Node.ParamDecl,
};
const ComptimeStatementCtx = struct {
comptime_token: Token,
block: &ast.Node.Block,
};
const OptionalCtx = union(enum) {
Optional: &?&ast.Node,
RequiredNull: &?&ast.Node,
Required: &&ast.Node,
pub fn store(self: &const OptionalCtx, value: &ast.Node) void {
switch (*self) {
OptionalCtx.Optional => |ptr| *ptr = value,
OptionalCtx.RequiredNull => |ptr| *ptr = value,
OptionalCtx.Required => |ptr| *ptr = value,
}
}
pub fn get(self: &const OptionalCtx) ?&ast.Node {
switch (*self) {
OptionalCtx.Optional => |ptr| return *ptr,
OptionalCtx.RequiredNull => |ptr| return ??*ptr,
OptionalCtx.Required => |ptr| return *ptr,
}
}
pub fn toRequired(self: &const OptionalCtx) OptionalCtx {
switch (*self) {
OptionalCtx.Optional => |ptr| {
return OptionalCtx { .RequiredNull = ptr };
},
OptionalCtx.RequiredNull => |ptr| return *self,
OptionalCtx.Required => |ptr| return *self,
}
}
};
const State = union(enum) {
TopLevel,
TopLevelExtern: TopLevelDeclCtx,
TopLevelLibname: TopLevelDeclCtx,
TopLevelDecl: TopLevelDeclCtx,
TopLevelExternOrField: TopLevelExternOrFieldCtx,
ContainerKind: ContainerKindCtx,
ContainerInitArgStart: &ast.Node.ContainerDecl,
ContainerInitArg: &ast.Node.ContainerDecl,
ContainerDecl: &ast.Node.ContainerDecl,
VarDecl: VarDeclCtx,
VarDeclAlign: &ast.Node.VarDecl,
VarDeclEq: &ast.Node.VarDecl,
FnDef: &ast.Node.FnProto,
FnProto: &ast.Node.FnProto,
FnProtoAlign: &ast.Node.FnProto,
FnProtoReturnType: &ast.Node.FnProto,
ParamDecl: &ast.Node.FnProto,
ParamDeclAliasOrComptime: &ast.Node.ParamDecl,
ParamDeclName: &ast.Node.ParamDecl,
ParamDeclEnd: ParamDeclEndCtx,
ParamDeclComma: &ast.Node.FnProto,
MaybeLabeledExpression: MaybeLabeledExpressionCtx,
LabeledExpression: LabelCtx,
Inline: InlineCtx,
While: LoopCtx,
WhileContinueExpr: &?&ast.Node,
For: LoopCtx,
Else: &?&ast.Node.Else,
Block: &ast.Node.Block,
Statement: &ast.Node.Block,
ComptimeStatement: ComptimeStatementCtx,
Semicolon: &&ast.Node,
AsmOutputItems: &ArrayList(&ast.Node.AsmOutput),
AsmOutputReturnOrType: &ast.Node.AsmOutput,
AsmInputItems: &ArrayList(&ast.Node.AsmInput),
AsmClopperItems: &ArrayList(&ast.Node),
ExprListItemOrEnd: ExprListCtx,
ExprListCommaOrEnd: ExprListCtx,
FieldInitListItemOrEnd: ListSave(&ast.Node.FieldInitializer),
FieldInitListCommaOrEnd: ListSave(&ast.Node.FieldInitializer),
FieldListCommaOrEnd: &ast.Node.ContainerDecl,
IdentifierListItemOrEnd: ListSave(&ast.Node),
IdentifierListCommaOrEnd: ListSave(&ast.Node),
SwitchCaseOrEnd: ListSave(&ast.Node.SwitchCase),
SwitchCaseCommaOrEnd: ListSave(&ast.Node.SwitchCase),
SwitchCaseFirstItem: &ArrayList(&ast.Node),
SwitchCaseItem: &ArrayList(&ast.Node),
SwitchCaseItemCommaOrEnd: &ArrayList(&ast.Node),
SuspendBody: &ast.Node.Suspend,
AsyncAllocator: &ast.Node.AsyncAttribute,
AsyncEnd: AsyncEndCtx,
ExternType: ExternTypeCtx,
SliceOrArrayAccess: &ast.Node.SuffixOp,
SliceOrArrayType: &ast.Node.PrefixOp,
AddrOfModifiers: &ast.Node.PrefixOp.AddrOfInfo,
Payload: OptionalCtx,
PointerPayload: OptionalCtx,
PointerIndexPayload: OptionalCtx,
Expression: OptionalCtx,
RangeExpressionBegin: OptionalCtx,
RangeExpressionEnd: OptionalCtx,
AssignmentExpressionBegin: OptionalCtx,
AssignmentExpressionEnd: OptionalCtx,
UnwrapExpressionBegin: OptionalCtx,
UnwrapExpressionEnd: OptionalCtx,
BoolOrExpressionBegin: OptionalCtx,
BoolOrExpressionEnd: OptionalCtx,
BoolAndExpressionBegin: OptionalCtx,
BoolAndExpressionEnd: OptionalCtx,
ComparisonExpressionBegin: OptionalCtx,
ComparisonExpressionEnd: OptionalCtx,
BinaryOrExpressionBegin: OptionalCtx,
BinaryOrExpressionEnd: OptionalCtx,
BinaryXorExpressionBegin: OptionalCtx,
BinaryXorExpressionEnd: OptionalCtx,
BinaryAndExpressionBegin: OptionalCtx,
BinaryAndExpressionEnd: OptionalCtx,
BitShiftExpressionBegin: OptionalCtx,
BitShiftExpressionEnd: OptionalCtx,
AdditionExpressionBegin: OptionalCtx,
AdditionExpressionEnd: OptionalCtx,
MultiplyExpressionBegin: OptionalCtx,
MultiplyExpressionEnd: OptionalCtx,
CurlySuffixExpressionBegin: OptionalCtx,
CurlySuffixExpressionEnd: OptionalCtx,
TypeExprBegin: OptionalCtx,
TypeExprEnd: OptionalCtx,
PrefixOpExpression: OptionalCtx,
SuffixOpExpressionBegin: OptionalCtx,
SuffixOpExpressionEnd: OptionalCtx,
PrimaryExpression: OptionalCtx,
ErrorTypeOrSetDecl: ErrorTypeOrSetDeclCtx,
StringLiteral: OptionalCtx,
Identifier: OptionalCtx,
IfToken: @TagType(Token.Id),
IfTokenSave: ExpectTokenSave,
ExpectToken: @TagType(Token.Id),
ExpectTokenSave: ExpectTokenSave,
OptionalTokenSave: OptionalTokenSave,
};
/// Returns an AST tree, allocated with the parser's allocator.
/// Result should be freed with tree.deinit() when there are
/// no more references to any AST nodes of the tree.
pub fn parse(self: &Parser) !Tree {
var stack = self.initUtilityArrayList(State);
defer self.deinitUtilityArrayList(stack);
var arena_allocator = std.heap.ArenaAllocator.init(self.util_allocator);
errdefer arena_allocator.deinit();
const arena = &arena_allocator.allocator;
const root_node = try self.createNode(arena, ast.Node.Root,
ast.Node.Root {
.base = undefined,
.decls = ArrayList(&ast.Node).init(arena),
// initialized when we get the eof token
.eof_token = undefined,
}
);
try stack.append(State.TopLevel);
while (true) {
//{
// const token = self.getNextToken();
// warn("{} ", @tagName(token.id));
// self.putBackToken(token);
// var i: usize = stack.len;
// while (i != 0) {
// i -= 1;
// warn("{} ", @tagName(stack.items[i]));
// }
// warn("\n");
//}
// This gives us 1 free append that can't fail
const state = stack.pop();
switch (state) {
State.TopLevel => {
const comments = try self.eatComments(arena);
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_test => {
stack.append(State.TopLevel) catch unreachable;
const block = try self.createNode(arena, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = null,
.lbrace = undefined,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
const test_node = try self.createAttachNode(arena, &root_node.decls, ast.Node.TestDecl,
ast.Node.TestDecl {
.base = undefined,
.comments = comments,
.test_token = token,
.name = undefined,
.body_node = &block.base,
}
);
stack.append(State { .Block = block }) catch unreachable;
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.LBrace,
.ptr = &block.rbrace,
}
});
try stack.append(State { .StringLiteral = OptionalCtx { .Required = &test_node.name } });
continue;
},
Token.Id.Eof => {
root_node.eof_token = token;
return Tree {.root_node = root_node, .arena_allocator = arena_allocator};
},
Token.Id.Keyword_pub => {
stack.append(State.TopLevel) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &root_node.decls,
.visib_token = token,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
},
Token.Id.Keyword_comptime => {
const block = try self.createNode(arena, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = null,
.lbrace = undefined,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
const node = try self.createAttachNode(arena, &root_node.decls, ast.Node.Comptime,
ast.Node.Comptime {
.base = undefined,
.comptime_token = token,
.expr = &block.base,
}
);
stack.append(State.TopLevel) catch unreachable;
try stack.append(State { .Block = block });
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.LBrace,
.ptr = &block.rbrace,
}
});
continue;
},
else => {
self.putBackToken(token);
stack.append(State.TopLevel) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &root_node.decls,
.visib_token = null,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
},
}
},
State.TopLevelExtern => |ctx| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_export, Token.Id.Keyword_inline => {
stack.append(State {
.TopLevelDecl = TopLevelDeclCtx {
.decls = ctx.decls,
.visib_token = ctx.visib_token,
.extern_export_inline_token = token,
.lib_name = null,
},
}) catch unreachable;
continue;
},
Token.Id.Keyword_extern => {
stack.append(State {
.TopLevelLibname = TopLevelDeclCtx {
.decls = ctx.decls,
.visib_token = ctx.visib_token,
.extern_export_inline_token = token,
.lib_name = null,
},
}) catch unreachable;
continue;
},
else => {
self.putBackToken(token);
stack.append(State { .TopLevelDecl = ctx }) catch unreachable;
continue;
}
}
},
State.TopLevelLibname => |ctx| {
const lib_name = blk: {
const lib_name_token = self.getNextToken();
break :blk (try self.parseStringLiteral(arena, lib_name_token)) ?? {
self.putBackToken(lib_name_token);
break :blk null;
};
};
stack.append(State {
.TopLevelDecl = TopLevelDeclCtx {
.decls = ctx.decls,
.visib_token = ctx.visib_token,
.extern_export_inline_token = ctx.extern_export_inline_token,
.lib_name = lib_name,
},
}) catch unreachable;
continue;
},
State.TopLevelDecl => |ctx| {
const comments = try self.eatComments(arena);
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_use => {
if (ctx.extern_export_inline_token != null) {
return self.parseError(token, "Invalid token {}", @tagName((??ctx.extern_export_inline_token).id));
}
const node = try self.createAttachNode(arena, ctx.decls, ast.Node.Use,
ast.Node.Use {
.base = undefined,
.visib_token = ctx.visib_token,
.expr = undefined,
.semicolon_token = undefined,
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Semicolon,
.ptr = &node.semicolon_token,
}
}) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
continue;
},
Token.Id.Keyword_var, Token.Id.Keyword_const => {
if (ctx.extern_export_inline_token) |extern_export_inline_token| {
if (extern_export_inline_token.id == Token.Id.Keyword_inline) {
return self.parseError(token, "Invalid token {}", @tagName(extern_export_inline_token.id));
}
}
stack.append(State {
.VarDecl = VarDeclCtx {
.comments = comments,
.visib_token = ctx.visib_token,
.lib_name = ctx.lib_name,
.comptime_token = null,
.extern_export_token = ctx.extern_export_inline_token,
.mut_token = token,
.list = ctx.decls
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc,
Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {
const fn_proto = try self.createAttachNode(arena, ctx.decls, ast.Node.FnProto,
ast.Node.FnProto {
.base = undefined,
.comments = comments,
.visib_token = ctx.visib_token,
.name_token = null,
.fn_token = undefined,
.params = ArrayList(&ast.Node).init(arena),
.return_type = undefined,
.var_args_token = null,
.extern_export_inline_token = ctx.extern_export_inline_token,
.cc_token = null,
.async_attr = null,
.body_node = null,
.lib_name = ctx.lib_name,
.align_expr = null,
}
);
stack.append(State { .FnDef = fn_proto }) catch unreachable;
try stack.append(State { .FnProto = fn_proto });
switch (token.id) {
Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
fn_proto.cc_token = token;
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Keyword_fn,
.ptr = &fn_proto.fn_token,
}
});
continue;
},
Token.Id.Keyword_async => {
const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
ast.Node.AsyncAttribute {
.base = undefined,
.async_token = token,
.allocator_type = null,
.rangle_bracket = null,
}
);
fn_proto.async_attr = async_node;
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Keyword_fn,
.ptr = &fn_proto.fn_token,
}
});
try stack.append(State { .AsyncAllocator = async_node });
continue;
},
Token.Id.Keyword_fn => {
fn_proto.fn_token = token;
continue;
},
else => unreachable,
}
},
else => {
return self.parseError(token, "expected variable declaration or function, found {}", @tagName(token.id));
},
}
},
State.TopLevelExternOrField => |ctx| {
if (self.eatToken(Token.Id.Identifier)) |identifier| {
std.debug.assert(ctx.container_decl.kind == ast.Node.ContainerDecl.Kind.Struct);
const node = try self.createAttachNode(arena, &ctx.container_decl.fields_and_decls, ast.Node.StructField,
ast.Node.StructField {
.base = undefined,
.visib_token = ctx.visib_token,
.name_token = identifier,
.type_expr = undefined,
}
);
stack.append(State { .FieldListCommaOrEnd = ctx.container_decl }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.type_expr } });
try stack.append(State { .ExpectToken = Token.Id.Colon });
continue;
}
stack.append(State{ .ContainerDecl = ctx.container_decl }) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &ctx.container_decl.fields_and_decls,
.visib_token = ctx.visib_token,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
},
State.ContainerKind => |ctx| {
const token = self.getNextToken();
const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ContainerDecl,
ast.Node.ContainerDecl {
.base = undefined,
.ltoken = ctx.ltoken,
.layout = ctx.layout,
.kind = switch (token.id) {
Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
else => {
return self.parseError(token, "expected {}, {} or {}, found {}",
@tagName(Token.Id.Keyword_struct),
@tagName(Token.Id.Keyword_union),
@tagName(Token.Id.Keyword_enum),
@tagName(token.id));
},
},
.init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
.fields_and_decls = ArrayList(&ast.Node).init(arena),
.rbrace_token = undefined,
}
);
stack.append(State { .ContainerDecl = node }) catch unreachable;
try stack.append(State { .ExpectToken = Token.Id.LBrace });
try stack.append(State { .ContainerInitArgStart = node });
continue;
},
State.ContainerInitArgStart => |container_decl| {
if (self.eatToken(Token.Id.LParen) == null) {
continue;
}
stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
try stack.append(State { .ContainerInitArg = container_decl });
continue;
},
State.ContainerInitArg => |container_decl| {
const init_arg_token = self.getNextToken();
switch (init_arg_token.id) {
Token.Id.Keyword_enum => {
container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg.Enum;
},
else => {
self.putBackToken(init_arg_token);
container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg { .Type = undefined };
stack.append(State { .Expression = OptionalCtx { .Required = &container_decl.init_arg_expr.Type } }) catch unreachable;
},
}
continue;
},
State.ContainerDecl => |container_decl| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Identifier => {
switch (container_decl.kind) {
ast.Node.ContainerDecl.Kind.Struct => {
const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.StructField,
ast.Node.StructField {
.base = undefined,
.visib_token = null,
.name_token = token,
.type_expr = undefined,
}
);
stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.type_expr } });
try stack.append(State { .ExpectToken = Token.Id.Colon });
continue;
},
ast.Node.ContainerDecl.Kind.Union => {
const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.UnionTag,
ast.Node.UnionTag {
.base = undefined,
.name_token = token,
.type_expr = null,
}
);
stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &node.type_expr } });
try stack.append(State { .IfToken = Token.Id.Colon });
continue;
},
ast.Node.ContainerDecl.Kind.Enum => {
const node = try self.createAttachNode(arena, &container_decl.fields_and_decls, ast.Node.EnumTag,
ast.Node.EnumTag {
.base = undefined,
.name_token = token,
.value = null,
}
);
stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &node.value } });
try stack.append(State { .IfToken = Token.Id.Equal });
continue;
},
}
},
Token.Id.Keyword_pub => {
switch (container_decl.kind) {
ast.Node.ContainerDecl.Kind.Struct => {
try stack.append(State {
.TopLevelExternOrField = TopLevelExternOrFieldCtx {
.visib_token = token,
.container_decl = container_decl,
}
});
continue;
},
else => {
stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &container_decl.fields_and_decls,
.visib_token = token,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
}
}
},
Token.Id.Keyword_export => {
stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &container_decl.fields_and_decls,
.visib_token = token,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
},
Token.Id.RBrace => {
container_decl.rbrace_token = token;
continue;
},
else => {
self.putBackToken(token);
stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
try stack.append(State {
.TopLevelExtern = TopLevelDeclCtx {
.decls = &container_decl.fields_and_decls,
.visib_token = null,
.extern_export_inline_token = null,
.lib_name = null,
}
});
continue;
}
}
},
State.VarDecl => |ctx| {
const var_decl = try self.createAttachNode(arena, ctx.list, ast.Node.VarDecl,
ast.Node.VarDecl {
.base = undefined,
.comments = ctx.comments,
.visib_token = ctx.visib_token,
.mut_token = ctx.mut_token,
.comptime_token = ctx.comptime_token,
.extern_export_token = ctx.extern_export_token,
.type_node = null,
.align_node = null,
.init_node = null,
.lib_name = ctx.lib_name,
// initialized later
.name_token = undefined,
.eq_token = undefined,
.semicolon_token = undefined,
}
);
stack.append(State { .VarDeclAlign = var_decl }) catch unreachable;
try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &var_decl.type_node} });
try stack.append(State { .IfToken = Token.Id.Colon });
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Identifier,
.ptr = &var_decl.name_token,
}
});
continue;
},
State.VarDeclAlign => |var_decl| {
stack.append(State { .VarDeclEq = var_decl }) catch unreachable;
const next_token = self.getNextToken();
if (next_token.id == Token.Id.Keyword_align) {
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &var_decl.align_node} });
try stack.append(State { .ExpectToken = Token.Id.LParen });
continue;
}
self.putBackToken(next_token);
continue;
},
State.VarDeclEq => |var_decl| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Equal => {
var_decl.eq_token = token;
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Semicolon,
.ptr = &var_decl.semicolon_token,
},
}) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &var_decl.init_node } });
continue;
},
Token.Id.Semicolon => {
var_decl.semicolon_token = token;
continue;
},
else => {
return self.parseError(token, "expected '=' or ';', found {}", @tagName(token.id));
}
}
},
State.FnDef => |fn_proto| {
const token = self.getNextToken();
switch(token.id) {
Token.Id.LBrace => {
const block = try self.createNode(arena, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = null,
.lbrace = token,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
fn_proto.body_node = &block.base;
stack.append(State { .Block = block }) catch unreachable;
continue;
},
Token.Id.Semicolon => continue,
else => {
return self.parseError(token, "expected ';' or '{{', found {}", @tagName(token.id));
},
}
},
State.FnProto => |fn_proto| {
stack.append(State { .FnProtoAlign = fn_proto }) catch unreachable;
try stack.append(State { .ParamDecl = fn_proto });
try stack.append(State { .ExpectToken = Token.Id.LParen });
if (self.eatToken(Token.Id.Identifier)) |name_token| {
fn_proto.name_token = name_token;
}
continue;
},
State.FnProtoAlign => |fn_proto| {
stack.append(State { .FnProtoReturnType = fn_proto }) catch unreachable;
if (self.eatToken(Token.Id.Keyword_align)) |align_token| {
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &fn_proto.align_expr } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
}
continue;
},
State.FnProtoReturnType => |fn_proto| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Bang => {
fn_proto.return_type = ast.Node.FnProto.ReturnType { .InferErrorSet = undefined };
stack.append(State {
.TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.InferErrorSet },
}) catch unreachable;
continue;
},
else => {
// TODO: this is a special case. Remove this when #760 is fixed
if (token.id == Token.Id.Keyword_error) {
if (self.isPeekToken(Token.Id.LBrace)) {
fn_proto.return_type = ast.Node.FnProto.ReturnType {
.Explicit = &(try self.createLiteral(arena, ast.Node.ErrorType, token)).base
};
continue;
}
}
self.putBackToken(token);
fn_proto.return_type = ast.Node.FnProto.ReturnType { .Explicit = undefined };
stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.Explicit }, }) catch unreachable;
continue;
},
}
},
State.ParamDecl => |fn_proto| {
if (self.eatToken(Token.Id.RParen)) |_| {
continue;
}
const param_decl = try self.createAttachNode(arena, &fn_proto.params, ast.Node.ParamDecl,
ast.Node.ParamDecl {
.base = undefined,
.comptime_token = null,
.noalias_token = null,
.name_token = null,
.type_node = undefined,
.var_args_token = null,
},
);
stack.append(State {
.ParamDeclEnd = ParamDeclEndCtx {
.param_decl = param_decl,
.fn_proto = fn_proto,
}
}) catch unreachable;
try stack.append(State { .ParamDeclName = param_decl });
try stack.append(State { .ParamDeclAliasOrComptime = param_decl });
continue;
},
State.ParamDeclAliasOrComptime => |param_decl| {
if (self.eatToken(Token.Id.Keyword_comptime)) |comptime_token| {
param_decl.comptime_token = comptime_token;
} else if (self.eatToken(Token.Id.Keyword_noalias)) |noalias_token| {
param_decl.noalias_token = noalias_token;
}
continue;
},
State.ParamDeclName => |param_decl| {
// TODO: Here, we eat two tokens in one state. This means that we can't have
// comments between these two tokens.
if (self.eatToken(Token.Id.Identifier)) |ident_token| {
if (self.eatToken(Token.Id.Colon)) |_| {
param_decl.name_token = ident_token;
} else {
self.putBackToken(ident_token);
}
}
continue;
},
State.ParamDeclEnd => |ctx| {
if (self.eatToken(Token.Id.Ellipsis3)) |ellipsis3| {
ctx.param_decl.var_args_token = ellipsis3;
stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
continue;
}
try stack.append(State { .ParamDeclComma = ctx.fn_proto });
try stack.append(State {
.TypeExprBegin = OptionalCtx { .Required = &ctx.param_decl.type_node }
});
continue;
},
State.ParamDeclComma => |fn_proto| {
if ((try self.expectCommaOrEnd(Token.Id.RParen)) == null) {
stack.append(State { .ParamDecl = fn_proto }) catch unreachable;
}
continue;
},
State.MaybeLabeledExpression => |ctx| {
if (self.eatToken(Token.Id.Colon)) |_| {
stack.append(State {
.LabeledExpression = LabelCtx {
.label = ctx.label,
.opt_ctx = ctx.opt_ctx,
}
}) catch unreachable;
continue;
}
_ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.Identifier, ctx.label);
continue;
},
State.LabeledExpression => |ctx| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.LBrace => {
const block = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = ctx.label,
.lbrace = token,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
stack.append(State { .Block = block }) catch unreachable;
continue;
},
Token.Id.Keyword_while => {
stack.append(State {
.While = LoopCtx {
.label = ctx.label,
.inline_token = null,
.loop_token = token,
.opt_ctx = ctx.opt_ctx.toRequired(),
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_for => {
stack.append(State {
.For = LoopCtx {
.label = ctx.label,
.inline_token = null,
.loop_token = token,
.opt_ctx = ctx.opt_ctx.toRequired(),
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_inline => {
stack.append(State {
.Inline = InlineCtx {
.label = ctx.label,
.inline_token = token,
.opt_ctx = ctx.opt_ctx.toRequired(),
}
}) catch unreachable;
continue;
},
else => {
if (ctx.opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected 'while', 'for', 'inline' or '{{', found {}", @tagName(token.id));
}
self.putBackToken(token);
continue;
},
}
},
State.Inline => |ctx| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_while => {
stack.append(State {
.While = LoopCtx {
.inline_token = ctx.inline_token,
.label = ctx.label,
.loop_token = token,
.opt_ctx = ctx.opt_ctx.toRequired(),
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_for => {
stack.append(State {
.For = LoopCtx {
.inline_token = ctx.inline_token,
.label = ctx.label,
.loop_token = token,
.opt_ctx = ctx.opt_ctx.toRequired(),
}
}) catch unreachable;
continue;
},
else => {
if (ctx.opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected 'while' or 'for', found {}", @tagName(token.id));
}
self.putBackToken(token);
continue;
},
}
},
State.While => |ctx| {
const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.While,
ast.Node.While {
.base = undefined,
.label = ctx.label,
.inline_token = ctx.inline_token,
.while_token = ctx.loop_token,
.condition = undefined,
.payload = null,
.continue_expr = null,
.body = undefined,
.@"else" = null,
}
);
stack.append(State { .Else = &node.@"else" }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
try stack.append(State { .WhileContinueExpr = &node.continue_expr });
try stack.append(State { .IfToken = Token.Id.Colon });
try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.condition } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
continue;
},
State.WhileContinueExpr => |dest| {
stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .RequiredNull = dest } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
continue;
},
State.For => |ctx| {
const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.For,
ast.Node.For {
.base = undefined,
.label = ctx.label,
.inline_token = ctx.inline_token,
.for_token = ctx.loop_token,
.array_expr = undefined,
.payload = null,
.body = undefined,
.@"else" = null,
}
);
stack.append(State { .Else = &node.@"else" }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
try stack.append(State { .PointerIndexPayload = OptionalCtx { .Optional = &node.payload } });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.array_expr } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
continue;
},
State.Else => |dest| {
if (self.eatToken(Token.Id.Keyword_else)) |else_token| {
const node = try self.createNode(arena, ast.Node.Else,
ast.Node.Else {
.base = undefined,
.else_token = else_token,
.payload = null,
.body = undefined,
}
);
*dest = node;
stack.append(State { .Expression = OptionalCtx { .Required = &node.body } }) catch unreachable;
try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
continue;
} else {
continue;
}
},
State.Block => |block| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.RBrace => {
block.rbrace = token;
continue;
},
else => {
self.putBackToken(token);
stack.append(State { .Block = block }) catch unreachable;
try stack.append(State { .Statement = block });
continue;
},
}
},
State.Statement => |block| {
const comments = try self.eatComments(arena);
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_comptime => {
stack.append(State {
.ComptimeStatement = ComptimeStatementCtx {
.comptime_token = token,
.block = block,
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_var, Token.Id.Keyword_const => {
stack.append(State {
.VarDecl = VarDeclCtx {
.comments = comments,
.visib_token = null,
.comptime_token = null,
.extern_export_token = null,
.lib_name = null,
.mut_token = token,
.list = &block.statements,
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {
const node = try self.createAttachNode(arena, &block.statements, ast.Node.Defer,
ast.Node.Defer {
.base = undefined,
.defer_token = token,
.kind = switch (token.id) {
Token.Id.Keyword_defer => ast.Node.Defer.Kind.Unconditional,
Token.Id.Keyword_errdefer => ast.Node.Defer.Kind.Error,
else => unreachable,
},
.expr = undefined,
}
);
stack.append(State { .Semicolon = &&node.base }) catch unreachable;
try stack.append(State { .AssignmentExpressionBegin = OptionalCtx{ .Required = &node.expr } });
continue;
},
Token.Id.LBrace => {
const inner_block = try self.createAttachNode(arena, &block.statements, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = null,
.lbrace = token,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
stack.append(State { .Block = inner_block }) catch unreachable;
continue;
},
else => {
self.putBackToken(token);
const statememt = try block.statements.addOne();
stack.append(State { .Semicolon = statememt }) catch unreachable;
try stack.append(State { .AssignmentExpressionBegin = OptionalCtx{ .Required = statememt } });
continue;
}
}
},
State.ComptimeStatement => |ctx| {
const comments = try self.eatComments(arena);
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_var, Token.Id.Keyword_const => {
stack.append(State {
.VarDecl = VarDeclCtx {
.comments = comments,
.visib_token = null,
.comptime_token = ctx.comptime_token,
.extern_export_token = null,
.lib_name = null,
.mut_token = token,
.list = &ctx.block.statements,
}
}) catch unreachable;
continue;
},
else => {
self.putBackToken(token);
self.putBackToken(ctx.comptime_token);
const statememt = try ctx.block.statements.addOne();
stack.append(State { .Semicolon = statememt }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = statememt } });
continue;
}
}
},
State.Semicolon => |node_ptr| {
const node = *node_ptr;
if (requireSemiColon(node)) {
stack.append(State { .ExpectToken = Token.Id.Semicolon }) catch unreachable;
continue;
}
continue;
},
State.AsmOutputItems => |items| {
const lbracket = self.getNextToken();
if (lbracket.id != Token.Id.LBracket) {
self.putBackToken(lbracket);
continue;
}
const node = try self.createNode(arena, ast.Node.AsmOutput,
ast.Node.AsmOutput {
.base = undefined,
.symbolic_name = undefined,
.constraint = undefined,
.kind = undefined,
}
);
try items.append(node);
stack.append(State { .AsmOutputItems = items }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.Comma });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .AsmOutputReturnOrType = node });
try stack.append(State { .ExpectToken = Token.Id.LParen });
try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.constraint } });
try stack.append(State { .ExpectToken = Token.Id.RBracket });
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.symbolic_name } });
continue;
},
State.AsmOutputReturnOrType => |node| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Identifier => {
node.kind = ast.Node.AsmOutput.Kind { .Variable = try self.createLiteral(arena, ast.Node.Identifier, token) };
continue;
},
Token.Id.Arrow => {
node.kind = ast.Node.AsmOutput.Kind { .Return = undefined };
try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.kind.Return } });
continue;
},
else => {
return self.parseError(token, "expected '->' or {}, found {}",
@tagName(Token.Id.Identifier),
@tagName(token.id));
},
}
},
State.AsmInputItems => |items| {
const lbracket = self.getNextToken();
if (lbracket.id != Token.Id.LBracket) {
self.putBackToken(lbracket);
continue;
}
const node = try self.createNode(arena, ast.Node.AsmInput,
ast.Node.AsmInput {
.base = undefined,
.symbolic_name = undefined,
.constraint = undefined,
.expr = undefined,
}
);
try items.append(node);
stack.append(State { .AsmInputItems = items }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.Comma });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.constraint } });
try stack.append(State { .ExpectToken = Token.Id.RBracket });
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.symbolic_name } });
continue;
},
State.AsmClopperItems => |items| {
stack.append(State { .AsmClopperItems = items }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.Comma });
try stack.append(State { .StringLiteral = OptionalCtx { .Required = try items.addOne() } });
continue;
},
State.ExprListItemOrEnd => |list_state| {
if (self.eatToken(list_state.end)) |token| {
*list_state.ptr = token;
continue;
}
stack.append(State { .ExprListCommaOrEnd = list_state }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = try list_state.list.addOne() } });
continue;
},
State.ExprListCommaOrEnd => |list_state| {
if (try self.expectCommaOrEnd(list_state.end)) |end| {
*list_state.ptr = end;
continue;
} else {
stack.append(State { .ExprListItemOrEnd = list_state }) catch unreachable;
continue;
}
},
State.FieldInitListItemOrEnd => |list_state| {
if (self.eatToken(Token.Id.RBrace)) |rbrace| {
*list_state.ptr = rbrace;
continue;
}
const node = try self.createNode(arena, ast.Node.FieldInitializer,
ast.Node.FieldInitializer {
.base = undefined,
.period_token = undefined,
.name_token = undefined,
.expr = undefined,
}
);
try list_state.list.append(node);
stack.append(State { .FieldInitListCommaOrEnd = list_state }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx{ .Required = &node.expr } });
try stack.append(State { .ExpectToken = Token.Id.Equal });
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Identifier,
.ptr = &node.name_token,
}
});
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Period,
.ptr = &node.period_token,
}
});
continue;
},
State.FieldInitListCommaOrEnd => |list_state| {
if (try self.expectCommaOrEnd(Token.Id.RBrace)) |end| {
*list_state.ptr = end;
continue;
} else {
stack.append(State { .FieldInitListItemOrEnd = list_state }) catch unreachable;
continue;
}
},
State.FieldListCommaOrEnd => |container_decl| {
if (try self.expectCommaOrEnd(Token.Id.RBrace)) |end| {
container_decl.rbrace_token = end;
continue;
} else {
stack.append(State { .ContainerDecl = container_decl }) catch unreachable;
continue;
}
},
State.IdentifierListItemOrEnd => |list_state| {
if (self.eatToken(Token.Id.RBrace)) |rbrace| {
*list_state.ptr = rbrace;
continue;
}
stack.append(State { .IdentifierListCommaOrEnd = list_state }) catch unreachable;
try stack.append(State { .Identifier = OptionalCtx { .Required = try list_state.list.addOne() } });
continue;
},
State.IdentifierListCommaOrEnd => |list_state| {
if (try self.expectCommaOrEnd(Token.Id.RBrace)) |end| {
*list_state.ptr = end;
continue;
} else {
stack.append(State { .IdentifierListItemOrEnd = list_state }) catch unreachable;
continue;
}
},
State.SwitchCaseOrEnd => |list_state| {
if (self.eatToken(Token.Id.RBrace)) |rbrace| {
*list_state.ptr = rbrace;
continue;
}
const node = try self.createNode(arena, ast.Node.SwitchCase,
ast.Node.SwitchCase {
.base = undefined,
.items = ArrayList(&ast.Node).init(arena),
.payload = null,
.expr = undefined,
}
);
try list_state.list.append(node);
stack.append(State { .SwitchCaseCommaOrEnd = list_state }) catch unreachable;
try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .Required = &node.expr } });
try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
try stack.append(State { .SwitchCaseFirstItem = &node.items });
continue;
},
State.SwitchCaseCommaOrEnd => |list_state| {
if (try self.expectCommaOrEnd(Token.Id.RBrace)) |end| {
*list_state.ptr = end;
continue;
} else {
stack.append(State { .SwitchCaseOrEnd = list_state }) catch unreachable;
continue;
}
},
State.SwitchCaseFirstItem => |case_items| {
const token = self.getNextToken();
if (token.id == Token.Id.Keyword_else) {
const else_node = try self.createAttachNode(arena, case_items, ast.Node.SwitchElse,
ast.Node.SwitchElse {
.base = undefined,
.token = token,
}
);
try stack.append(State { .ExpectToken = Token.Id.EqualAngleBracketRight });
continue;
} else {
self.putBackToken(token);
try stack.append(State { .SwitchCaseItem = case_items });
continue;
}
},
State.SwitchCaseItem => |case_items| {
stack.append(State { .SwitchCaseItemCommaOrEnd = case_items }) catch unreachable;
try stack.append(State { .RangeExpressionBegin = OptionalCtx { .Required = try case_items.addOne() } });
},
State.SwitchCaseItemCommaOrEnd => |case_items| {
if ((try self.expectCommaOrEnd(Token.Id.EqualAngleBracketRight)) == null) {
stack.append(State { .SwitchCaseItem = case_items }) catch unreachable;
}
continue;
},
State.SuspendBody => |suspend_node| {
if (suspend_node.payload != null) {
try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .RequiredNull = &suspend_node.body } });
}
continue;
},
State.AsyncAllocator => |async_node| {
if (self.eatToken(Token.Id.AngleBracketLeft) == null) {
continue;
}
async_node.rangle_bracket = Token(undefined);
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.AngleBracketRight,
.ptr = &??async_node.rangle_bracket,
}
});
try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &async_node.allocator_type } });
continue;
},
State.AsyncEnd => |ctx| {
const node = ctx.ctx.get() ?? continue;
switch (node.id) {
ast.Node.Id.FnProto => {
const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", node);
fn_proto.async_attr = ctx.attribute;
continue;
},
ast.Node.Id.SuffixOp => {
const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", node);
if (suffix_op.op == ast.Node.SuffixOp.Op.Call) {
suffix_op.op.Call.async_attr = ctx.attribute;
continue;
}
return self.parseError(node.firstToken(), "expected {}, found {}.",
@tagName(ast.Node.SuffixOp.Op.Call),
@tagName(suffix_op.op));
},
else => {
return self.parseError(node.firstToken(), "expected {} or {}, found {}.",
@tagName(ast.Node.SuffixOp.Op.Call),
@tagName(ast.Node.Id.FnProto),
@tagName(node.id));
}
}
},
State.ExternType => |ctx| {
if (self.eatToken(Token.Id.Keyword_fn)) |fn_token| {
const fn_proto = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.FnProto,
ast.Node.FnProto {
.base = undefined,
.comments = ctx.comments,
.visib_token = null,
.name_token = null,
.fn_token = fn_token,
.params = ArrayList(&ast.Node).init(arena),
.return_type = undefined,
.var_args_token = null,
.extern_export_inline_token = ctx.extern_token,
.cc_token = null,
.async_attr = null,
.body_node = null,
.lib_name = null,
.align_expr = null,
}
);
stack.append(State { .FnProto = fn_proto }) catch unreachable;
continue;
}
stack.append(State {
.ContainerKind = ContainerKindCtx {
.opt_ctx = ctx.opt_ctx,
.ltoken = ctx.extern_token,
.layout = ast.Node.ContainerDecl.Layout.Extern,
},
}) catch unreachable;
continue;
},
State.SliceOrArrayAccess => |node| {
var token = self.getNextToken();
switch (token.id) {
Token.Id.Ellipsis2 => {
const start = node.op.ArrayAccess;
node.op = ast.Node.SuffixOp.Op {
.Slice = ast.Node.SuffixOp.SliceRange {
.start = start,
.end = null,
}
};
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.RBracket,
.ptr = &node.rtoken,
}
}) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Optional = &node.op.Slice.end } });
continue;
},
Token.Id.RBracket => {
node.rtoken = token;
continue;
},
else => {
return self.parseError(token, "expected ']' or '..', found {}", @tagName(token.id));
}
}
},
State.SliceOrArrayType => |node| {
if (self.eatToken(Token.Id.RBracket)) |_| {
node.op = ast.Node.PrefixOp.Op {
.SliceType = ast.Node.PrefixOp.AddrOfInfo {
.align_expr = null,
.bit_offset_start_token = null,
.bit_offset_end_token = null,
.const_token = null,
.volatile_token = null,
}
};
stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
try stack.append(State { .AddrOfModifiers = &node.op.SliceType });
continue;
}
node.op = ast.Node.PrefixOp.Op { .ArrayType = undefined };
stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
try stack.append(State { .ExpectToken = Token.Id.RBracket });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayType } });
continue;
},
State.AddrOfModifiers => |addr_of_info| {
var token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_align => {
stack.append(state) catch unreachable;
if (addr_of_info.align_expr != null) {
return self.parseError(token, "multiple align qualifiers");
}
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &addr_of_info.align_expr} });
try stack.append(State { .ExpectToken = Token.Id.LParen });
continue;
},
Token.Id.Keyword_const => {
stack.append(state) catch unreachable;
if (addr_of_info.const_token != null) {
return self.parseError(token, "duplicate qualifier: const");
}
addr_of_info.const_token = token;
continue;
},
Token.Id.Keyword_volatile => {
stack.append(state) catch unreachable;
if (addr_of_info.volatile_token != null) {
return self.parseError(token, "duplicate qualifier: volatile");
}
addr_of_info.volatile_token = token;
continue;
},
else => {
self.putBackToken(token);
continue;
},
}
},
State.Payload => |opt_ctx| {
const token = self.getNextToken();
if (token.id != Token.Id.Pipe) {
if (opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected {}, found {}.",
@tagName(Token.Id.Pipe),
@tagName(token.id));
}
self.putBackToken(token);
continue;
}
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Payload,
ast.Node.Payload {
.base = undefined,
.lpipe = token,
.error_symbol = undefined,
.rpipe = undefined
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Pipe,
.ptr = &node.rpipe,
}
}) catch unreachable;
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.error_symbol } });
continue;
},
State.PointerPayload => |opt_ctx| {
const token = self.getNextToken();
if (token.id != Token.Id.Pipe) {
if (opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected {}, found {}.",
@tagName(Token.Id.Pipe),
@tagName(token.id));
}
self.putBackToken(token);
continue;
}
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerPayload,
ast.Node.PointerPayload {
.base = undefined,
.lpipe = token,
.ptr_token = null,
.value_symbol = undefined,
.rpipe = undefined
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Pipe,
.ptr = &node.rpipe,
}
}) catch unreachable;
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.value_symbol } });
try stack.append(State {
.OptionalTokenSave = OptionalTokenSave {
.id = Token.Id.Asterisk,
.ptr = &node.ptr_token,
}
});
continue;
},
State.PointerIndexPayload => |opt_ctx| {
const token = self.getNextToken();
if (token.id != Token.Id.Pipe) {
if (opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected {}, found {}.",
@tagName(Token.Id.Pipe),
@tagName(token.id));
}
self.putBackToken(token);
continue;
}
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PointerIndexPayload,
ast.Node.PointerIndexPayload {
.base = undefined,
.lpipe = token,
.ptr_token = null,
.value_symbol = undefined,
.index_symbol = null,
.rpipe = undefined
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Pipe,
.ptr = &node.rpipe,
}
}) catch unreachable;
try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.index_symbol } });
try stack.append(State { .IfToken = Token.Id.Comma });
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.value_symbol } });
try stack.append(State {
.OptionalTokenSave = OptionalTokenSave {
.id = Token.Id.Asterisk,
.ptr = &node.ptr_token,
}
});
continue;
},
State.Expression => |opt_ctx| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.ControlFlowExpression,
ast.Node.ControlFlowExpression {
.base = undefined,
.ltoken = token,
.kind = undefined,
.rhs = null,
}
);
stack.append(State { .Expression = OptionalCtx { .Optional = &node.rhs } }) catch unreachable;
switch (token.id) {
Token.Id.Keyword_break => {
node.kind = ast.Node.ControlFlowExpression.Kind { .Break = null };
try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Break } });
try stack.append(State { .IfToken = Token.Id.Colon });
},
Token.Id.Keyword_continue => {
node.kind = ast.Node.ControlFlowExpression.Kind { .Continue = null };
try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Continue } });
try stack.append(State { .IfToken = Token.Id.Colon });
},
Token.Id.Keyword_return => {
node.kind = ast.Node.ControlFlowExpression.Kind.Return;
},
else => unreachable,
}
continue;
},
Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
ast.Node.PrefixOp {
.base = undefined,
.op_token = token,
.op = switch (token.id) {
Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
else => unreachable,
},
.rhs = undefined,
}
);
stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
continue;
},
else => {
if (!try self.parseBlockExpr(&stack, arena, opt_ctx, token)) {
self.putBackToken(token);
stack.append(State { .UnwrapExpressionBegin = opt_ctx }) catch unreachable;
}
continue;
}
}
},
State.RangeExpressionBegin => |opt_ctx| {
stack.append(State { .RangeExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .Expression = opt_ctx });
continue;
},
State.RangeExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Ellipsis3)) |ellipsis3| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = ellipsis3,
.op = ast.Node.InfixOp.Op.Range,
.rhs = undefined,
}
);
stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
continue;
}
},
State.AssignmentExpressionBegin => |opt_ctx| {
stack.append(State { .AssignmentExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .Expression = opt_ctx });
continue;
},
State.AssignmentExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToAssignment(token.id)) |ass_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = ass_id,
.rhs = undefined,
}
);
stack.append(State { .AssignmentExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.UnwrapExpressionBegin => |opt_ctx| {
stack.append(State { .UnwrapExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BoolOrExpressionBegin = opt_ctx });
continue;
},
State.UnwrapExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToUnwrapExpr(token.id)) |unwrap_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = unwrap_id,
.rhs = undefined,
}
);
stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
if (node.op == ast.Node.InfixOp.Op.Catch) {
try stack.append(State { .Payload = OptionalCtx { .Optional = &node.op.Catch } });
}
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.BoolOrExpressionBegin => |opt_ctx| {
stack.append(State { .BoolOrExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BoolAndExpressionBegin = opt_ctx });
continue;
},
State.BoolOrExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Keyword_or)) |or_token| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = or_token,
.op = ast.Node.InfixOp.Op.BoolOr,
.rhs = undefined,
}
);
stack.append(State { .BoolOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .BoolAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.BoolAndExpressionBegin => |opt_ctx| {
stack.append(State { .BoolAndExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .ComparisonExpressionBegin = opt_ctx });
continue;
},
State.BoolAndExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Keyword_and)) |and_token| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = and_token,
.op = ast.Node.InfixOp.Op.BoolAnd,
.rhs = undefined,
}
);
stack.append(State { .BoolAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .ComparisonExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.ComparisonExpressionBegin => |opt_ctx| {
stack.append(State { .ComparisonExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BinaryOrExpressionBegin = opt_ctx });
continue;
},
State.ComparisonExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToComparison(token.id)) |comp_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = comp_id,
.rhs = undefined,
}
);
stack.append(State { .ComparisonExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .BinaryOrExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.BinaryOrExpressionBegin => |opt_ctx| {
stack.append(State { .BinaryOrExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BinaryXorExpressionBegin = opt_ctx });
continue;
},
State.BinaryOrExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Pipe)) |pipe| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = pipe,
.op = ast.Node.InfixOp.Op.BitOr,
.rhs = undefined,
}
);
stack.append(State { .BinaryOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .BinaryXorExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.BinaryXorExpressionBegin => |opt_ctx| {
stack.append(State { .BinaryXorExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BinaryAndExpressionBegin = opt_ctx });
continue;
},
State.BinaryXorExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Caret)) |caret| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = caret,
.op = ast.Node.InfixOp.Op.BitXor,
.rhs = undefined,
}
);
stack.append(State { .BinaryXorExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .BinaryAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.BinaryAndExpressionBegin => |opt_ctx| {
stack.append(State { .BinaryAndExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .BitShiftExpressionBegin = opt_ctx });
continue;
},
State.BinaryAndExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Ampersand)) |ampersand| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = ampersand,
.op = ast.Node.InfixOp.Op.BitAnd,
.rhs = undefined,
}
);
stack.append(State { .BinaryAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .BitShiftExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.BitShiftExpressionBegin => |opt_ctx| {
stack.append(State { .BitShiftExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .AdditionExpressionBegin = opt_ctx });
continue;
},
State.BitShiftExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToBitShift(token.id)) |bitshift_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = bitshift_id,
.rhs = undefined,
}
);
stack.append(State { .BitShiftExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .AdditionExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.AdditionExpressionBegin => |opt_ctx| {
stack.append(State { .AdditionExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .MultiplyExpressionBegin = opt_ctx });
continue;
},
State.AdditionExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToAddition(token.id)) |add_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = add_id,
.rhs = undefined,
}
);
stack.append(State { .AdditionExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .MultiplyExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.MultiplyExpressionBegin => |opt_ctx| {
stack.append(State { .MultiplyExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .CurlySuffixExpressionBegin = opt_ctx });
continue;
},
State.MultiplyExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
if (tokenIdToMultiply(token.id)) |mult_id| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = mult_id,
.rhs = undefined,
}
);
stack.append(State { .MultiplyExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .CurlySuffixExpressionBegin = OptionalCtx { .Required = &node.rhs } });
continue;
} else {
self.putBackToken(token);
continue;
}
},
State.CurlySuffixExpressionBegin => |opt_ctx| {
stack.append(State { .CurlySuffixExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.LBrace });
try stack.append(State { .TypeExprBegin = opt_ctx });
continue;
},
State.CurlySuffixExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.isPeekToken(Token.Id.Period)) {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
ast.Node.SuffixOp {
.base = undefined,
.lhs = lhs,
.op = ast.Node.SuffixOp.Op {
.StructInitializer = ArrayList(&ast.Node.FieldInitializer).init(arena),
},
.rtoken = undefined,
}
);
stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.LBrace });
try stack.append(State {
.FieldInitListItemOrEnd = ListSave(&ast.Node.FieldInitializer) {
.list = &node.op.StructInitializer,
.ptr = &node.rtoken,
}
});
continue;
}
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
ast.Node.SuffixOp {
.base = undefined,
.lhs = lhs,
.op = ast.Node.SuffixOp.Op {
.ArrayInitializer = ArrayList(&ast.Node).init(arena),
},
.rtoken = undefined,
}
);
stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .IfToken = Token.Id.LBrace });
try stack.append(State {
.ExprListItemOrEnd = ExprListCtx {
.list = &node.op.ArrayInitializer,
.end = Token.Id.RBrace,
.ptr = &node.rtoken,
}
});
continue;
},
State.TypeExprBegin => |opt_ctx| {
stack.append(State { .TypeExprEnd = opt_ctx }) catch unreachable;
try stack.append(State { .PrefixOpExpression = opt_ctx });
continue;
},
State.TypeExprEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
if (self.eatToken(Token.Id.Bang)) |bang| {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = bang,
.op = ast.Node.InfixOp.Op.ErrorUnion,
.rhs = undefined,
}
);
stack.append(State { .TypeExprEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .PrefixOpExpression = OptionalCtx { .Required = &node.rhs } });
continue;
}
},
State.PrefixOpExpression => |opt_ctx| {
const token = self.getNextToken();
if (tokenIdToPrefixOp(token.id)) |prefix_id| {
var node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
ast.Node.PrefixOp {
.base = undefined,
.op_token = token,
.op = prefix_id,
.rhs = undefined,
}
);
// Treat '**' token as two derefs
if (token.id == Token.Id.AsteriskAsterisk) {
const child = try self.createNode(arena, ast.Node.PrefixOp,
ast.Node.PrefixOp {
.base = undefined,
.op_token = token,
.op = prefix_id,
.rhs = undefined,
}
);
node.rhs = &child.base;
node = child;
}
stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
if (node.op == ast.Node.PrefixOp.Op.AddrOf) {
try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
}
continue;
} else {
self.putBackToken(token);
stack.append(State { .SuffixOpExpressionBegin = opt_ctx }) catch unreachable;
continue;
}
},
State.SuffixOpExpressionBegin => |opt_ctx| {
if (self.eatToken(Token.Id.Keyword_async)) |async_token| {
const async_node = try self.createNode(arena, ast.Node.AsyncAttribute,
ast.Node.AsyncAttribute {
.base = undefined,
.async_token = async_token,
.allocator_type = null,
.rangle_bracket = null,
}
);
stack.append(State {
.AsyncEnd = AsyncEndCtx {
.ctx = opt_ctx,
.attribute = async_node,
}
}) catch unreachable;
try stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() });
try stack.append(State { .PrimaryExpression = opt_ctx.toRequired() });
try stack.append(State { .AsyncAllocator = async_node });
continue;
}
stack.append(State { .SuffixOpExpressionEnd = opt_ctx }) catch unreachable;
try stack.append(State { .PrimaryExpression = opt_ctx });
continue;
},
State.SuffixOpExpressionEnd => |opt_ctx| {
const lhs = opt_ctx.get() ?? continue;
const token = self.getNextToken();
switch (token.id) {
Token.Id.LParen => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
ast.Node.SuffixOp {
.base = undefined,
.lhs = lhs,
.op = ast.Node.SuffixOp.Op {
.Call = ast.Node.SuffixOp.CallInfo {
.params = ArrayList(&ast.Node).init(arena),
.async_attr = null,
}
},
.rtoken = undefined,
}
);
stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State {
.ExprListItemOrEnd = ExprListCtx {
.list = &node.op.Call.params,
.end = Token.Id.RParen,
.ptr = &node.rtoken,
}
});
continue;
},
Token.Id.LBracket => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
ast.Node.SuffixOp {
.base = undefined,
.lhs = lhs,
.op = ast.Node.SuffixOp.Op {
.ArrayAccess = undefined,
},
.rtoken = undefined
}
);
stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .SliceOrArrayAccess = node });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayAccess }});
continue;
},
Token.Id.Period => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
ast.Node.InfixOp {
.base = undefined,
.lhs = lhs,
.op_token = token,
.op = ast.Node.InfixOp.Op.Period,
.rhs = undefined,
}
);
stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
try stack.append(State { .Identifier = OptionalCtx { .Required = &node.rhs } });
continue;
},
else => {
self.putBackToken(token);
continue;
},
}
},
State.PrimaryExpression => |opt_ctx| {
const token = self.getNextToken();
switch (token.id) {
Token.Id.IntegerLiteral => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.StringLiteral, token);
continue;
},
Token.Id.FloatLiteral => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.FloatLiteral, token);
continue;
},
Token.Id.CharLiteral => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.CharLiteral, token);
continue;
},
Token.Id.Keyword_undefined => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.UndefinedLiteral, token);
continue;
},
Token.Id.Keyword_true, Token.Id.Keyword_false => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.BoolLiteral, token);
continue;
},
Token.Id.Keyword_null => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.NullLiteral, token);
continue;
},
Token.Id.Keyword_this => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.ThisLiteral, token);
continue;
},
Token.Id.Keyword_var => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.VarType, token);
continue;
},
Token.Id.Keyword_unreachable => {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.Unreachable, token);
continue;
},
Token.Id.StringLiteral, Token.Id.MultilineStringLiteralLine => {
opt_ctx.store((try self.parseStringLiteral(arena, token)) ?? unreachable);
continue;
},
Token.Id.LParen => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.GroupedExpression,
ast.Node.GroupedExpression {
.base = undefined,
.lparen = token,
.expr = undefined,
.rparen = undefined,
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.RParen,
.ptr = &node.rparen,
}
}) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
continue;
},
Token.Id.Builtin => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.BuiltinCall,
ast.Node.BuiltinCall {
.base = undefined,
.builtin_token = token,
.params = ArrayList(&ast.Node).init(arena),
.rparen_token = undefined,
}
);
stack.append(State {
.ExprListItemOrEnd = ExprListCtx {
.list = &node.params,
.end = Token.Id.RParen,
.ptr = &node.rparen_token,
}
}) catch unreachable;
try stack.append(State { .ExpectToken = Token.Id.LParen, });
continue;
},
Token.Id.LBracket => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
ast.Node.PrefixOp {
.base = undefined,
.op_token = token,
.op = undefined,
.rhs = undefined,
}
);
stack.append(State { .SliceOrArrayType = node }) catch unreachable;
continue;
},
Token.Id.Keyword_error => {
stack.append(State {
.ErrorTypeOrSetDecl = ErrorTypeOrSetDeclCtx {
.error_token = token,
.opt_ctx = opt_ctx
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_packed => {
stack.append(State {
.ContainerKind = ContainerKindCtx {
.opt_ctx = opt_ctx,
.ltoken = token,
.layout = ast.Node.ContainerDecl.Layout.Packed,
},
}) catch unreachable;
continue;
},
Token.Id.Keyword_extern => {
stack.append(State {
.ExternType = ExternTypeCtx {
.opt_ctx = opt_ctx,
.extern_token = token,
.comments = null,
},
}) catch unreachable;
continue;
},
Token.Id.Keyword_struct, Token.Id.Keyword_union, Token.Id.Keyword_enum => {
self.putBackToken(token);
stack.append(State {
.ContainerKind = ContainerKindCtx {
.opt_ctx = opt_ctx,
.ltoken = token,
.layout = ast.Node.ContainerDecl.Layout.Auto,
},
}) catch unreachable;
continue;
},
Token.Id.Identifier => {
stack.append(State {
.MaybeLabeledExpression = MaybeLabeledExpressionCtx {
.label = token,
.opt_ctx = opt_ctx
}
}) catch unreachable;
continue;
},
Token.Id.Keyword_fn => {
const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
ast.Node.FnProto {
.base = undefined,
.comments = null,
.visib_token = null,
.name_token = null,
.fn_token = token,
.params = ArrayList(&ast.Node).init(arena),
.return_type = undefined,
.var_args_token = null,
.extern_export_inline_token = null,
.cc_token = null,
.async_attr = null,
.body_node = null,
.lib_name = null,
.align_expr = null,
}
);
stack.append(State { .FnProto = fn_proto }) catch unreachable;
continue;
},
Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
const fn_proto = try self.createToCtxNode(arena, opt_ctx, ast.Node.FnProto,
ast.Node.FnProto {
.base = undefined,
.comments = null,
.visib_token = null,
.name_token = null,
.fn_token = undefined,
.params = ArrayList(&ast.Node).init(arena),
.return_type = undefined,
.var_args_token = null,
.extern_export_inline_token = null,
.cc_token = token,
.async_attr = null,
.body_node = null,
.lib_name = null,
.align_expr = null,
}
);
stack.append(State { .FnProto = fn_proto }) catch unreachable;
try stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.Keyword_fn,
.ptr = &fn_proto.fn_token
}
});
continue;
},
Token.Id.Keyword_asm => {
const node = try self.createToCtxNode(arena, opt_ctx, ast.Node.Asm,
ast.Node.Asm {
.base = undefined,
.asm_token = token,
.volatile_token = null,
.template = undefined,
//.tokens = ArrayList(ast.Node.Asm.AsmToken).init(arena),
.outputs = ArrayList(&ast.Node.AsmOutput).init(arena),
.inputs = ArrayList(&ast.Node.AsmInput).init(arena),
.cloppers = ArrayList(&ast.Node).init(arena),
.rparen = undefined,
}
);
stack.append(State {
.ExpectTokenSave = ExpectTokenSave {
.id = Token.Id.RParen,
.ptr = &node.rparen,
}
}) catch unreachable;
try stack.append(State { .AsmClopperItems = &node.cloppers });
try stack.append(State { .IfToken = Token.Id.Colon });
try stack.append(State { .AsmInputItems = &node.inputs });
try stack.append(State { .IfToken = Token.Id.Colon });
try stack.append(State { .AsmOutputItems = &node.outputs });
try stack.append(State { .IfToken = Token.Id.Colon });
try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.template } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
try stack.append(State {
.OptionalTokenSave = OptionalTokenSave {
.id = Token.Id.Keyword_volatile,
.ptr = &node.volatile_token,
}
});
},
Token.Id.Keyword_inline => {
stack.append(State {
.Inline = InlineCtx {
.label = null,
.inline_token = token,
.opt_ctx = opt_ctx,
}
}) catch unreachable;
continue;
},
else => {
if (!try self.parseBlockExpr(&stack, arena, opt_ctx, token)) {
self.putBackToken(token);
if (opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected primary expression, found {}", @tagName(token.id));
}
}
continue;
}
}
},
State.ErrorTypeOrSetDecl => |ctx| {
if (self.eatToken(Token.Id.LBrace) == null) {
_ = try self.createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.ErrorType, ctx.error_token);
continue;
}
const node = try self.createToCtxNode(arena, ctx.opt_ctx, ast.Node.ErrorSetDecl,
ast.Node.ErrorSetDecl {
.base = undefined,
.error_token = ctx.error_token,
.decls = ArrayList(&ast.Node).init(arena),
.rbrace_token = undefined,
}
);
stack.append(State {
.IdentifierListItemOrEnd = ListSave(&ast.Node) {
.list = &node.decls,
.ptr = &node.rbrace_token,
}
}) catch unreachable;
continue;
},
State.StringLiteral => |opt_ctx| {
const token = self.getNextToken();
opt_ctx.store(
(try self.parseStringLiteral(arena, token)) ?? {
self.putBackToken(token);
if (opt_ctx != OptionalCtx.Optional) {
return self.parseError(token, "expected primary expression, found {}", @tagName(token.id));
}
continue;
}
);
},
State.Identifier => |opt_ctx| {
if (self.eatToken(Token.Id.Identifier)) |ident_token| {
_ = try self.createToCtxLiteral(arena, opt_ctx, ast.Node.Identifier, ident_token);
continue;
}
if (opt_ctx != OptionalCtx.Optional) {
const token = self.getNextToken();
return self.parseError(token, "expected identifier, found {}", @tagName(token.id));
}
},
State.ExpectToken => |token_id| {
_ = try self.expectToken(token_id);
continue;
},
State.ExpectTokenSave => |expect_token_save| {
*expect_token_save.ptr = try self.expectToken(expect_token_save.id);
continue;
},
State.IfToken => |token_id| {
if (self.eatToken(token_id)) |_| {
continue;
}
_ = stack.pop();
continue;
},
State.IfTokenSave => |if_token_save| {
if (self.eatToken(if_token_save.id)) |token| {
*if_token_save.ptr = token;
continue;
}
_ = stack.pop();
continue;
},
State.OptionalTokenSave => |optional_token_save| {
if (self.eatToken(optional_token_save.id)) |token| {
*optional_token_save.ptr = token;
continue;
}
continue;
},
}
}
}
fn eatComments(self: &Parser, arena: &mem.Allocator) !?&ast.Node.LineComment {
var result: ?&ast.Node.LineComment = null;
while (true) {
if (self.eatToken(Token.Id.LineComment)) |line_comment| {
const node = blk: {
if (result) |comment_node| {
break :blk comment_node;
} else {
const comment_node = try arena.create(ast.Node.LineComment);
*comment_node = ast.Node.LineComment {
.base = ast.Node {
.id = ast.Node.Id.LineComment,
},
.lines = ArrayList(Token).init(arena),
};
result = comment_node;
break :blk comment_node;
}
};
try node.lines.append(line_comment);
continue;
}
break;
}
return result;
}
fn requireSemiColon(node: &const ast.Node) bool {
var n = node;
while (true) {
switch (n.id) {
ast.Node.Id.Root,
ast.Node.Id.StructField,
ast.Node.Id.UnionTag,
ast.Node.Id.EnumTag,
ast.Node.Id.ParamDecl,
ast.Node.Id.Block,
ast.Node.Id.Payload,
ast.Node.Id.PointerPayload,
ast.Node.Id.PointerIndexPayload,
ast.Node.Id.Switch,
ast.Node.Id.SwitchCase,
ast.Node.Id.SwitchElse,
ast.Node.Id.FieldInitializer,
ast.Node.Id.LineComment,
ast.Node.Id.TestDecl => return false,
ast.Node.Id.While => {
const while_node = @fieldParentPtr(ast.Node.While, "base", n);
if (while_node.@"else") |@"else"| {
n = @"else".base;
continue;
}
return while_node.body.id != ast.Node.Id.Block;
},
ast.Node.Id.For => {
const for_node = @fieldParentPtr(ast.Node.For, "base", n);
if (for_node.@"else") |@"else"| {
n = @"else".base;
continue;
}
return for_node.body.id != ast.Node.Id.Block;
},
ast.Node.Id.If => {
const if_node = @fieldParentPtr(ast.Node.If, "base", n);
if (if_node.@"else") |@"else"| {
n = @"else".base;
continue;
}
return if_node.body.id != ast.Node.Id.Block;
},
ast.Node.Id.Else => {
const else_node = @fieldParentPtr(ast.Node.Else, "base", n);
n = else_node.body;
continue;
},
ast.Node.Id.Defer => {
const defer_node = @fieldParentPtr(ast.Node.Defer, "base", n);
return defer_node.expr.id != ast.Node.Id.Block;
},
ast.Node.Id.Comptime => {
const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", n);
return comptime_node.expr.id != ast.Node.Id.Block;
},
ast.Node.Id.Suspend => {
const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", n);
if (suspend_node.body) |body| {
return body.id != ast.Node.Id.Block;
}
return true;
},
else => return true,
}
}
}
fn parseStringLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !?&ast.Node {
switch (token.id) {
Token.Id.StringLiteral => {
return &(try self.createLiteral(arena, ast.Node.StringLiteral, token)).base;
},
Token.Id.MultilineStringLiteralLine => {
const node = try self.createNode(arena, ast.Node.MultilineStringLiteral,
ast.Node.MultilineStringLiteral {
.base = undefined,
.tokens = ArrayList(Token).init(arena),
}
);
try node.tokens.append(token);
while (true) {
const multiline_str = self.getNextToken();
if (multiline_str.id != Token.Id.MultilineStringLiteralLine) {
self.putBackToken(multiline_str);
break;
}
try node.tokens.append(multiline_str);
}
return &node.base;
},
// TODO: We shouldn't need a cast, but:
// zig: /home/jc/Documents/zig/src/ir.cpp:7962: TypeTableEntry* ir_resolve_peer_types(IrAnalyze*, AstNode*, IrInstruction**, size_t): Assertion `err_set_type != nullptr' failed.
else => return (?&ast.Node)(null),
}
}
fn parseBlockExpr(self: &Parser, stack: &ArrayList(State), arena: &mem.Allocator, ctx: &const OptionalCtx, token: &const Token) !bool {
switch (token.id) {
Token.Id.Keyword_suspend => {
const node = try self.createToCtxNode(arena, ctx, ast.Node.Suspend,
ast.Node.Suspend {
.base = undefined,
.suspend_token = *token,
.payload = null,
.body = null,
}
);
stack.append(State { .SuspendBody = node }) catch unreachable;
try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
return true;
},
Token.Id.Keyword_if => {
const node = try self.createToCtxNode(arena, ctx, ast.Node.If,
ast.Node.If {
.base = undefined,
.if_token = *token,
.condition = undefined,
.payload = null,
.body = undefined,
.@"else" = null,
}
);
stack.append(State { .Else = &node.@"else" }) catch unreachable;
try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.condition } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
return true;
},
Token.Id.Keyword_while => {
stack.append(State {
.While = LoopCtx {
.label = null,
.inline_token = null,
.loop_token = *token,
.opt_ctx = *ctx,
}
}) catch unreachable;
return true;
},
Token.Id.Keyword_for => {
stack.append(State {
.For = LoopCtx {
.label = null,
.inline_token = null,
.loop_token = *token,
.opt_ctx = *ctx,
}
}) catch unreachable;
return true;
},
Token.Id.Keyword_switch => {
const node = try self.createToCtxNode(arena, ctx, ast.Node.Switch,
ast.Node.Switch {
.base = undefined,
.switch_token = *token,
.expr = undefined,
.cases = ArrayList(&ast.Node.SwitchCase).init(arena),
.rbrace = undefined,
}
);
stack.append(State {
.SwitchCaseOrEnd = ListSave(&ast.Node.SwitchCase) {
.list = &node.cases,
.ptr = &node.rbrace,
},
}) catch unreachable;
try stack.append(State { .ExpectToken = Token.Id.LBrace });
try stack.append(State { .ExpectToken = Token.Id.RParen });
try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
try stack.append(State { .ExpectToken = Token.Id.LParen });
return true;
},
Token.Id.Keyword_comptime => {
const node = try self.createToCtxNode(arena, ctx, ast.Node.Comptime,
ast.Node.Comptime {
.base = undefined,
.comptime_token = *token,
.expr = undefined,
}
);
try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
return true;
},
Token.Id.LBrace => {
const block = try self.createToCtxNode(arena, ctx, ast.Node.Block,
ast.Node.Block {
.base = undefined,
.label = null,
.lbrace = *token,
.statements = ArrayList(&ast.Node).init(arena),
.rbrace = undefined,
}
);
stack.append(State { .Block = block }) catch unreachable;
return true;
},
else => {
return false;
}
}
}
fn expectCommaOrEnd(self: &Parser, end: @TagType(Token.Id)) !?Token {
var token = self.getNextToken();
switch (token.id) {
Token.Id.Comma => return null,
else => {
if (end == token.id) {
return token;
}
return self.parseError(token, "expected ',' or {}, found {}", @tagName(end), @tagName(token.id));
},
}
}
fn tokenIdToAssignment(id: &const Token.Id) ?ast.Node.InfixOp.Op {
// TODO: We have to cast all cases because of this:
// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
return switch (*id) {
Token.Id.AmpersandEqual => ast.Node.InfixOp.Op { .AssignBitAnd = void{} },
Token.Id.AngleBracketAngleBracketLeftEqual => ast.Node.InfixOp.Op { .AssignBitShiftLeft = void{} },
Token.Id.AngleBracketAngleBracketRightEqual => ast.Node.InfixOp.Op { .AssignBitShiftRight = void{} },
Token.Id.AsteriskEqual => ast.Node.InfixOp.Op { .AssignTimes = void{} },
Token.Id.AsteriskPercentEqual => ast.Node.InfixOp.Op { .AssignTimesWarp = void{} },
Token.Id.CaretEqual => ast.Node.InfixOp.Op { .AssignBitXor = void{} },
Token.Id.Equal => ast.Node.InfixOp.Op { .Assign = void{} },
Token.Id.MinusEqual => ast.Node.InfixOp.Op { .AssignMinus = void{} },
Token.Id.MinusPercentEqual => ast.Node.InfixOp.Op { .AssignMinusWrap = void{} },
Token.Id.PercentEqual => ast.Node.InfixOp.Op { .AssignMod = void{} },
Token.Id.PipeEqual => ast.Node.InfixOp.Op { .AssignBitOr = void{} },
Token.Id.PlusEqual => ast.Node.InfixOp.Op { .AssignPlus = void{} },
Token.Id.PlusPercentEqual => ast.Node.InfixOp.Op { .AssignPlusWrap = void{} },
Token.Id.SlashEqual => ast.Node.InfixOp.Op { .AssignDiv = void{} },
else => null,
};
}
fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
return switch (id) {
Token.Id.Keyword_catch => ast.Node.InfixOp.Op { .Catch = null },
Token.Id.QuestionMarkQuestionMark => ast.Node.InfixOp.Op { .UnwrapMaybe = void{} },
else => null,
};
}
fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
return switch (id) {
Token.Id.BangEqual => ast.Node.InfixOp.Op { .BangEqual = void{} },
Token.Id.EqualEqual => ast.Node.InfixOp.Op { .EqualEqual = void{} },
Token.Id.AngleBracketLeft => ast.Node.InfixOp.Op { .LessThan = void{} },
Token.Id.AngleBracketLeftEqual => ast.Node.InfixOp.Op { .LessOrEqual = void{} },
Token.Id.AngleBracketRight => ast.Node.InfixOp.Op { .GreaterThan = void{} },
Token.Id.AngleBracketRightEqual => ast.Node.InfixOp.Op { .GreaterOrEqual = void{} },
else => null,
};
}
fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
return switch (id) {
Token.Id.AngleBracketAngleBracketLeft => ast.Node.InfixOp.Op { .BitShiftLeft = void{} },
Token.Id.AngleBracketAngleBracketRight => ast.Node.InfixOp.Op { .BitShiftRight = void{} },
else => null,
};
}
fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
return switch (id) {
Token.Id.Minus => ast.Node.InfixOp.Op { .Sub = void{} },
Token.Id.MinusPercent => ast.Node.InfixOp.Op { .SubWrap = void{} },
Token.Id.Plus => ast.Node.InfixOp.Op { .Add = void{} },
Token.Id.PlusPercent => ast.Node.InfixOp.Op { .AddWrap = void{} },
Token.Id.PlusPlus => ast.Node.InfixOp.Op { .ArrayCat = void{} },
else => null,
};
}
fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
return switch (id) {
Token.Id.Slash => ast.Node.InfixOp.Op { .Div = void{} },
Token.Id.Asterisk => ast.Node.InfixOp.Op { .Mult = void{} },
Token.Id.AsteriskAsterisk => ast.Node.InfixOp.Op { .ArrayMult = void{} },
Token.Id.AsteriskPercent => ast.Node.InfixOp.Op { .MultWrap = void{} },
Token.Id.Percent => ast.Node.InfixOp.Op { .Mod = void{} },
Token.Id.PipePipe => ast.Node.InfixOp.Op { .MergeErrorSets = void{} },
else => null,
};
}
fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
return switch (id) {
Token.Id.Bang => ast.Node.PrefixOp.Op { .BoolNot = void{} },
Token.Id.Tilde => ast.Node.PrefixOp.Op { .BitNot = void{} },
Token.Id.Minus => ast.Node.PrefixOp.Op { .Negation = void{} },
Token.Id.MinusPercent => ast.Node.PrefixOp.Op { .NegationWrap = void{} },
Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.Node.PrefixOp.Op { .Deref = void{} },
Token.Id.Ampersand => ast.Node.PrefixOp.Op {
.AddrOf = ast.Node.PrefixOp.AddrOfInfo {
.align_expr = null,
.bit_offset_start_token = null,
.bit_offset_end_token = null,
.const_token = null,
.volatile_token = null,
},
},
Token.Id.QuestionMark => ast.Node.PrefixOp.Op { .MaybeType = void{} },
Token.Id.QuestionMarkQuestionMark => ast.Node.PrefixOp.Op { .UnwrapMaybe = void{} },
Token.Id.Keyword_await => ast.Node.PrefixOp.Op { .Await = void{} },
Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{ } },
else => null,
};
}
fn createNode(self: &Parser, arena: &mem.Allocator, comptime T: type, init_to: &const T) !&T {
const node = try arena.create(T);
*node = *init_to;
node.base = blk: {
const id = ast.Node.typeToId(T);
break :blk ast.Node {.id = id};
};
return node;
}
fn createAttachNode(self: &Parser, arena: &mem.Allocator, list: &ArrayList(&ast.Node), comptime T: type, init_to: &const T) !&T {
const node = try self.createNode(arena, T, init_to);
try list.append(&node.base);
return node;
}
fn createToCtxNode(self: &Parser, arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, init_to: &const T) !&T {
const node = try self.createNode(arena, T, init_to);
opt_ctx.store(&node.base);
return node;
}
fn createLiteral(self: &Parser, arena: &mem.Allocator, comptime T: type, token: &const Token) !&T {
return self.createNode(arena, T,
T {
.base = undefined,
.token = *token,
}
);
}
fn createToCtxLiteral(self: &Parser, arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, token: &const Token) !&T {
const node = try self.createLiteral(arena, T, token);
opt_ctx.store(&node.base);
return node;
}
fn parseError(self: &Parser, token: &const Token, comptime fmt: []const u8, args: ...) (error{ParseError}) {
const loc = self.tokenizer.getTokenLocation(0, token);
warn("{}:{}:{}: error: " ++ fmt ++ "\n", self.source_file_name, loc.line + 1, loc.column + 1, args);
warn("{}\n", self.tokenizer.buffer[loc.line_start..loc.line_end]);
{
var i: usize = 0;
while (i < loc.column) : (i += 1) {
warn(" ");
}
}
{
const caret_count = token.end - token.start;
var i: usize = 0;
while (i < caret_count) : (i += 1) {
warn("~");
}
}
warn("\n");
return error.ParseError;
}
fn expectToken(self: &Parser, id: @TagType(Token.Id)) !Token {
const token = self.getNextToken();
if (token.id != id) {
return self.parseError(token, "expected {}, found {}", @tagName(id), @tagName(token.id));
}
return token;
}
fn eatToken(self: &Parser, id: @TagType(Token.Id)) ?Token {
if (self.isPeekToken(id)) {
return self.getNextToken();
}
return null;
}
fn putBackToken(self: &Parser, token: &const Token) void {
self.put_back_tokens[self.put_back_count] = *token;
self.put_back_count += 1;
}
fn getNextToken(self: &Parser) Token {
if (self.put_back_count != 0) {
const put_back_index = self.put_back_count - 1;
const put_back_token = self.put_back_tokens[put_back_index];
self.put_back_count = put_back_index;
return put_back_token;
} else {
return self.tokenizer.next();
}
}
fn isPeekToken(self: &Parser, id: @TagType(Token.Id)) bool {
const token = self.getNextToken();
defer self.putBackToken(token);
return id == token.id;
}
const RenderAstFrame = struct {
node: &ast.Node,
indent: usize,
};
pub fn renderAst(self: &Parser, stream: var, root_node: &ast.Node.Root) !void {
var stack = self.initUtilityArrayList(RenderAstFrame);
defer self.deinitUtilityArrayList(stack);
try stack.append(RenderAstFrame {
.node = &root_node.base,
.indent = 0,
});
while (stack.popOrNull()) |frame| {
{
var i: usize = 0;
while (i < frame.indent) : (i += 1) {
try stream.print(" ");
}
}
try stream.print("{}\n", @tagName(frame.node.id));
var child_i: usize = 0;
while (frame.node.iterate(child_i)) |child| : (child_i += 1) {
try stack.append(RenderAstFrame {
.node = child,
.indent = frame.indent + 2,
});
}
}
}
const RenderState = union(enum) {
TopLevelDecl: &ast.Node,
ParamDecl: &ast.Node,
Text: []const u8,
Expression: &ast.Node,
VarDecl: &ast.Node.VarDecl,
Statement: &ast.Node,
FieldInitializer: &ast.Node.FieldInitializer,
PrintIndent,
Indent: usize,
};
pub fn renderSource(self: &Parser, stream: var, root_node: &ast.Node.Root) !void {
var stack = self.initUtilityArrayList(RenderState);
defer self.deinitUtilityArrayList(stack);
{
try stack.append(RenderState { .Text = "\n"});
var i = root_node.decls.len;
while (i != 0) {
i -= 1;
const decl = root_node.decls.items[i];
try stack.append(RenderState {.TopLevelDecl = decl});
if (i != 0) {
try stack.append(RenderState {
.Text = blk: {
const prev_node = root_node.decls.at(i - 1);
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, decl.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
break :blk "\n";
},
});
}
}
}
const indent_delta = 4;
var indent: usize = 0;
while (stack.popOrNull()) |state| {
switch (state) {
RenderState.TopLevelDecl => |decl| {
switch (decl.id) {
ast.Node.Id.FnProto => {
const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
try self.renderComments(stream, fn_proto, indent);
if (fn_proto.body_node) |body_node| {
stack.append(RenderState { .Expression = body_node}) catch unreachable;
try stack.append(RenderState { .Text = " "});
} else {
stack.append(RenderState { .Text = ";" }) catch unreachable;
}
try stack.append(RenderState { .Expression = decl });
},
ast.Node.Id.Use => {
const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
if (use_decl.visib_token) |visib_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
}
try stream.print("use ");
try stack.append(RenderState { .Text = ";" });
try stack.append(RenderState { .Expression = use_decl.expr });
},
ast.Node.Id.VarDecl => {
const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
try stack.append(RenderState { .VarDecl = var_decl});
},
ast.Node.Id.TestDecl => {
const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
try self.renderComments(stream, test_decl, indent);
try stream.print("test ");
try stack.append(RenderState { .Expression = test_decl.body_node });
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = test_decl.name });
},
ast.Node.Id.StructField => {
const field = @fieldParentPtr(ast.Node.StructField, "base", decl);
if (field.visib_token) |visib_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
}
try stream.print("{}: ", self.tokenizer.getTokenSlice(field.name_token));
try stack.append(RenderState { .Expression = field.type_expr});
},
ast.Node.Id.UnionTag => {
const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
if (tag.type_expr) |type_expr| {
try stream.print(": ");
try stack.append(RenderState { .Expression = type_expr});
}
},
ast.Node.Id.EnumTag => {
const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
try stream.print("{}", self.tokenizer.getTokenSlice(tag.name_token));
if (tag.value) |value| {
try stream.print(" = ");
try stack.append(RenderState { .Expression = value});
}
},
ast.Node.Id.Comptime => {
if (requireSemiColon(decl)) {
try stack.append(RenderState { .Text = ";" });
}
try stack.append(RenderState { .Expression = decl });
},
else => unreachable,
}
},
RenderState.FieldInitializer => |field_init| {
//TODO try self.renderComments(stream, field_init, indent);
try stream.print(".{}", self.tokenizer.getTokenSlice(field_init.name_token));
try stream.print(" = ");
try stack.append(RenderState { .Expression = field_init.expr });
},
RenderState.VarDecl => |var_decl| {
try stack.append(RenderState { .Text = ";" });
if (var_decl.init_node) |init_node| {
try stack.append(RenderState { .Expression = init_node });
try stack.append(RenderState { .Text = " = " });
}
if (var_decl.align_node) |align_node| {
try stack.append(RenderState { .Text = ")" });
try stack.append(RenderState { .Expression = align_node });
try stack.append(RenderState { .Text = " align(" });
}
if (var_decl.type_node) |type_node| {
try stack.append(RenderState { .Expression = type_node });
try stack.append(RenderState { .Text = ": " });
}
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(var_decl.name_token) });
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(var_decl.mut_token) });
if (var_decl.comptime_token) |comptime_token| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(comptime_token) });
}
if (var_decl.extern_export_token) |extern_export_token| {
if (var_decl.lib_name != null) {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = ??var_decl.lib_name });
}
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(extern_export_token) });
}
if (var_decl.visib_token) |visib_token| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(visib_token) });
}
},
RenderState.ParamDecl => |base| {
const param_decl = @fieldParentPtr(ast.Node.ParamDecl, "base", base);
// TODO try self.renderComments(stream, param_decl, indent);
if (param_decl.comptime_token) |comptime_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));
}
if (param_decl.noalias_token) |noalias_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(noalias_token));
}
if (param_decl.name_token) |name_token| {
try stream.print("{}: ", self.tokenizer.getTokenSlice(name_token));
}
if (param_decl.var_args_token) |var_args_token| {
try stream.print("{}", self.tokenizer.getTokenSlice(var_args_token));
} else {
try stack.append(RenderState { .Expression = param_decl.type_node});
}
},
RenderState.Text => |bytes| {
try stream.write(bytes);
},
RenderState.Expression => |base| switch (base.id) {
ast.Node.Id.Identifier => {
const identifier = @fieldParentPtr(ast.Node.Identifier, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(identifier.token));
},
ast.Node.Id.Block => {
const block = @fieldParentPtr(ast.Node.Block, "base", base);
if (block.label) |label| {
try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
}
if (block.statements.len == 0) {
try stream.write("{}");
} else {
try stream.write("{");
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent});
try stack.append(RenderState { .Text = "\n"});
var i = block.statements.len;
while (i != 0) {
i -= 1;
const statement_node = block.statements.items[i];
try stack.append(RenderState { .Statement = statement_node});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState {
.Text = blk: {
if (i != 0) {
const prev_node = block.statements.items[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, statement_node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
}
break :blk "\n";
},
});
}
}
},
ast.Node.Id.Defer => {
const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
try stream.print("{} ", self.tokenizer.getTokenSlice(defer_node.defer_token));
try stack.append(RenderState { .Expression = defer_node.expr });
},
ast.Node.Id.Comptime => {
const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_node.comptime_token));
try stack.append(RenderState { .Expression = comptime_node.expr });
},
ast.Node.Id.AsyncAttribute => {
const async_attr = @fieldParentPtr(ast.Node.AsyncAttribute, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(async_attr.async_token));
if (async_attr.allocator_type) |allocator_type| {
try stack.append(RenderState { .Text = ">" });
try stack.append(RenderState { .Expression = allocator_type });
try stack.append(RenderState { .Text = "<" });
}
},
ast.Node.Id.Suspend => {
const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(suspend_node.suspend_token));
if (suspend_node.body) |body| {
try stack.append(RenderState { .Expression = body });
try stack.append(RenderState { .Text = " " });
}
if (suspend_node.payload) |payload| {
try stack.append(RenderState { .Expression = payload });
try stack.append(RenderState { .Text = " " });
}
},
ast.Node.Id.InfixOp => {
const prefix_op_node = @fieldParentPtr(ast.Node.InfixOp, "base", base);
try stack.append(RenderState { .Expression = prefix_op_node.rhs });
if (prefix_op_node.op == ast.Node.InfixOp.Op.Catch) {
if (prefix_op_node.op.Catch) |payload| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = payload });
}
try stack.append(RenderState { .Text = " catch " });
} else {
const text = switch (prefix_op_node.op) {
ast.Node.InfixOp.Op.Add => " + ",
ast.Node.InfixOp.Op.AddWrap => " +% ",
ast.Node.InfixOp.Op.ArrayCat => " ++ ",
ast.Node.InfixOp.Op.ArrayMult => " ** ",
ast.Node.InfixOp.Op.Assign => " = ",
ast.Node.InfixOp.Op.AssignBitAnd => " &= ",
ast.Node.InfixOp.Op.AssignBitOr => " |= ",
ast.Node.InfixOp.Op.AssignBitShiftLeft => " <<= ",
ast.Node.InfixOp.Op.AssignBitShiftRight => " >>= ",
ast.Node.InfixOp.Op.AssignBitXor => " ^= ",
ast.Node.InfixOp.Op.AssignDiv => " /= ",
ast.Node.InfixOp.Op.AssignMinus => " -= ",
ast.Node.InfixOp.Op.AssignMinusWrap => " -%= ",
ast.Node.InfixOp.Op.AssignMod => " %= ",
ast.Node.InfixOp.Op.AssignPlus => " += ",
ast.Node.InfixOp.Op.AssignPlusWrap => " +%= ",
ast.Node.InfixOp.Op.AssignTimes => " *= ",
ast.Node.InfixOp.Op.AssignTimesWarp => " *%= ",
ast.Node.InfixOp.Op.BangEqual => " != ",
ast.Node.InfixOp.Op.BitAnd => " & ",
ast.Node.InfixOp.Op.BitOr => " | ",
ast.Node.InfixOp.Op.BitShiftLeft => " << ",
ast.Node.InfixOp.Op.BitShiftRight => " >> ",
ast.Node.InfixOp.Op.BitXor => " ^ ",
ast.Node.InfixOp.Op.BoolAnd => " and ",
ast.Node.InfixOp.Op.BoolOr => " or ",
ast.Node.InfixOp.Op.Div => " / ",
ast.Node.InfixOp.Op.EqualEqual => " == ",
ast.Node.InfixOp.Op.ErrorUnion => "!",
ast.Node.InfixOp.Op.GreaterOrEqual => " >= ",
ast.Node.InfixOp.Op.GreaterThan => " > ",
ast.Node.InfixOp.Op.LessOrEqual => " <= ",
ast.Node.InfixOp.Op.LessThan => " < ",
ast.Node.InfixOp.Op.MergeErrorSets => " || ",
ast.Node.InfixOp.Op.Mod => " % ",
ast.Node.InfixOp.Op.Mult => " * ",
ast.Node.InfixOp.Op.MultWrap => " *% ",
ast.Node.InfixOp.Op.Period => ".",
ast.Node.InfixOp.Op.Sub => " - ",
ast.Node.InfixOp.Op.SubWrap => " -% ",
ast.Node.InfixOp.Op.UnwrapMaybe => " ?? ",
ast.Node.InfixOp.Op.Range => " ... ",
ast.Node.InfixOp.Op.Catch => unreachable,
};
try stack.append(RenderState { .Text = text });
}
try stack.append(RenderState { .Expression = prefix_op_node.lhs });
},
ast.Node.Id.PrefixOp => {
const prefix_op_node = @fieldParentPtr(ast.Node.PrefixOp, "base", base);
try stack.append(RenderState { .Expression = prefix_op_node.rhs });
switch (prefix_op_node.op) {
ast.Node.PrefixOp.Op.AddrOf => |addr_of_info| {
try stream.write("&");
if (addr_of_info.volatile_token != null) {
try stack.append(RenderState { .Text = "volatile "});
}
if (addr_of_info.const_token != null) {
try stack.append(RenderState { .Text = "const "});
}
if (addr_of_info.align_expr) |align_expr| {
try stream.print("align(");
try stack.append(RenderState { .Text = ") "});
try stack.append(RenderState { .Expression = align_expr});
}
},
ast.Node.PrefixOp.Op.SliceType => |addr_of_info| {
try stream.write("[]");
if (addr_of_info.volatile_token != null) {
try stack.append(RenderState { .Text = "volatile "});
}
if (addr_of_info.const_token != null) {
try stack.append(RenderState { .Text = "const "});
}
if (addr_of_info.align_expr) |align_expr| {
try stream.print("align(");
try stack.append(RenderState { .Text = ") "});
try stack.append(RenderState { .Expression = align_expr});
}
},
ast.Node.PrefixOp.Op.ArrayType => |array_index| {
try stack.append(RenderState { .Text = "]"});
try stack.append(RenderState { .Expression = array_index});
try stack.append(RenderState { .Text = "["});
},
ast.Node.PrefixOp.Op.BitNot => try stream.write("~"),
ast.Node.PrefixOp.Op.BoolNot => try stream.write("!"),
ast.Node.PrefixOp.Op.Deref => try stream.write("*"),
ast.Node.PrefixOp.Op.Negation => try stream.write("-"),
ast.Node.PrefixOp.Op.NegationWrap => try stream.write("-%"),
ast.Node.PrefixOp.Op.Try => try stream.write("try "),
ast.Node.PrefixOp.Op.UnwrapMaybe => try stream.write("??"),
ast.Node.PrefixOp.Op.MaybeType => try stream.write("?"),
ast.Node.PrefixOp.Op.Await => try stream.write("await "),
ast.Node.PrefixOp.Op.Cancel => try stream.write("cancel "),
ast.Node.PrefixOp.Op.Resume => try stream.write("resume "),
}
},
ast.Node.Id.SuffixOp => {
const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", base);
switch (suffix_op.op) {
ast.Node.SuffixOp.Op.Call => |call_info| {
try stack.append(RenderState { .Text = ")"});
var i = call_info.params.len;
while (i != 0) {
i -= 1;
const param_node = call_info.params.at(i);
try stack.append(RenderState { .Expression = param_node});
if (i != 0) {
try stack.append(RenderState { .Text = ", " });
}
}
try stack.append(RenderState { .Text = "("});
try stack.append(RenderState { .Expression = suffix_op.lhs });
if (call_info.async_attr) |async_attr| {
try stack.append(RenderState { .Text = " "});
try stack.append(RenderState { .Expression = &async_attr.base });
}
},
ast.Node.SuffixOp.Op.ArrayAccess => |index_expr| {
try stack.append(RenderState { .Text = "]"});
try stack.append(RenderState { .Expression = index_expr});
try stack.append(RenderState { .Text = "["});
try stack.append(RenderState { .Expression = suffix_op.lhs });
},
ast.Node.SuffixOp.Op.Slice => |range| {
try stack.append(RenderState { .Text = "]"});
if (range.end) |end| {
try stack.append(RenderState { .Expression = end});
}
try stack.append(RenderState { .Text = ".."});
try stack.append(RenderState { .Expression = range.start});
try stack.append(RenderState { .Text = "["});
try stack.append(RenderState { .Expression = suffix_op.lhs });
},
ast.Node.SuffixOp.Op.StructInitializer => |field_inits| {
if (field_inits.len == 0) {
try stack.append(RenderState { .Text = "{}" });
try stack.append(RenderState { .Expression = suffix_op.lhs });
continue;
}
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent });
var i = field_inits.len;
while (i != 0) {
i -= 1;
const field_init = field_inits.at(i);
try stack.append(RenderState { .Text = ",\n" });
try stack.append(RenderState { .FieldInitializer = field_init });
try stack.append(RenderState.PrintIndent);
}
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = " {\n"});
try stack.append(RenderState { .Expression = suffix_op.lhs });
},
ast.Node.SuffixOp.Op.ArrayInitializer => |exprs| {
if (exprs.len == 0) {
try stack.append(RenderState { .Text = "{}" });
try stack.append(RenderState { .Expression = suffix_op.lhs });
continue;
}
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent });
var i = exprs.len;
while (i != 0) {
i -= 1;
const expr = exprs.at(i);
try stack.append(RenderState { .Text = ",\n" });
try stack.append(RenderState { .Expression = expr });
try stack.append(RenderState.PrintIndent);
}
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = " {\n"});
try stack.append(RenderState { .Expression = suffix_op.lhs });
},
}
},
ast.Node.Id.ControlFlowExpression => {
const flow_expr = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", base);
if (flow_expr.rhs) |rhs| {
try stack.append(RenderState { .Expression = rhs });
try stack.append(RenderState { .Text = " " });
}
switch (flow_expr.kind) {
ast.Node.ControlFlowExpression.Kind.Break => |maybe_label| {
try stream.print("break");
if (maybe_label) |label| {
try stream.print(" :");
try stack.append(RenderState { .Expression = label });
}
},
ast.Node.ControlFlowExpression.Kind.Continue => |maybe_label| {
try stream.print("continue");
if (maybe_label) |label| {
try stream.print(" :");
try stack.append(RenderState { .Expression = label });
}
},
ast.Node.ControlFlowExpression.Kind.Return => {
try stream.print("return");
},
}
},
ast.Node.Id.Payload => {
const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
try stack.append(RenderState { .Text = "|"});
try stack.append(RenderState { .Expression = payload.error_symbol });
try stack.append(RenderState { .Text = "|"});
},
ast.Node.Id.PointerPayload => {
const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
try stack.append(RenderState { .Text = "|"});
try stack.append(RenderState { .Expression = payload.value_symbol });
if (payload.ptr_token) |ptr_token| {
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(ptr_token) });
}
try stack.append(RenderState { .Text = "|"});
},
ast.Node.Id.PointerIndexPayload => {
const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
try stack.append(RenderState { .Text = "|"});
if (payload.index_symbol) |index_symbol| {
try stack.append(RenderState { .Expression = index_symbol });
try stack.append(RenderState { .Text = ", "});
}
try stack.append(RenderState { .Expression = payload.value_symbol });
if (payload.ptr_token) |ptr_token| {
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(ptr_token) });
}
try stack.append(RenderState { .Text = "|"});
},
ast.Node.Id.GroupedExpression => {
const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
try stack.append(RenderState { .Text = ")"});
try stack.append(RenderState { .Expression = grouped_expr.expr });
try stack.append(RenderState { .Text = "("});
},
ast.Node.Id.FieldInitializer => {
const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
try stream.print(".{} = ", self.tokenizer.getTokenSlice(field_init.name_token));
try stack.append(RenderState { .Expression = field_init.expr });
},
ast.Node.Id.IntegerLiteral => {
const integer_literal = @fieldParentPtr(ast.Node.IntegerLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(integer_literal.token));
},
ast.Node.Id.FloatLiteral => {
const float_literal = @fieldParentPtr(ast.Node.FloatLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(float_literal.token));
},
ast.Node.Id.StringLiteral => {
const string_literal = @fieldParentPtr(ast.Node.StringLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(string_literal.token));
},
ast.Node.Id.CharLiteral => {
const char_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(char_literal.token));
},
ast.Node.Id.BoolLiteral => {
const bool_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(bool_literal.token));
},
ast.Node.Id.NullLiteral => {
const null_literal = @fieldParentPtr(ast.Node.NullLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(null_literal.token));
},
ast.Node.Id.ThisLiteral => {
const this_literal = @fieldParentPtr(ast.Node.ThisLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(this_literal.token));
},
ast.Node.Id.Unreachable => {
const unreachable_node = @fieldParentPtr(ast.Node.Unreachable, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(unreachable_node.token));
},
ast.Node.Id.ErrorType => {
const error_type = @fieldParentPtr(ast.Node.ErrorType, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(error_type.token));
},
ast.Node.Id.VarType => {
const var_type = @fieldParentPtr(ast.Node.VarType, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(var_type.token));
},
ast.Node.Id.ContainerDecl => {
const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
switch (container_decl.layout) {
ast.Node.ContainerDecl.Layout.Packed => try stream.print("packed "),
ast.Node.ContainerDecl.Layout.Extern => try stream.print("extern "),
ast.Node.ContainerDecl.Layout.Auto => { },
}
switch (container_decl.kind) {
ast.Node.ContainerDecl.Kind.Struct => try stream.print("struct"),
ast.Node.ContainerDecl.Kind.Enum => try stream.print("enum"),
ast.Node.ContainerDecl.Kind.Union => try stream.print("union"),
}
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Text = "\n"});
const fields_and_decls = container_decl.fields_and_decls.toSliceConst();
var i = fields_and_decls.len;
while (i != 0) {
i -= 1;
const node = fields_and_decls[i];
switch (node.id) {
ast.Node.Id.StructField,
ast.Node.Id.UnionTag,
ast.Node.Id.EnumTag => {
try stack.append(RenderState { .Text = "," });
},
else => { }
}
try stack.append(RenderState { .TopLevelDecl = node});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState {
.Text = blk: {
if (i != 0) {
const prev_node = fields_and_decls[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
}
break :blk "\n";
},
});
}
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState { .Text = "{"});
switch (container_decl.init_arg_expr) {
ast.Node.ContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),
ast.Node.ContainerDecl.InitArg.Enum => try stack.append(RenderState { .Text = "(enum) "}),
ast.Node.ContainerDecl.InitArg.Type => |type_expr| {
try stack.append(RenderState { .Text = ") "});
try stack.append(RenderState { .Expression = type_expr});
try stack.append(RenderState { .Text = "("});
},
}
},
ast.Node.Id.ErrorSetDecl => {
const err_set_decl = @fieldParentPtr(ast.Node.ErrorSetDecl, "base", base);
try stream.print("error ");
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Text = "\n"});
const decls = err_set_decl.decls.toSliceConst();
var i = decls.len;
while (i != 0) {
i -= 1;
const node = decls[i];
try stack.append(RenderState { .Text = "," });
try stack.append(RenderState { .Expression = node });
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState {
.Text = blk: {
if (i != 0) {
const prev_node = decls[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
}
break :blk "\n";
},
});
}
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState { .Text = "{"});
},
ast.Node.Id.MultilineStringLiteral => {
const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
try stream.print("\n");
var i : usize = 0;
while (i < multiline_str_literal.tokens.len) : (i += 1) {
const t = multiline_str_literal.tokens.at(i);
try stream.writeByteNTimes(' ', indent + indent_delta);
try stream.print("{}", self.tokenizer.getTokenSlice(t));
}
try stream.writeByteNTimes(' ', indent + indent_delta);
},
ast.Node.Id.UndefinedLiteral => {
const undefined_literal = @fieldParentPtr(ast.Node.UndefinedLiteral, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(undefined_literal.token));
},
ast.Node.Id.BuiltinCall => {
const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
try stream.print("{}(", self.tokenizer.getTokenSlice(builtin_call.builtin_token));
try stack.append(RenderState { .Text = ")"});
var i = builtin_call.params.len;
while (i != 0) {
i -= 1;
const param_node = builtin_call.params.at(i);
try stack.append(RenderState { .Expression = param_node});
if (i != 0) {
try stack.append(RenderState { .Text = ", " });
}
}
},
ast.Node.Id.FnProto => {
const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
switch (fn_proto.return_type) {
ast.Node.FnProto.ReturnType.Explicit => |node| {
try stack.append(RenderState { .Expression = node});
},
ast.Node.FnProto.ReturnType.InferErrorSet => |node| {
try stack.append(RenderState { .Expression = node});
try stack.append(RenderState { .Text = "!"});
},
}
if (fn_proto.align_expr) |align_expr| {
try stack.append(RenderState { .Text = ") " });
try stack.append(RenderState { .Expression = align_expr});
try stack.append(RenderState { .Text = "align(" });
}
try stack.append(RenderState { .Text = ") " });
var i = fn_proto.params.len;
while (i != 0) {
i -= 1;
const param_decl_node = fn_proto.params.items[i];
try stack.append(RenderState { .ParamDecl = param_decl_node});
if (i != 0) {
try stack.append(RenderState { .Text = ", " });
}
}
try stack.append(RenderState { .Text = "(" });
if (fn_proto.name_token) |name_token| {
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(name_token) });
try stack.append(RenderState { .Text = " " });
}
try stack.append(RenderState { .Text = "fn" });
if (fn_proto.async_attr) |async_attr| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = &async_attr.base });
}
if (fn_proto.cc_token) |cc_token| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(cc_token) });
}
if (fn_proto.lib_name) |lib_name| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = lib_name });
}
if (fn_proto.extern_export_inline_token) |extern_export_inline_token| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(extern_export_inline_token) });
}
if (fn_proto.visib_token) |visib_token| {
assert(visib_token.id == Token.Id.Keyword_pub or visib_token.id == Token.Id.Keyword_export);
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(visib_token) });
}
},
ast.Node.Id.LineComment => @panic("TODO render line comment in an expression"),
ast.Node.Id.Switch => {
const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
try stream.print("{} (", self.tokenizer.getTokenSlice(switch_node.switch_token));
try stack.append(RenderState { .Text = "}"});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Text = "\n"});
const cases = switch_node.cases.toSliceConst();
var i = cases.len;
while (i != 0) {
i -= 1;
const node = cases[i];
try stack.append(RenderState { .Text = ","});
try stack.append(RenderState { .Expression = &node.base});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState {
.Text = blk: {
if (i != 0) {
const prev_node = cases[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
}
break :blk "\n";
},
});
}
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState { .Text = ") {"});
try stack.append(RenderState { .Expression = switch_node.expr });
},
ast.Node.Id.SwitchCase => {
const switch_case = @fieldParentPtr(ast.Node.SwitchCase, "base", base);
try stack.append(RenderState { .Expression = switch_case.expr });
if (switch_case.payload) |payload| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = payload });
}
try stack.append(RenderState { .Text = " => "});
const items = switch_case.items.toSliceConst();
var i = items.len;
while (i != 0) {
i -= 1;
try stack.append(RenderState { .Expression = items[i] });
if (i != 0) {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Text = ",\n" });
}
}
},
ast.Node.Id.SwitchElse => {
const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(switch_else.token));
},
ast.Node.Id.Else => {
const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
try stream.print("{}", self.tokenizer.getTokenSlice(else_node.else_token));
switch (else_node.body.id) {
ast.Node.Id.Block, ast.Node.Id.If,
ast.Node.Id.For, ast.Node.Id.While,
ast.Node.Id.Switch => {
try stream.print(" ");
try stack.append(RenderState { .Expression = else_node.body });
},
else => {
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Expression = else_node.body });
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = "\n" });
}
}
if (else_node.payload) |payload| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = payload });
}
},
ast.Node.Id.While => {
const while_node = @fieldParentPtr(ast.Node.While, "base", base);
if (while_node.label) |label| {
try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
}
if (while_node.inline_token) |inline_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(inline_token));
}
try stream.print("{} ", self.tokenizer.getTokenSlice(while_node.while_token));
if (while_node.@"else") |@"else"| {
try stack.append(RenderState { .Expression = &@"else".base });
if (while_node.body.id == ast.Node.Id.Block) {
try stack.append(RenderState { .Text = " " });
} else {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Text = "\n" });
}
}
if (while_node.body.id == ast.Node.Id.Block) {
try stack.append(RenderState { .Expression = while_node.body });
try stack.append(RenderState { .Text = " " });
} else {
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Expression = while_node.body });
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = "\n" });
}
if (while_node.continue_expr) |continue_expr| {
try stack.append(RenderState { .Text = ")" });
try stack.append(RenderState { .Expression = continue_expr });
try stack.append(RenderState { .Text = ": (" });
try stack.append(RenderState { .Text = " " });
}
if (while_node.payload) |payload| {
try stack.append(RenderState { .Expression = payload });
try stack.append(RenderState { .Text = " " });
}
try stack.append(RenderState { .Text = ")" });
try stack.append(RenderState { .Expression = while_node.condition });
try stack.append(RenderState { .Text = "(" });
},
ast.Node.Id.For => {
const for_node = @fieldParentPtr(ast.Node.For, "base", base);
if (for_node.label) |label| {
try stream.print("{}: ", self.tokenizer.getTokenSlice(label));
}
if (for_node.inline_token) |inline_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(inline_token));
}
try stream.print("{} ", self.tokenizer.getTokenSlice(for_node.for_token));
if (for_node.@"else") |@"else"| {
try stack.append(RenderState { .Expression = &@"else".base });
if (for_node.body.id == ast.Node.Id.Block) {
try stack.append(RenderState { .Text = " " });
} else {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Text = "\n" });
}
}
if (for_node.body.id == ast.Node.Id.Block) {
try stack.append(RenderState { .Expression = for_node.body });
try stack.append(RenderState { .Text = " " });
} else {
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Expression = for_node.body });
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = "\n" });
}
if (for_node.payload) |payload| {
try stack.append(RenderState { .Expression = payload });
try stack.append(RenderState { .Text = " " });
}
try stack.append(RenderState { .Text = ")" });
try stack.append(RenderState { .Expression = for_node.array_expr });
try stack.append(RenderState { .Text = "(" });
},
ast.Node.Id.If => {
const if_node = @fieldParentPtr(ast.Node.If, "base", base);
try stream.print("{} ", self.tokenizer.getTokenSlice(if_node.if_token));
switch (if_node.body.id) {
ast.Node.Id.Block, ast.Node.Id.If,
ast.Node.Id.For, ast.Node.Id.While,
ast.Node.Id.Switch => {
if (if_node.@"else") |@"else"| {
try stack.append(RenderState { .Expression = &@"else".base });
if (if_node.body.id == ast.Node.Id.Block) {
try stack.append(RenderState { .Text = " " });
} else {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Text = "\n" });
}
}
},
else => {
if (if_node.@"else") |@"else"| {
try stack.append(RenderState { .Expression = @"else".body });
if (@"else".payload) |payload| {
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Expression = payload });
}
try stack.append(RenderState { .Text = " " });
try stack.append(RenderState { .Text = self.tokenizer.getTokenSlice(@"else".else_token) });
try stack.append(RenderState { .Text = " " });
}
}
}
try stack.append(RenderState { .Expression = if_node.body });
try stack.append(RenderState { .Text = " " });
if (if_node.payload) |payload| {
try stack.append(RenderState { .Expression = payload });
try stack.append(RenderState { .Text = " " });
}
try stack.append(RenderState { .Text = ")" });
try stack.append(RenderState { .Expression = if_node.condition });
try stack.append(RenderState { .Text = "(" });
},
ast.Node.Id.Asm => {
const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
try stream.print("{} ", self.tokenizer.getTokenSlice(asm_node.asm_token));
if (asm_node.volatile_token) |volatile_token| {
try stream.print("{} ", self.tokenizer.getTokenSlice(volatile_token));
}
try stack.append(RenderState { .Indent = indent });
try stack.append(RenderState { .Text = ")" });
{
const cloppers = asm_node.cloppers.toSliceConst();
var i = cloppers.len;
while (i != 0) {
i -= 1;
try stack.append(RenderState { .Expression = cloppers[i] });
if (i != 0) {
try stack.append(RenderState { .Text = ", " });
}
}
}
try stack.append(RenderState { .Text = ": " });
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta });
try stack.append(RenderState { .Text = "\n" });
{
const inputs = asm_node.inputs.toSliceConst();
var i = inputs.len;
while (i != 0) {
i -= 1;
const node = inputs[i];
try stack.append(RenderState { .Expression = &node.base});
if (i != 0) {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState {
.Text = blk: {
const prev_node = inputs[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
break :blk "\n";
},
});
try stack.append(RenderState { .Text = "," });
}
}
}
try stack.append(RenderState { .Indent = indent + indent_delta + 2});
try stack.append(RenderState { .Text = ": "});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState { .Text = "\n" });
{
const outputs = asm_node.outputs.toSliceConst();
var i = outputs.len;
while (i != 0) {
i -= 1;
const node = outputs[i];
try stack.append(RenderState { .Expression = &node.base});
if (i != 0) {
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState {
.Text = blk: {
const prev_node = outputs[i - 1];
const loc = self.tokenizer.getTokenLocation(prev_node.lastToken().end, node.firstToken());
if (loc.line >= 2) {
break :blk "\n\n";
}
break :blk "\n";
},
});
try stack.append(RenderState { .Text = "," });
}
}
}
try stack.append(RenderState { .Indent = indent + indent_delta + 2});
try stack.append(RenderState { .Text = ": "});
try stack.append(RenderState.PrintIndent);
try stack.append(RenderState { .Indent = indent + indent_delta});
try stack.append(RenderState { .Text = "\n" });
try stack.append(RenderState { .Expression = asm_node.template });
try stack.append(RenderState { .Text = "(" });
},
ast.Node.Id.AsmInput => {
const asm_input = @fieldParentPtr(ast.Node.AsmInput, "base", base);
try stack.append(RenderState { .Text = ")"});
try stack.append(RenderState { .Expression = asm_input.expr});
try stack.append(RenderState { .Text = " ("});
try stack.append(RenderState { .Expression = asm_input.constraint });
try stack.append(RenderState { .Text = "] "});
try stack.append(RenderState { .Expression = asm_input.symbolic_name });
try stack.append(RenderState { .Text = "["});
},
ast.Node.Id.AsmOutput => {
const asm_output = @fieldParentPtr(ast.Node.AsmOutput, "base", base);
try stack.append(RenderState { .Text = ")"});
switch (asm_output.kind) {
ast.Node.AsmOutput.Kind.Variable => |variable_name| {
try stack.append(RenderState { .Expression = &variable_name.base});
},
ast.Node.AsmOutput.Kind.Return => |return_type| {
try stack.append(RenderState { .Expression = return_type});
try stack.append(RenderState { .Text = "-> "});
},
}
try stack.append(RenderState { .Text = " ("});
try stack.append(RenderState { .Expression = asm_output.constraint });
try stack.append(RenderState { .Text = "] "});
try stack.append(RenderState { .Expression = asm_output.symbolic_name });
try stack.append(RenderState { .Text = "["});
},
ast.Node.Id.StructField,
ast.Node.Id.UnionTag,
ast.Node.Id.EnumTag,
ast.Node.Id.Root,
ast.Node.Id.VarDecl,
ast.Node.Id.Use,
ast.Node.Id.TestDecl,
ast.Node.Id.ParamDecl => unreachable,
},
RenderState.Statement => |base| {
switch (base.id) {
ast.Node.Id.VarDecl => {
const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
try self.renderComments(stream, var_decl, indent);
try stack.append(RenderState { .VarDecl = var_decl});
},
else => {
if (requireSemiColon(base)) {
try stack.append(RenderState { .Text = ";" });
}
try stack.append(RenderState { .Expression = base });
},
}
},
RenderState.Indent => |new_indent| indent = new_indent,
RenderState.PrintIndent => try stream.writeByteNTimes(' ', indent),
}
}
}
fn renderComments(self: &Parser, stream: var, node: var, indent: usize) !void {
const comment = node.comments ?? return;
for (comment.lines.toSliceConst()) |line_token| {
try stream.print("{}\n", self.tokenizer.getTokenSlice(line_token));
try stream.writeByteNTimes(' ', indent);
}
}
fn initUtilityArrayList(self: &Parser, comptime T: type) ArrayList(T) {
const new_byte_count = self.utility_bytes.len - self.utility_bytes.len % @sizeOf(T);
self.utility_bytes = self.util_allocator.alignedShrink(u8, utility_bytes_align, self.utility_bytes, new_byte_count);
const typed_slice = ([]T)(self.utility_bytes);
return ArrayList(T) {
.allocator = self.util_allocator,
.items = typed_slice,
.len = 0,
};
}
fn deinitUtilityArrayList(self: &Parser, list: var) void {
self.utility_bytes = ([]align(utility_bytes_align) u8)(list.items);
}
};
var fixed_buffer_mem: [100 * 1024]u8 = undefined;
fn testParse(source: []const u8, allocator: &mem.Allocator) ![]u8 {
var tokenizer = Tokenizer.init(source);
var parser = Parser.init(&tokenizer, allocator, "(memory buffer)");
defer parser.deinit();
var tree = try parser.parse();
defer tree.deinit();
var buffer = try std.Buffer.initSize(allocator, 0);
errdefer buffer.deinit();
var buffer_out_stream = io.BufferOutStream.init(&buffer);
try parser.renderSource(&buffer_out_stream.stream, tree.root_node);
return buffer.toOwnedSlice();
}
fn testCanonical(source: []const u8) !void {
const needed_alloc_count = x: {
// Try it once with unlimited memory, make sure it works
var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
const result_source = try testParse(source, &failing_allocator.allocator);
if (!mem.eql(u8, result_source, source)) {
warn("\n====== expected this output: =========\n");
warn("{}", source);
warn("\n======== instead found this: =========\n");
warn("{}", result_source);
warn("\n======================================\n");
return error.TestFailed;
}
failing_allocator.allocator.free(result_source);
break :x failing_allocator.index;
};
var fail_index: usize = 0;
while (fail_index < needed_alloc_count) : (fail_index += 1) {
var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
if (testParse(source, &failing_allocator.allocator)) |_| {
return error.NondeterministicMemoryUsage;
} else |err| switch (err) {
error.OutOfMemory => {
if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
warn("\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
fail_index, needed_alloc_count,
failing_allocator.allocated_bytes, failing_allocator.freed_bytes,
failing_allocator.index, failing_allocator.deallocations);
return error.MemoryLeakDetected;
}
},
error.ParseError => @panic("test failed"),
}
}
}
test "zig fmt: preserve top level comments" {
try testCanonical(
\\// top level comment
\\test "hi" {}
\\
);
}
test "zig fmt: get stdout or fail" {
try testCanonical(
\\const std = @import("std");
\\
\\pub fn main() !void {
\\ // If this program is run without stdout attached, exit with an error.
\\ // another comment
\\ var stdout_file = try std.io.getStdOut;
\\}
\\
);
}
test "zig fmt: preserve spacing" {
try testCanonical(
\\const std = @import("std");
\\
\\pub fn main() !void {
\\ var stdout_file = try std.io.getStdOut;
\\ var stdout_file = try std.io.getStdOut;
\\
\\ var stdout_file = try std.io.getStdOut;
\\ var stdout_file = try std.io.getStdOut;
\\}
\\
);
}
test "zig fmt: return types" {
try testCanonical(
\\pub fn main() !void {}
\\pub fn main() var {}
\\pub fn main() i32 {}
\\
);
}
test "zig fmt: imports" {
try testCanonical(
\\const std = @import("std");
\\const std = @import();
\\
);
}
test "zig fmt: global declarations" {
try testCanonical(
\\const a = b;
\\pub const a = b;
\\var a = b;
\\pub var a = b;
\\const a: i32 = b;
\\pub const a: i32 = b;
\\var a: i32 = b;
\\pub var a: i32 = b;
\\extern const a: i32 = b;
\\pub extern const a: i32 = b;
\\extern var a: i32 = b;
\\pub extern var a: i32 = b;
\\extern "a" const a: i32 = b;
\\pub extern "a" const a: i32 = b;
\\extern "a" var a: i32 = b;
\\pub extern "a" var a: i32 = b;
\\
);
}
test "zig fmt: extern declaration" {
try testCanonical(
\\extern var foo: c_int;
\\
);
}
test "zig fmt: alignment" {
try testCanonical(
\\var foo: c_int align(1);
\\
);
}
test "zig fmt: C main" {
try testCanonical(
\\fn main(argc: c_int, argv: &&u8) c_int {
\\ const a = b;
\\}
\\
);
}
test "zig fmt: return" {
try testCanonical(
\\fn foo(argc: c_int, argv: &&u8) c_int {
\\ return 0;
\\}
\\
\\fn bar() void {
\\ return;
\\}
\\
);
}
test "zig fmt: pointer attributes" {
try testCanonical(
\\extern fn f1(s: &align(&u8) u8) c_int;
\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
\\extern fn f4(s: &align(1) const volatile u8) c_int;
\\
);
}
test "zig fmt: slice attributes" {
try testCanonical(
\\extern fn f1(s: &align(&u8) u8) c_int;
\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
\\extern fn f4(s: &align(1) const volatile u8) c_int;
\\
);
}
test "zig fmt: test declaration" {
try testCanonical(
\\test "test name" {
\\ const a = 1;
\\ var b = 1;
\\}
\\
);
}
test "zig fmt: infix operators" {
try testCanonical(
\\test "infix operators" {
\\ var i = undefined;
\\ i = 2;
\\ i *= 2;
\\ i |= 2;
\\ i ^= 2;
\\ i <<= 2;
\\ i >>= 2;
\\ i &= 2;
\\ i *= 2;
\\ i *%= 2;
\\ i -= 2;
\\ i -%= 2;
\\ i += 2;
\\ i +%= 2;
\\ i /= 2;
\\ i %= 2;
\\ _ = i == i;
\\ _ = i != i;
\\ _ = i != i;
\\ _ = i.i;
\\ _ = i || i;
\\ _ = i!i;
\\ _ = i ** i;
\\ _ = i ++ i;
\\ _ = i ?? i;
\\ _ = i % i;
\\ _ = i / i;
\\ _ = i *% i;
\\ _ = i * i;
\\ _ = i -% i;
\\ _ = i - i;
\\ _ = i +% i;
\\ _ = i + i;
\\ _ = i << i;
\\ _ = i >> i;
\\ _ = i & i;
\\ _ = i ^ i;
\\ _ = i | i;
\\ _ = i >= i;
\\ _ = i <= i;
\\ _ = i > i;
\\ _ = i < i;
\\ _ = i and i;
\\ _ = i or i;
\\}
\\
);
}
test "zig fmt: precedence" {
try testCanonical(
\\test "precedence" {
\\ a!b();
\\ (a!b)();
\\ !a!b;
\\ !(a!b);
\\ !a{};
\\ !(a{});
\\ a + b{};
\\ (a + b){};
\\ a << b + c;
\\ (a << b) + c;
\\ a & b << c;
\\ (a & b) << c;
\\ a ^ b & c;
\\ (a ^ b) & c;
\\ a | b ^ c;
\\ (a | b) ^ c;
\\ a == b | c;
\\ (a == b) | c;
\\ a and b == c;
\\ (a and b) == c;
\\ a or b and c;
\\ (a or b) and c;
\\ (a or b) and c;
\\}
\\
);
}
test "zig fmt: prefix operators" {
try testCanonical(
\\test "prefix operators" {
\\ try return --%~??!*&0;
\\}
\\
);
}
test "zig fmt: call expression" {
try testCanonical(
\\test "test calls" {
\\ a();
\\ a(1);
\\ a(1, 2);
\\ a(1, 2) + a(1, 2);
\\}
\\
);
}
test "zig fmt: var args" {
try testCanonical(
\\fn print(args: ...) void {}
\\
);
}
test "zig fmt: var type" {
try testCanonical(
\\fn print(args: var) var {}
\\const Var = var;
\\const i: var = 0;
\\
);
}
test "zig fmt: functions" {
try testCanonical(
\\extern fn puts(s: &const u8) c_int;
\\extern "c" fn puts(s: &const u8) c_int;
\\export fn puts(s: &const u8) c_int;
\\inline fn puts(s: &const u8) c_int;
\\pub extern fn puts(s: &const u8) c_int;
\\pub extern "c" fn puts(s: &const u8) c_int;
\\pub export fn puts(s: &const u8) c_int;
\\pub inline fn puts(s: &const u8) c_int;
\\pub extern fn puts(s: &const u8) align(2 + 2) c_int;
\\pub extern "c" fn puts(s: &const u8) align(2 + 2) c_int;
\\pub export fn puts(s: &const u8) align(2 + 2) c_int;
\\pub inline fn puts(s: &const u8) align(2 + 2) c_int;
\\
);
}
test "zig fmt: multiline string" {
try testCanonical(
\\const s =
\\ \\ something
\\ \\ something else
\\ ;
\\
);
}
test "zig fmt: values" {
try testCanonical(
\\test "values" {
\\ 1;
\\ 1.0;
\\ "string";
\\ c"cstring";
\\ 'c';
\\ true;
\\ false;
\\ null;
\\ undefined;
\\ error;
\\ this;
\\ unreachable;
\\}
\\
);
}
test "zig fmt: indexing" {
try testCanonical(
\\test "test index" {
\\ a[0];
\\ a[0 + 5];
\\ a[0..];
\\ a[0..5];
\\ a[a[0]];
\\ a[a[0..]];
\\ a[a[0..5]];
\\ a[a[0]..];
\\ a[a[0..5]..];
\\ a[a[0]..a[0]];
\\ a[a[0..5]..a[0]];
\\ a[a[0..5]..a[0..5]];
\\}
\\
);
}
test "zig fmt: struct declaration" {
try testCanonical(
\\const S = struct {
\\ const Self = this;
\\ f1: u8,
\\ pub f3: u8,
\\
\\ fn method(self: &Self) Self {
\\ return *self;
\\ }
\\
\\ f2: u8,
\\};
\\
\\const Ps = packed struct {
\\ a: u8,
\\ pub b: u8,
\\
\\ c: u8,
\\};
\\
\\const Es = extern struct {
\\ a: u8,
\\ pub b: u8,
\\
\\ c: u8,
\\};
\\
);
}
test "zig fmt: enum declaration" {
try testCanonical(
\\const E = enum {
\\ Ok,
\\ SomethingElse = 0,
\\};
\\
\\const E2 = enum(u8) {
\\ Ok,
\\ SomethingElse = 255,
\\ SomethingThird,
\\};
\\
\\const Ee = extern enum {
\\ Ok,
\\ SomethingElse,
\\ SomethingThird,
\\};
\\
\\const Ep = packed enum {
\\ Ok,
\\ SomethingElse,
\\ SomethingThird,
\\};
\\
);
}
test "zig fmt: union declaration" {
try testCanonical(
\\const U = union {
\\ Int: u8,
\\ Float: f32,
\\ None,
\\ Bool: bool,
\\};
\\
\\const Ue = union(enum) {
\\ Int: u8,
\\ Float: f32,
\\ None,
\\ Bool: bool,
\\};
\\
\\const E = enum {
\\ Int,
\\ Float,
\\ None,
\\ Bool,
\\};
\\
\\const Ue2 = union(E) {
\\ Int: u8,
\\ Float: f32,
\\ None,
\\ Bool: bool,
\\};
\\
\\const Eu = extern union {
\\ Int: u8,
\\ Float: f32,
\\ None,
\\ Bool: bool,
\\};
\\
);
}
test "zig fmt: error set declaration" {
try testCanonical(
\\const E = error {
\\ A,
\\ B,
\\
\\ C,
\\};
\\
);
}
test "zig fmt: arrays" {
try testCanonical(
\\test "test array" {
\\ const a: [2]u8 = [2]u8 {
\\ 1,
\\ 2,
\\ };
\\ const a: [2]u8 = []u8 {
\\ 1,
\\ 2,
\\ };
\\ const a: [0]u8 = []u8{};
\\}
\\
);
}
test "zig fmt: container initializers" {
try testCanonical(
\\const a1 = []u8{};
\\const a2 = []u8 {
\\ 1,
\\ 2,
\\ 3,
\\ 4,
\\};
\\const s1 = S{};
\\const s2 = S {
\\ .a = 1,
\\ .b = 2,
\\};
\\
);
}
test "zig fmt: catch" {
try testCanonical(
\\test "catch" {
\\ const a: error!u8 = 0;
\\ _ = a catch return;
\\ _ = a catch |err| return;
\\}
\\
);
}
test "zig fmt: blocks" {
try testCanonical(
\\test "blocks" {
\\ {
\\ const a = 0;
\\ const b = 0;
\\ }
\\
\\ blk: {
\\ const a = 0;
\\ const b = 0;
\\ }
\\
\\ const r = blk: {
\\ const a = 0;
\\ const b = 0;
\\ };
\\}
\\
);
}
test "zig fmt: switch" {
try testCanonical(
\\test "switch" {
\\ switch (0) {
\\ 0 => {},
\\ 1 => unreachable,
\\ 2,
\\ 3 => {},
\\ 4 ... 7 => {},
\\ 1 + 4 * 3 + 22 => {},
\\ else => {
\\ const a = 1;
\\ const b = a;
\\ },
\\ }
\\
\\ const res = switch (0) {
\\ 0 => 0,
\\ 1 => 2,
\\ 1 => a = 4,
\\ else => 4,
\\ };
\\
\\ const Union = union(enum) {
\\ Int: i64,
\\ Float: f64,
\\ };
\\
\\ const u = Union {
\\ .Int = 0,
\\ };
\\ switch (u) {
\\ Union.Int => |int| {},
\\ Union.Float => |*float| unreachable,
\\ }
\\}
\\
);
}
test "zig fmt: while" {
try testCanonical(
\\test "while" {
\\ while (10 < 1) {
\\ unreachable;
\\ }
\\
\\ while (10 < 1)
\\ unreachable;
\\
\\ var i: usize = 0;
\\ while (i < 10) : (i += 1) {
\\ continue;
\\ }
\\
\\ i = 0;
\\ while (i < 10) : (i += 1)
\\ continue;
\\
\\ i = 0;
\\ var j: usize = 0;
\\ while (i < 10) : ({
\\ i += 1;
\\ j += 1;
\\ }) {
\\ continue;
\\ }
\\
\\ var a: ?u8 = 2;
\\ while (a) |v| : (a = null) {
\\ continue;
\\ }
\\
\\ while (a) |v| : (a = null)
\\ unreachable;
\\
\\ label: while (10 < 0) {
\\ unreachable;
\\ }
\\
\\ const res = while (0 < 10) {
\\ break 7;
\\ } else {
\\ unreachable;
\\ };
\\
\\ const res = while (0 < 10)
\\ break 7
\\ else
\\ unreachable;
\\
\\ var a: error!u8 = 0;
\\ while (a) |v| {
\\ a = error.Err;
\\ } else |err| {
\\ i = 1;
\\ }
\\
\\ comptime var k: usize = 0;
\\ inline while (i < 10) : (i += 1)
\\ j += 2;
\\}
\\
);
}
test "zig fmt: for" {
try testCanonical(
\\test "for" {
\\ const a = []u8 {
\\ 1,
\\ 2,
\\ 3,
\\ };
\\ for (a) |v| {
\\ continue;
\\ }
\\
\\ for (a) |v|
\\ continue;
\\
\\ for (a) |*v|
\\ continue;
\\
\\ for (a) |v, i| {
\\ continue;
\\ }
\\
\\ for (a) |v, i|
\\ continue;
\\
\\ const res = for (a) |v, i| {
\\ break v;
\\ } else {
\\ unreachable;
\\ };
\\
\\ var num: usize = 0;
\\ inline for (a) |v, i| {
\\ num += v;
\\ num += i;
\\ }
\\}
\\
);
}
test "zig fmt: if" {
try testCanonical(
\\test "if" {
\\ if (10 < 0) {
\\ unreachable;
\\ }
\\
\\ if (10 < 0) unreachable;
\\
\\ if (10 < 0) {
\\ unreachable;
\\ } else {
\\ const a = 20;
\\ }
\\
\\ if (10 < 0) {
\\ unreachable;
\\ } else if (5 < 0) {
\\ unreachable;
\\ } else {
\\ const a = 20;
\\ }
\\
\\ const is_world_broken = if (10 < 0) true else false;
\\ const some_number = 1 + if (10 < 0) 2 else 3;
\\
\\ const a: ?u8 = 10;
\\ const b: ?u8 = null;
\\ if (a) |v| {
\\ const some = v;
\\ } else if (b) |*v| {
\\ unreachable;
\\ } else {
\\ const some = 10;
\\ }
\\
\\ const non_null_a = if (a) |v| v else 0;
\\
\\ const a_err: error!u8 = 0;
\\ if (a_err) |v| {
\\ const p = v;
\\ } else |err| {
\\ unreachable;
\\ }
\\}
\\
);
}
test "zig fmt: defer" {
try testCanonical(
\\test "defer" {
\\ var i: usize = 0;
\\ defer i = 1;
\\ defer {
\\ i += 2;
\\ i *= i;
\\ }
\\
\\ errdefer i += 3;
\\ errdefer {
\\ i += 2;
\\ i /= i;
\\ }
\\}
\\
);
}
test "zig fmt: comptime" {
try testCanonical(
\\fn a() u8 {
\\ return 5;
\\}
\\
\\fn b(comptime i: u8) u8 {
\\ return i;
\\}
\\
\\const av = comptime a();
\\const av2 = comptime blk: {
\\ var res = a();
\\ res *= b(2);
\\ break :blk res;
\\};
\\
\\comptime {
\\ _ = a();
\\}
\\
\\test "comptime" {
\\ const av3 = comptime a();
\\ const av4 = comptime blk: {
\\ var res = a();
\\ res *= a();
\\ break :blk res;
\\ };
\\
\\ comptime var i = 0;
\\ comptime {
\\ i = a();
\\ i += b(i);
\\ }
\\}
\\
);
}
test "zig fmt: fn type" {
try testCanonical(
\\fn a(i: u8) u8 {
\\ return i + 1;
\\}
\\
\\const a: fn(u8) u8 = undefined;
\\const b: extern fn(u8) u8 = undefined;
\\const c: nakedcc fn(u8) u8 = undefined;
\\const ap: fn(u8) u8 = a;
\\
);
}
test "zig fmt: inline asm" {
try testCanonical(
\\pub fn syscall1(number: usize, arg1: usize) usize {
\\ return asm volatile ("syscall"
\\ : [ret] "={rax}" (-> usize)
\\ : [number] "{rax}" (number),
\\ [arg1] "{rdi}" (arg1)
\\ : "rcx", "r11");
\\}
\\
);
}
test "zig fmt: coroutines" {
try testCanonical(
\\async fn simpleAsyncFn() void {
\\ const a = async a.b();
\\ x += 1;
\\ suspend;
\\ x += 1;
\\ suspend |p| {}
\\ const p = async simpleAsyncFn() catch unreachable;
\\ await p;
\\}
\\
\\test "coroutine suspend, resume, cancel" {
\\ const p = try async<std.debug.global_allocator> testAsyncSeq();
\\ resume p;
\\ cancel p;
\\}
\\
);
}
test "zig fmt: Block after if" {
try testCanonical(
\\test "Block after if" {
\\ if (true) {
\\ const a = 0;
\\ }
\\
\\ {
\\ const a = 0;
\\ }
\\}
\\
);
}
test "zig fmt: use" {
try testCanonical(
\\use @import("std");
\\pub use @import("std");
\\
);
}
test "zig fmt: string identifier" {
try testCanonical(
\\const @"a b" = @"c d".@"e f";
\\fn @"g h"() void {}
\\
);
}
test "zig fmt: error return" {
try testCanonical(
\\fn err() error {
\\ call();
\\ return error.InvalidArgs;
\\}
\\
);
}
test "zig fmt: struct literals with fields on each line" {
try testCanonical(
\\var self = BufSet {
\\ .hash_map = BufSetHashMap.init(a),
\\};
\\
);
} | std/zig/parser.zig |
const std = @import("std");
const eql = std.mem.eql;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const expectEqualStrings = std.testing.expectEqualStrings;
const test_allocator = std.testing.allocator;
const trimLeft = std.mem.trimLeft;
const ESCAPE_1 = '\u{001b}';
const ESCAPE_2 = '[';
const UNESCAPE = 'm';
const COMBO = ';';
// we trim leading 0's, so RESET is just an empty instruction, see
// parse_instruction()
const BOLD = '1';
const UNDERSCORE = '4';
const BLINK = '5'; // cursed tag, truly
const HIDDEN = '8';
const FG_FAMILY = '3';
const BRIGHT_FG_FAMILY = '9';
const BG_FAMILY = '4';
// TODO allow changing or removing the begrudge- prefix?
const SPAN_OPEN = "<span class='begrudge-{s}'>";
const SPAN_CLOSE = "</span>";
const SPAN_CLASS_BOLD = "bold";
const SPAN_CLASS_UNDERSCORE = "underscore";
const SPAN_CLASS_BLINK = "blink";
const SPAN_CLASS_HIDDEN = "hidden";
const LONGEST_SPAN_CLASS_NAME = std.mem.max(usize, &.{
SPAN_CLASS_BOLD.len,
SPAN_CLASS_UNDERSCORE.len,
SPAN_CLASS_BLINK.len,
SPAN_CLASS_HIDDEN.len,
});
// this is *not* the fancy-shmancy and generally considered to be
// much-more-correct https://vt100.net/emu/dec_ansi_parser state machine, but
// rather an internal representation of what spans are currently open. we'll
// classify our supported escapess into a few categories, of which only one of
// each category can be on at a given time. when we see a RESET, that's easy:
// just close all open spans and call it a day. however, there's no guarantee
// we'll see a RESET between two escapes of the same category (perhaps we
// turned on BOLD and BG_2 but want to flip between FG_1 and FG_4). while the
// "correct" (and most tag-efficient) thing to do is to track the order that
// spans were opened and close only as many as necessary to unroll back to the
// FG_1, then open an FG_4 and re-open all the other spans, the *simple* thing
// to do is to simply close all spans when we change escapes within a category,
// and reopen all new ones.
//
// this state struct tracks enough... state... to enable the above behavior
const State = struct {
// while zig exposes the default values of a struct (and we even use that
// functionality later on), it's exposed as an array of StructFields, and
// for random lookups, O(1) is of course nice. so we'll just store this for
// when we need to look up by field name later.
const default_state = .{
.bold = false,
.underscore = false,
.blink = false,
.hidden = false,
.fg = null,
.bg = null,
};
bold: bool = default_state.bold,
underscore: bool = default_state.underscore,
blink: bool = default_state.blink,
hidden: bool = default_state.hidden,
fg: ?u8 = default_state.fg,
bg: ?u8 = default_state.bg,
pub fn num_differing_fields(self: *@This()) u8 {
var differing_fields: u8 = 0;
inline for (std.meta.fields(@This())) |field| {
if (@field(self, field.name) != @field(default_state, field.name)) {
differing_fields += 1;
}
}
return differing_fields;
}
pub fn write_all_open_spans(self: *@This(), output: anytype, color_class_buf: []u8) !void {
var span_buf: [SPAN_OPEN.len + LONGEST_SPAN_CLASS_NAME]u8 = undefined;
inline for (std.meta.fields(@This())) |field| {
if (@field(self, field.name) != @field(default_state, field.name)) {
var class_name = field.name;
// the type system (rightfully) gets real cranky with these
// hacks on nullable fields, so fg and bg need handled (1)
// separately from everything else, and (2) separately from
// *each other*
if (eql(u8, field.name, "fg")) {
if (self.fg) |fg| {
class_name = try color_class_name(field.name, fg, color_class_buf);
}
}
if (eql(u8, field.name, "bg")) {
if (self.bg) |bg| {
class_name = try color_class_name(field.name, bg, color_class_buf);
}
}
const tag = try std.fmt.bufPrint(span_buf[0..], SPAN_OPEN, .{class_name});
try output.writeAll(tag);
}
}
}
pub fn write_close_spans(_: *@This(), output: anytype, count: u8) !void {
var close_idx: u8 = 0;
while (close_idx < count) {
try output.writeAll(SPAN_CLOSE);
close_idx += 1;
}
}
pub const OutputInstruction = union(enum) {
/// some operations only require opening a single new tag (which
/// doesn't conflict with any others currently open), this represents
/// the new class name to open a span for
Incremental: []const u8,
/// for safety's sake, all other cases currently require a full
/// teardown and rebuild of the tag stack. since the number of
/// differing fields may have changed as part of the mutation, this u8
/// tracks how many differing fields were detected before applying the
/// mutation
Rebuild: u8,
};
pub fn mutate(self: *@This(), mutation: Mutation, color_class_buf: []u8) !?OutputInstruction {
const differing_fields = self.num_differing_fields();
return switch (mutation) {
.Reset => blk: {
if (differing_fields == 0) break :blk null;
inline for (std.meta.fields(@This())) |field| {
@field(self, field.name) = field.default_value.?;
}
break :blk OutputInstruction{ .Rebuild = differing_fields };
},
.BoldEnable => mutation_simple_enable(self, SPAN_CLASS_BOLD),
.UnderscoreEnable => mutation_simple_enable(self, SPAN_CLASS_UNDERSCORE),
.BlinkEnable => mutation_simple_enable(self, SPAN_CLASS_BLINK),
.HiddenEnable => mutation_simple_enable(self, SPAN_CLASS_HIDDEN),
.Foreground => |color_idx| try mutation_color_enable(self, "fg", color_idx, differing_fields, color_class_buf),
.Background => |color_idx| try mutation_color_enable(self, "bg", color_idx, differing_fields, color_class_buf),
};
}
fn mutation_simple_enable(self: *@This(), comptime field: []const u8) ?OutputInstruction {
if (@field(self, field)) {
return null;
}
@field(self, field) = true;
return OutputInstruction{ .Incremental = field };
}
fn mutation_color_enable(
self: *@This(),
comptime field: []const u8,
color: u8,
differing_fields: u8,
color_class_buf: []u8,
) !?OutputInstruction {
const old_color = @field(self, field);
if (color == old_color) {
return null;
}
@field(self, field) = color;
const class_name = try color_class_name(field, color, color_class_buf);
if (old_color) |_| {
return OutputInstruction{ .Rebuild = differing_fields };
}
return OutputInstruction{ .Incremental = class_name };
}
fn color_class_name(comptime field: []const u8, color: u8, color_class_buf: []u8) ![]const u8 {
return try std.fmt.bufPrint(color_class_buf, "{s}-{d}", .{ field, color });
}
test "State.mutate::reset_everything" {
var color_class_buf: [5]u8 = undefined;
var state = State{
.bold = true,
.underscore = true,
.blink = true,
.hidden = true,
.fg = 1,
.bg = 8,
};
const expected_state = State{};
const result = try state.mutate(Mutation{ .Reset = {} }, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Rebuild = 6 }, result.?);
}
test "State.mutate::useless_resets_ignored" {
var color_class_buf: [5]u8 = undefined;
var state = State{};
try expect(null == try state.mutate(Mutation{ .Reset = {} }, color_class_buf[0..]));
}
test "State.mutate::can_enable_bold" {
var color_class_buf: [5]u8 = undefined;
var state = State{};
var expected_state = State{ .bold = true };
var mutation = Mutation{ .BoldEnable = {} };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Incremental = "bold" }, result.?);
}
test "State.mutate::can_enable_underscore" {
var color_class_buf: [5]u8 = undefined;
var state = State{};
var expected_state = State{ .underscore = true };
var mutation = Mutation{ .UnderscoreEnable = {} };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Incremental = "underscore" }, result.?);
}
test "State.mutate::can_enable_blink" {
var color_class_buf: [5]u8 = undefined;
var state = State{};
var expected_state = State{ .blink = true };
var mutation = Mutation{ .BlinkEnable = {} };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Incremental = "blink" }, result.?);
}
test "State.mutate::can_enable_hidden" {
var color_class_buf: [5]u8 = undefined;
var state = State{};
var expected_state = State{ .hidden = true };
var mutation = Mutation{ .HiddenEnable = {} };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Incremental = "hidden" }, result.?);
}
test "State.mutate::can_enable_second_simple_toggle_without_closing_others" {
var color_class_buf: [5]u8 = undefined;
var state = State{ .bold = true };
var expected_state = State{ .bold = true, .hidden = true };
var mutation = Mutation{ .HiddenEnable = {} };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Incremental = "hidden" }, result.?);
}
test "State.mutate::can_enable_fg_color_without_closing_anything" {
var color_class_buf: [5]u8 = undefined;
var state = State{ .bold = true };
var expected_state = State{ .bold = true, .fg = 1 };
var mutation = Mutation{ .Foreground = 1 };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqualStrings("fg-1", result.?.Incremental);
}
test "State.mutate::switching_fg_colors_with_one_existing_forces_rebuild" {
var color_class_buf: [5]u8 = undefined;
var state = State{ .fg = 1 };
var expected_state = State{ .fg = 2 };
var mutation = Mutation{ .Foreground = 2 };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Rebuild = 1 }, result.?);
}
test "State.mutate::can_enable_bg_color_without_closing_anything" {
var color_class_buf: [5]u8 = undefined;
var state = State{ .bold = true };
var expected_state = State{ .bold = true, .bg = 1 };
var mutation = Mutation{ .Background = 1 };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqualStrings("bg-1", result.?.Incremental);
}
test "State.mutate::switching_bg_colors_with_one_existing_forces_rebuild" {
var color_class_buf: [5]u8 = undefined;
var state = State{ .bg = 1 };
var expected_state = State{ .bg = 2 };
var mutation = Mutation{ .Background = 2 };
const result = try state.mutate(mutation, color_class_buf[0..]);
try expectEqual(expected_state, state);
try expectEqual(State.OutputInstruction{ .Rebuild = 1 }, result.?);
}
comptime {
std.testing.refAllDecls(@This());
}
};
const Mutation = union(enum) {
Reset,
BoldEnable,
UnderscoreEnable,
BlinkEnable,
HiddenEnable,
Foreground: u8,
Background: u8,
pub fn from_instruction(ins: []const u8) ?@This() {
const ins_trimmed = trimLeft(u8, ins, "0");
return switch (ins_trimmed.len) {
// all 0's got trimmed out, leaving us with a "0" instruction aka reset
0 => Mutation{ .Reset = {} },
1 => switch (ins_trimmed[0]) {
BOLD => Mutation{ .BoldEnable = {} },
UNDERSCORE => Mutation{ .UnderscoreEnable = {} },
BLINK => Mutation{ .BlinkEnable = {} },
HIDDEN => Mutation{ .HiddenEnable = {} },
else => null,
},
2 => switch (ins_trimmed[0]) {
FG_FAMILY => switch (ins_trimmed[1]) {
'8' => null, // truecolor not supported
'9' => null, // FG_NONE not yet supported
else => Mutation{ .Foreground = color_code_from_char(ins_trimmed[1]) },
},
BRIGHT_FG_FAMILY => blk: {
if (ins_trimmed[1] < '8') {
break :blk Mutation{ .Foreground = bright_color_code_from_char(ins_trimmed[1]) };
} else {
break :blk null;
}
},
BG_FAMILY => switch (ins_trimmed[1]) {
'8' => null, // truecolor not supported
'9' => null, // BG_NONE not yet supported
else => Mutation{ .Background = color_code_from_char(ins_trimmed[1]) },
},
else => null,
},
// the only 100+ series codes we understand are bright backgrounds, so
// we get to be *extra* lazy
3 => switch (ins_trimmed[1]) {
'0' => blk: {
if (ins_trimmed[2] < '8') {
break :blk Mutation{ .Background = bright_color_code_from_char(ins_trimmed[2]) };
} else {
break :blk null;
}
},
else => null,
},
else => null,
};
}
fn color_code_from_char(char: u8) u8 {
return char - 48;
}
fn bright_color_code_from_char(char: u8) u8 {
return 8 + color_code_from_char(char);
}
};
pub fn main() anyerror!void {
const in = std.io.getStdIn();
const out = std.io.getStdOut();
var buf_in = std.io.bufferedReader(in.reader());
var buf_out = std.io.bufferedWriter(out.writer());
try process_stream(&buf_in, &buf_out);
try buf_out.flush();
}
fn process_stream(input: anytype, output: anytype) !void {
const reader = input.reader();
const writer = output.writer();
var state = State{};
var instruction_read_buf: [32]u8 = undefined;
var span_buf: [SPAN_OPEN.len + LONGEST_SPAN_CLASS_NAME]u8 = undefined;
var color_class_buf: [5]u8 = undefined;
var need_to_open_spans = false;
while (reader.readByte()) |c| {
if (need_to_open_spans) {
try state.write_all_open_spans(writer, color_class_buf[0..]);
need_to_open_spans = false;
}
// if we get a new line, close all open tags, and reopen them on the
// next new line (if applicable), to prevent unclosed spans or otherwise
// interfering with HTML the caller may wrap around this output on a
// line-by-line basis
if (c == '\n') {
try state.write_close_spans(writer, state.num_differing_fields());
try writer.writeByte(c);
// if there's anything left in the stream, we'll open new tags next
// iteration, otherwise, the while->else will end execution anyway
need_to_open_spans = true;
continue;
}
if (c != ESCAPE_1) {
try writer.writeByte(c);
continue;
}
const c2 = try reader.readByte();
if (c2 != ESCAPE_2) {
// technically, malformed escape sequences are probably not useful
// to downstream consumers, but it's not this tool's place to make
// that determination, so dump them out verbatim
try writer.writeByte(c);
try writer.writeByte(c2);
continue;
}
if (try reader.readUntilDelimiterOrEof(instruction_read_buf[0..], UNESCAPE)) |seq| {
const last_possible_index = seq.len - 1;
var instruction_start: usize = 0;
for (seq) |sc, idx| {
const is_end = idx == last_possible_index;
if (is_end or sc == COMBO) {
const slice = if (is_end) seq[instruction_start..] else seq[instruction_start..idx];
if (Mutation.from_instruction(slice)) |mutation| {
std.log.debug("mutation: {s}", .{mutation});
if (try state.mutate(mutation, color_class_buf[0..])) |todo| {
std.log.debug("todo: {s}", .{todo});
switch (todo) {
.Incremental => |class_name| {
const tag = try std.fmt.bufPrint(span_buf[0..], SPAN_OPEN, .{class_name});
try writer.writeAll(tag);
},
.Rebuild => |close_count| {
try state.write_close_spans(writer, close_count);
try state.write_all_open_spans(writer, color_class_buf[0..]);
},
}
}
}
instruction_start = std.math.min(last_possible_index, idx + 1);
}
}
}
} else |err| switch (err) {
error.EndOfStream => {},
else => std.log.err("error received: {s}", .{err}),
}
}
// NOTE: all the remaining tests are integration tests of the stream parser,
// and were generated by piping whatever command is in the comments into base64
// and then wl-copy, so that the ANSI escape sequences would be reasonable-ish
// to paste in (as opposed to needing to read files off the disk at test time)
// ls -1 --color=always | hexdump -b | cut -c 9-
//
// this is probably the easiest case I've found: opens a bold and fg-4 sequence
// that spans only a partial line on two lines, and the rest of the lines are
// uncolored
test "process_stream::simple" {
const ls_output = [_]u8{
033, 133, 060, 155, 033, 133, 060, 061, 073, 063, 064, 155, 172, 151, 147, 055,
143, 141, 143, 150, 145, 033, 133, 060, 155, 057, 012, 033, 133, 060, 061, 073,
063, 064, 155, 172, 151, 147, 055, 157, 165, 164, 033, 133, 060, 155, 057, 012,
033, 133, 060, 060, 155, 142, 145, 147, 162, 165, 144, 147, 145, 056, 172, 151,
147, 033, 133, 060, 155, 012, 033, 133, 060, 060, 155, 142, 165, 151, 154, 144,
056, 172, 151, 147, 033, 133, 060, 155, 012, 033, 133, 060, 060, 155, 103, 117,
120, 131, 111, 116, 107, 033, 133, 060, 155, 012, 033, 133, 060, 060, 155, 122,
105, 101, 104, 115, 105, 056, 155, 144, 033, 133, 060, 155, 012,
};
const exp =
\\<span class='begrudge-bold'><span class='begrudge-fg-4'>zig-cache</span></span>/
\\<span class='begrudge-bold'><span class='begrudge-fg-4'>zig-out</span></span>/
\\begrudge.zig
\\build.zig
\\COPYING
\\Makefile
\\README.md
;
var output_buf: [4096]u8 = undefined;
var input = std.io.fixedBufferStream(ls_output[0..]);
var output = std.io.fixedBufferStream(output_buf[0..]);
try process_stream(&input, &output);
try expectEqualStrings(exp, output.getWritten());
}
comptime {
std.testing.refAllDecls(@This());
} | begrudge.zig |
const std = @import("std");
const minInt = std.math.minInt;
const maxInt = std.math.maxInt;
const add = std.math.add;
const sub = std.math.sub;
const mul = std.math.mul;
const base = @import("base.zig");
const gen = @import("gen.zig");
const UNIX_EPOCH_IN_MJD: i32 = 40587;
const RD_EPOCH_IN_MJD: i32 = -678576;
fn clockModulo(a: i32, b: u31) u31 {
return @intCast(u31, @mod((a - 1), b)) + 1;
}
fn isLeap(year: i32, cal: *const base.Cal) bool {
const lc = cal.*.leap_cycle;
//Prevent overflow by promoting all quantities to i64
const y = @intCast(i64, year);
const c = @intCast(i64, lc.year_count);
const l = @intCast(i64, lc.leap_year_count);
const A = @intCast(i64, lc.offset_years);
const adjusted: i64 = (l * y) - A;
const m_simple = @mod(adjusted, c);
const res_simple = m_simple < l;
if (lc.skip100) {
const res100 = (@mod(adjusted, 100) != 0 or @mod(adjusted, 400) == 0);
if (lc.skip4000) {
const res4000 = (@mod(adjusted, 4000) != 0);
return res_simple and res100 and res4000;
} else {
return res_simple and res100;
}
} else {
if (lc.skip4000) {
unreachable;
}
return res_simple;
}
}
fn getSegments(year: i32, cal: *const base.Cal) [*:null]const ?base.Segment {
if (isLeap(year, cal)) {
return cal.*.leap_lookup_list;
} else {
return cal.*.common_lookup_list;
}
}
fn diffModifier(bigDiff: i32, smallDiff: i32) i32 {
if (bigDiff > 0 and smallDiff < 0) {
return -1;
}
if (bigDiff < 0 and smallDiff > 0) {
return 1;
}
return 0;
}
fn daysInCycle(cal: *const base.Cal) i32 {
const lc = cal.*.leap_cycle;
const common_cycle: i32 = @intCast(i32, gen.yearLen(false, cal)) * lc.year_count;
const leap_cycle = lc.leap_year_count * lc.leap_days;
return common_cycle + leap_cycle;
}
const YearCycle = struct {
count: i32 = 0,
rem: i32 = 0,
len: i32 = 0,
fn cycle(days: i32, years: u16, leaps: u16, cal: *const base.Cal) YearCycle {
const common: i32 = @intCast(i32, gen.yearLen(false, cal)) * years;
const leap: i32 = @intCast(i32, cal.*.leap_cycle.leap_days) * leaps;
const total = common + leap;
return YearCycle{
.count = @divFloor(days, total),
.rem = @mod(days, total),
.len = years,
};
}
fn leapCycle(days: i32, cal: *const base.Cal) YearCycle {
const lc = cal.*.leap_cycle;
return YearCycle.cycle(days, lc.year_count, lc.leap_year_count, cal);
}
fn prod(self: YearCycle) i32 {
return self.len * self.count;
}
};
const C99Tm = extern struct {
tm_sec: c_int,
tm_min: c_int,
tm_hour: c_int,
tm_mday: c_int,
tm_mon: c_int,
tm_year: c_int,
tm_wday: c_int,
tm_yday: c_int,
tm_isdst: c_int,
};
const Date = struct {
year: i32,
month: u8,
day: u8,
fn toDoyFromSegments(
self: Date,
segments: [*:null]const ?base.Segment,
) base.Err!DoyDate {
var si: u8 = 0;
while (segments[si]) |s| : (si += 1) {
if (gen.getDayOfYearFromSegment(self.month, self.day, s)) |res_doy| {
return DoyDate{ .year = self.year, .doy = res_doy };
}
}
return base.Err.DateNotFound;
}
fn toDoy(self: Date, cal: *const base.Cal) base.Err!DoyDate {
return self.toDoyFromSegments(getSegments(self.year, cal));
}
fn skipIntercalary(self: Date, cal: *const base.Cal) base.Err!Date {
var prev_day = self;
while (gen.seekIc(prev_day.month, prev_day.day, cal)) |ic| {
const prev_leap = isLeap(prev_day.year, cal);
var dd_doy = ic.day_of_year;
if (prev_leap) {
dd_doy = ic.day_of_leap_year;
}
var offset: u16 = 1;
if (gen.yearLen(prev_leap, cal) < dd_doy) {
offset = 0;
}
const dd: DoyDate = .{
.year = prev_day.year,
.doy = dd_doy + offset,
};
const norm_dd = try dd.norm(cal);
const next_day = try norm_dd.toMonthDay(cal);
if (prev_day.year == next_day.year and prev_day.month == next_day.month and prev_day.day == next_day.day) {
return base.Err.BadCalendar;
}
prev_day = next_day;
}
return prev_day;
}
fn norm(self: Date, cal: *const base.Cal) base.Err!Date {
const segments = getSegments(self.year, cal);
var matching_si: u8 = 0;
var si: u8 = 0;
while (segments[si]) |s| : (si += 1) {
if (s.month == self.month) {
if (self.day >= s.day_start and self.day <= s.day_end) {
return self;
}
matching_si = si;
}
}
//d.day is too big
if (segments[matching_si]) |matching_s| {
//const excess_days = d.day -% matching_s.day_start;
const dd: DoyDate = .{
.year = self.year,
.doy = matching_s.offset +% self.day,
};
const norm_dd = try dd.norm(cal);
const res = try norm_dd.toMonthDay(cal);
return res;
} else {
return base.Err.BadCalendar;
}
}
//Validation
fn valid_year(self: Date, cal: *const base.Cal) bool {
return (cal.*.year0 or self.year != 0);
}
fn valid_assume_yz(self: Date, cal: *const base.Cal) bool {
const segments = getSegments(self.year, cal);
var si: u8 = 0;
while (segments[si]) |s| : (si += 1) {
if (self.month == s.month and self.day >= s.day_start and self.day <= s.day_end) {
return true;
}
}
return false;
}
//Year Zero adjustment
fn yzNeedsAdjustment(self: Date, cal: *const base.Cal) bool {
return (!cal.*.year0) and (self.year < 1);
}
fn yzToNoYz(self: Date, cal: *const base.Cal) Date {
const y = if (self.yzNeedsAdjustment(cal)) (self.year -% 1) else self.year;
return .{ .year = y, .month = self.month, .day = self.day };
}
fn noYzToYz(self: Date, cal: *const base.Cal) Date {
const y = if (self.yzNeedsAdjustment(cal)) (self.year +% 1) else self.year;
return .{ .year = y, .month = self.month, .day = self.day };
}
fn noYzToValidYz(self: Date, cal: *const base.Cal) base.Err!Date {
if (self.valid_year(cal)) {
const d_yz = self.noYzToYz(cal);
if (d_yz.valid_assume_yz(cal)) {
return d_yz;
}
}
return base.Err.InvalidDate;
}
};
const DoyDate = struct {
year: i32,
doy: u16,
fn toMonthDay(self: DoyDate, cal: *const base.Cal) base.Err!Date {
const segments = getSegments(self.year, cal);
var si: u8 = 0;
while (segments[si]) |s| : (si += 1) {
const s_len = (s.day_end - s.day_start) + 1;
const s_end = s.offset + s_len;
if (self.doy > s.offset and self.doy <= s_end) {
const day = @intCast(u8, self.doy - s.offset + s.day_start - 1);
const res: Date = .{
.year = self.year,
.month = s.month,
.day = day,
};
return res;
}
}
return base.Err.DoyNotFound;
}
fn norm(self: DoyDate, cal: *const base.Cal) base.Err!DoyDate {
var doy_done: u16 = 0;
var year: i32 = self.year;
while (true) {
const leap = isLeap(year, cal);
const doy_sum = try add(u16, doy_done, gen.yearLen(leap, cal));
if (doy_sum >= self.doy) {
//doy_done never exceeds d.doy.
//That makes it slightly easier to determine the result.
//Use >= for 1-based doy, > for 0-based doy.
break;
} else {
year = try add(i32, year, 1);
doy_done = doy_sum;
}
}
return DoyDate{ .year = year, .doy = self.doy - doy_done };
}
fn toYearStartMjdCommon(self: DoyDate, cal: *const base.Cal) base.Err!i32 {
const year = self.year;
const lc = cal.*.leap_cycle;
//Let's make some assumptions about good calendars.
if (lc.year_count <= lc.leap_year_count) {
return base.Err.BadCalendar;
}
if (lc.common_days <= lc.leap_days) {
return base.Err.BadCalendar;
}
const off_year = try sub(i32, year, 1 + lc.offset_years);
const common_days = try mul(i32, off_year, lc.common_days);
const f_leap_quot = @divFloor(off_year, @intCast(i32, lc.year_count));
//At this point, we know off_year * lc.common_days hasn't overflowed.
//And we also have our assumptions about good calendars.
//Since leap years are less common than common years,
//and leap days are less common than common days,
//we can assume calculating the leap days shouldn't overflow.
var leap_days: i32 = @intCast(i32, lc.leap_year_count) * @intCast(i32, f_leap_quot) * @intCast(i32, lc.leap_days);
if (lc.skip4000) {
const f_4000_quot = @divFloor(off_year, 4000);
leap_days -= (f_4000_quot * @intCast(i32, lc.leap_days));
}
if (lc.skip100) {
const f_400_quot = @divFloor(off_year, 400);
leap_days += (f_400_quot * @intCast(i32, lc.leap_days));
const f_100_quot = @divFloor(off_year, 100);
leap_days -= (f_100_quot * @intCast(i32, lc.leap_days));
}
const off_days = try add(i32, common_days, leap_days);
const total_days = try add(i32, off_days, lc.offset_days);
return add(i32, total_days, cal.*.epoch_mjd - 1);
}
fn toYearStartMjdSymmetric(self: DoyDate, cal: *const base.Cal) base.Err!i32 {
const lc = cal.*.leap_cycle;
const E = self.year - 1;
const common_days = try mul(i32, E, lc.common_days);
const leap_num = @intCast(i32, lc.leap_year_count) * E - @intCast(i32, lc.offset_years);
const leap_quot = @divFloor(leap_num, lc.year_count);
const leap_days = lc.leap_days * leap_quot;
const total_days = try add(i32, common_days, leap_days);
return add(i32, total_days, cal.*.epoch_mjd - 1);
}
fn toMjd(self: DoyDate, cal: *const base.Cal) base.Err!i32 {
var year_start_mjd: i32 = 0;
const lc = cal.*.leap_cycle;
if (lc.leap_year_count > 1) {
if (lc.symmetric) {
year_start_mjd = try self.toYearStartMjdSymmetric(cal);
} else {
return base.Err.BadCalendar;
}
} else {
year_start_mjd = try self.toYearStartMjdCommon(cal);
}
return add(i32, year_start_mjd, self.doy);
}
fn fromMjdSymmetric(mjd: i32, cal: *const base.Cal) base.Err!DoyDate {
//Based on http://individual.utoronto.ca/kalendis/Symmetry454-Arithmetic.pdf
//FixedToSymYear
//Most differences are caused by trying to convert to integer math.
const lc = cal.*.leap_cycle;
const day_shifted: i64 = @intCast(i64, mjd) - @intCast(i64, cal.*.epoch_mjd);
const num: i64 = @intCast(i64, lc.year_count) * day_shifted;
const total_cycle = daysInCycle(cal);
var y64: i64 = @divFloor(num, total_cycle);
if (@mod(num, total_cycle) != 0) {
y64 += 1;
}
if (y64 > std.math.maxInt(i32) or y64 < std.math.minInt(i32)) {
return base.Err.Overflow;
}
const estimate = DoyDate{ .year = @intCast(i32, y64), .doy = 1 };
const estimate_start_mjd = (try estimate.toYearStartMjdSymmetric(cal)) + 1;
var sym = estimate;
var start_mjd = estimate_start_mjd;
if (estimate_start_mjd < mjd) {
if ((mjd - estimate_start_mjd) >= gen.yearLen(false, cal)) {
const next_year = DoyDate{ .year = estimate.year + 1, .doy = 1 };
const next_start_mjd = (try next_year.toYearStartMjdSymmetric(cal)) + 1;
if (next_start_mjd <= mjd) {
sym = next_year;
start_mjd = next_start_mjd;
}
}
} else if (estimate_start_mjd > mjd) {
const prev_year = DoyDate{ .year = estimate.year - 1, .doy = 1 };
const prev_start_mjd = (try prev_year.toYearStartMjdSymmetric(cal)) + 1;
sym = prev_year;
start_mjd = prev_start_mjd;
}
const final_doy = mjd - start_mjd + 1;
if (final_doy < 1) {
return base.Err.BadCalendar;
}
if (final_doy > gen.yearLen(isLeap(sym.year, cal), cal)) {
return base.Err.BadCalendar;
}
return DoyDate{ .year = sym.year, .doy = @intCast(u16, final_doy) };
}
fn fromMjdCommon(mjd: i32, cal: *const base.Cal) base.Err!DoyDate {
//Based on "Calendrical Calculations: The Ultimate Edition"
//Chapters 1 and 2
//Most differences are caused by generalizing across calendars.
const lc = cal.*.leap_cycle;
const day_shifted = try sub(i32, mjd, cal.*.epoch_mjd);
const day_total = try sub(i32, day_shifted, lc.offset_days);
var f_4000 = YearCycle{};
var f_400 = YearCycle{};
var f_100 = YearCycle{};
if (lc.skip4000) {
f_4000 = YearCycle.cycle(day_total, 4000, 1000 - 31, cal);
} else {
f_4000.rem = day_total;
}
if (lc.skip100) {
f_400 = YearCycle.cycle(f_4000.rem, 400, 100 - 3, cal);
f_100 = YearCycle.cycle(f_400.rem, 100, ((100 / lc.year_count) - 1), cal);
} else {
f_100.rem = day_total;
}
const f_cycle = YearCycle.leapCycle(f_100.rem, cal);
const f_common = YearCycle.cycle(f_cycle.rem, 1, 0, cal);
var res: DoyDate = .{ .year = 0, .doy = 0 };
res.year = f_4000.prod() + f_400.prod() + f_100.prod() + f_cycle.prod() + f_common.prod();
res.year += lc.offset_years;
if (f_100.count == lc.year_count or f_common.count == lc.year_count) {
res.doy = gen.yearLen(true, cal);
} else {
res.year += 1;
res.doy = @intCast(u16, f_common.rem + 1);
}
return res;
}
fn fromMjd(mjd: i32, cal: *const base.Cal) base.Err!DoyDate {
const lc = cal.*.leap_cycle;
if (lc.leap_year_count > 1) {
if (lc.symmetric) {
return DoyDate.fromMjdSymmetric(mjd, cal);
} else {
return base.Err.BadCalendar;
}
} else {
return DoyDate.fromMjdCommon(mjd, cal);
}
}
};
//Public functions
pub fn validYmd(cal: *const base.Cal, year: i32, month: u8, day: u8) bool {
const d = Date{ .year = year, .month = month, .day = day };
if (d.valid_year(cal)) {
return d.noYzToYz(cal).valid_assume_yz(cal);
} else {
return false;
}
}
pub fn mjdFromYmd(cal: *const base.Cal, year: i32, month: u8, day: u8) base.Err!i32 {
const d = Date{ .year = year, .month = month, .day = day };
const d_norm = try d.noYzToValidYz(cal);
const d_doy = try d_norm.toDoy(cal);
return try d_doy.toMjd(cal);
}
pub fn mjdFromDayOfYear(cal: *const base.Cal, year: i32, doy: u16) base.Err!i32 {
const d = Date{ .year = year, .month = 0, .day = 0 };
const d_norm = try d.noYzToValidYz(cal);
const d_doy = DoyDate{ .year = d_norm.year, .doy = doy };
return try d_doy.toMjd(cal);
}
pub fn mjdFromC99Tm(cal: *const base.Cal, raw_tm: *const anyopaque) base.Err!i32 {
const tm = @ptrCast(*const C99Tm, @alignCast(@alignOf(C99Tm), raw_tm));
if (tm.*.tm_mday < 1 or tm.*.tm_mday > maxInt(u8)) {
return base.Err.Overflow;
}
if (tm.*.tm_mon < 0 or tm.*.tm_mon > maxInt(u8)) {
return base.Err.Overflow;
}
if (tm.*.tm_year < minInt(i32) or tm.*.tm_year > maxInt(i32)) {
return base.Err.Overflow;
}
const day = @intCast(u8, tm.*.tm_mday);
const month = @intCast(u8, tm.*.tm_mon + 1);
const year = @intCast(i32, tm.*.tm_year + 1900);
return try mjdFromYmd(cal, year, month, day);
}
pub fn mjdFromUnix(unix: i64) base.Err!i32 {
const unix_days = @divFloor(unix, 24 * 60 * 60);
if (unix_days > maxInt(i32) or unix_days < minInt(i32)) {
return base.Err.Overflow;
}
const unix_days_32 = @intCast(i32, unix_days);
return add(i32, unix_days_32, UNIX_EPOCH_IN_MJD);
}
pub fn mjdFromRd(rd: i32) base.Err!i32 {
return add(i32, rd, RD_EPOCH_IN_MJD);
}
pub fn mjdToYmd(
mjd: i32,
cal: *const base.Cal,
raw_year: ?*i32,
raw_month: ?*u8,
raw_day: ?*u8,
) base.Err!void {
const doy = try DoyDate.fromMjd(mjd, cal);
const res_yz = try doy.toMonthDay(cal);
const d = res_yz.yzToNoYz(cal);
if (raw_year) |year| {
year.* = d.year;
}
if (raw_month) |month| {
month.* = d.month;
}
if (raw_day) |day| {
day.* = d.day;
}
}
pub fn mjdToC99Tm(mjd: i32, cal: *const base.Cal, tm: *anyopaque) base.Err!void {
const doy = try DoyDate.fromMjd(mjd, cal);
const d_yz = try doy.toMonthDay(cal);
const d = d_yz.yzToNoYz(cal);
const weekday = try mjdToDayOfWeek(mjd, cal);
var output_c99_tm = @ptrCast(*C99Tm, @alignCast(@alignOf(C99Tm), tm));
output_c99_tm.*.tm_sec = 0;
output_c99_tm.*.tm_min = 0;
output_c99_tm.*.tm_hour = 0;
output_c99_tm.*.tm_mday = @intCast(c_int, d.day);
output_c99_tm.*.tm_mon = @intCast(c_int, d.month - 1);
output_c99_tm.*.tm_year = @intCast(c_int, d.year - 1900);
output_c99_tm.*.tm_wday = @intCast(c_int, @mod(weekday, cal.*.week.length));
output_c99_tm.*.tm_yday = doy.doy - 1;
output_c99_tm.*.tm_isdst = 0;
}
pub fn mjdToUnix(mjd: i32) base.Err!i64 {
const unix_days = try sub(i64, mjd, UNIX_EPOCH_IN_MJD);
return 24 * 60 * 60 * unix_days;
}
pub fn mjdToRd(mjd: i32) base.Err!i32 {
return sub(i32, mjd, RD_EPOCH_IN_MJD);
}
pub fn mjdToIsLeapYear(mjd: i32, cal: *const base.Cal) base.Err!bool {
const doy = try DoyDate.fromMjd(mjd, cal);
const d_yz = try doy.toMonthDay(cal);
return isLeap(d_yz.year, cal);
}
pub fn mjdToDayOfWeek(mjd: i32, cal: *const base.Cal) base.Err!u8 {
const w = cal.*.week;
if (w.continuous) {
const f_week_rem = @mod(mjd, w.length);
const shifted_f_week_rem = f_week_rem + @enumToInt(base.Weekday7.Wednesday);
const res = clockModulo(@intCast(i32, shifted_f_week_rem), w.length);
return @intCast(u8, res);
} else {
const doy = try DoyDate.fromMjd(mjd, cal);
const d = try doy.toMonthDay(cal);
if (gen.seekIc(d.month, d.day, cal)) |_| {
return @enumToInt(base.Weekday7.NoWeekday);
}
const f_week_rem = @mod(d.day, w.length);
const shifted_f_week_rem = f_week_rem + w.start - 1;
const res = clockModulo(@intCast(i32, shifted_f_week_rem), w.length);
return @intCast(u4, res);
}
}
pub fn mjdToDayOfYear(mjd: i32, cal: *const base.Cal) base.Err!u16 {
const doy = try DoyDate.fromMjd(mjd, cal);
return doy.doy;
}
pub fn addMonths(mjd: i32, cal: *const base.Cal, offset: i32) base.Err!i32 {
if (offset == 0) {
return mjd;
}
const doy = try DoyDate.fromMjd(mjd, cal);
const d_yz = try doy.toMonthDay(cal);
const skipped_d = try d_yz.skipIntercalary(cal);
if (cal.common_month_max != cal.leap_month_max) {
return base.Err.BadCalendar;
}
const month_max = cal.common_month_max;
const month_sum = try add(i32, skipped_d.month, offset);
const year_shift = @divFloor((month_sum - 1), month_max); //-1 in case month_sum == month_max
const rolled_d: Date = .{
.year = try add(i32, skipped_d.year, year_shift),
.month = @intCast(u8, clockModulo(month_sum, month_max)),
.day = skipped_d.day,
};
const res_yz = try rolled_d.norm(cal);
const res_doy = try res_yz.toDoy(cal);
return try res_doy.toMjd(cal);
}
pub fn addYears(mjd: i32, cal: *const base.Cal, offset: i32) base.Err!i32 {
if (offset == 0) {
return mjd;
}
const doy = try DoyDate.fromMjd(mjd, cal);
const d_yz = try doy.toMonthDay(cal);
var y = try add(i32, d_yz.year, offset);
const rolled_d = Date{ .year = y, .month = d_yz.month, .day = d_yz.day };
if (rolled_d.valid_assume_yz(cal)) {
const res_doy = try rolled_d.toDoy(cal);
return try res_doy.toMjd(cal);
} else {
const skipped_d = try rolled_d.skipIntercalary(cal);
const norm_day = try skipped_d.norm(cal);
const res_doy = try norm_day.toDoy(cal);
return try res_doy.toMjd(cal);
}
}
pub fn diffMonths(mjd0: i32, mjd1: i32, cal: *const base.Cal) base.Err!i32 {
const doy0 = try DoyDate.fromMjd(mjd0, cal);
const doy1 = try DoyDate.fromMjd(mjd1, cal);
const d0_norm = try doy0.toMonthDay(cal);
const d1_norm = try doy1.toMonthDay(cal);
const d0_skip = try d0_norm.skipIntercalary(cal);
const d1_skip = try d1_norm.skipIntercalary(cal);
if (cal.common_month_max != cal.leap_month_max) {
return base.Err.BadCalendar;
}
const y_diff = try sub(i32, d0_skip.year, d1_skip.year);
const m_diff = @intCast(i32, d0_skip.month) - @intCast(i32, d1_skip.month);
const d_diff = @intCast(i32, d0_skip.day) - @intCast(i32, d1_skip.day);
const month_max = @intCast(i32, cal.common_month_max);
const y_diff_to_m = try mul(i32, y_diff, month_max);
const ym_diff = try add(i32, y_diff_to_m, m_diff);
const modifier = diffModifier(ym_diff, d_diff);
const res = try add(i32, ym_diff, modifier);
return res;
}
pub fn diffYears(mjd0: i32, mjd1: i32, cal: *const base.Cal) base.Err!i32 {
const doy0 = try DoyDate.fromMjd(mjd0, cal);
const doy1 = try DoyDate.fromMjd(mjd1, cal);
const y_diff = try sub(i32, doy0.year, doy1.year);
const d0 = try doy0.toMonthDay(cal);
const d1 = try doy1.toMonthDay(cal);
const segments = cal.*.leap_lookup_list;
const adjusted0 = try d0.toDoyFromSegments(segments);
const adjusted1 = try d1.toDoyFromSegments(segments);
const d_diff = @intCast(i32, adjusted0.doy) - @intCast(i32, adjusted1.doy);
const modifier = diffModifier(y_diff, d_diff);
const res = try add(i32, y_diff, modifier);
return res;
} | src/logic.zig |
const std = @import("std");
pub const c = @import("pdpanel.zig");
pub const chars = @import("chars.zig");
pub const colors = @import("color.zig");
pub const mouse = @import("mouse.zig");
pub const keys = @import("keys.zig");
pub const attrib = @import("attrib.zig");
pub const AttrChar = c.chtype;
pub const char_size = @bitSizeOf(AttrChar);
pub const CursorVisibility = enum(i32) {
invisible = 0,
normal = 1,
emphasized = 2,
};
// Sets when initScr runs
pub var std_scr:Window = undefined;
var global_alloc:*std.mem.Allocator = undefined;
pub var panel_cache:std.AutoHashMap(usize, *Panel) = undefined;
pub const Border = struct {
char_l:AttrChar = chars.vline,
char_r:AttrChar = chars.vline,
@"char_t":AttrChar = chars.hline,
char_b:AttrChar = chars.hline,
char_tl:AttrChar = chars.ulcorner,
char_tr:AttrChar = chars.urcorner,
char_bl:AttrChar = chars.llcorner,
char_br:AttrChar = chars.lrcorner,
};
pub const Position = struct { x:i32 = -1, y:i32 = -1 };
pub const MouseEvent = struct {
const Self = @This();
id:i8,
x:i32,
y:i32,
z:i32,
bstate:u32,
// COULD PROBABLY USE OFFSET MATH HERE, but jic call them as is in case
// the library changes (one in a million chance)
pub fn buttPress(self:Self,button:u8) bool {
return switch(button) {
1 => return self.bstate & mouse.butt1_press,
2 => return self.bstate & mouse.butt2_press,
3 => return self.bstate & mouse.butt3_press,
4 => return self.bstate & mouse.butt4_press,
5 => return self.bstate & mouse.butt5_press,
else => false,
};
}
pub fn buttRelease(self:Self,button:u8) bool {
return switch(button) {
1 => return self.bstate & mouse.butt1_release,
2 => return self.bstate & mouse.butt2_release,
3 => return self.bstate & mouse.butt3_release,
4 => return self.bstate & mouse.butt4_release,
5 => return self.bstate & mouse.butt5_release,
else => false,
};
}
pub fn buttClick(self:Self,button:u8) bool {
return switch(button) {
1 => return self.bstate & mouse.butt1_click,
2 => return self.bstate & mouse.butt2_click,
3 => return self.bstate & mouse.butt3_click,
4 => return self.bstate & mouse.butt4_click,
5 => return self.bstate & mouse.butt5_click,
else => false,
};
}
pub fn buttDoubleClick(self:Self,button:u8) bool {
return switch(button) {
1 => return self.bstate & mouse.butt1_double_click,
2 => return self.bstate & mouse.butt2_double_click,
3 => return self.bstate & mouse.butt3_double_click,
4 => return self.bstate & mouse.butt4_double_click,
5 => return self.bstate & mouse.butt5_double_click,
else => false,
};
}
pub fn buttTripleClick(self:Self,button:u8) bool {
return switch(button) {
1 => return self.bstate & mouse.butt1_triple_click,
2 => return self.bstate & mouse.butt2_triple_click,
3 => return self.bstate & mouse.butt3_triple_click,
4 => return self.bstate & mouse.butt4_triple_click,
5 => return self.bstate & mouse.butt5_triple_click,
else => false,
};
}
// This probably is incorrect, couldn't find good docs
pub fn mouseScroll(self:Self) bool {
return self.bstate & mouse.mouse_wheel_scroll;
}
// butt shift ctrl alt / mod shift ctrl alt?
pub fn transform(window:?Window) !Position {
var pos = Position{};
if(window) |win| {
if(!c.wmouse_trafo(win.ptr,pos.x,pos.y,true)) return error.InvalidCoordinates;
} else {
if(!c.mouse_trafo(pos.x,pos.y,true)) return error.InvalidCoordinates;
}
return pos;
}
};
// Window restructuring, basically just calls the w-type fns
// Some added funtionality with borders, not fully implemented
pub const Window = struct {
const Self = @This();
ptr:[*c]c.WINDOW = null,
bord:?Border = null,
height:i32 = 0,
width:i32 = 0,
row:i32 = 0,
col:i32 = 0,
derived:bool = false,
//border_chars:[]const u8 = "\u2502\u2502\u2500\u2500\u250c\u2510\u2514\u2518",
pub fn init(height:i32,width:i32,row:i32,col:i32) Self {
var nwin = Window{
.height = height,
.width = width,
.row = row,
.col = col,
};
nwin.ptr = c.newwin(height,width,row,col);
return nwin;
}
pub fn deinit (self:*Self) void {
_=c.delwin(self.ptr);
}
/// Shorthand for creating a border,
pub fn box(self:Self,vert_ch:AttrChar,horiz_ch:AttrChar) void {
_=c.box(self.ptr,vert_ch,horiz_ch);
}
/// Draws a border for the window
pub fn border(
self:Self,
char_l:AttrChar, char_r:AttrChar, char_t:AttrChar, char_b:AttrChar,
char_tl:AttrChar, char_tr:AttrChar, char_bl:AttrChar, char_br:AttrChar
) void {
_=c.wborder(self.ptr,char_l,char_r,char_t,char_b,char_tl,char_tr,char_bl,char_br);
}
/// Like border, but takes an 8-character
/// string instead of 8 params
pub fn borderString(self:Self,string:[]const u8) void {
_=c.wborder(self.ptr,string[0],string[1],string[2],string[3],string[4],string[5],string[6],string[7]);
}
/// Shorthand to erase the window border
pub fn borderZap(self:Self) void {
self.borderString(self.ptr," ");
}
pub fn setBorder (self:*Self,bord:Border) void {
self.bord = bord;
self.border(bord.char_l,bord.char_r,bord.char_t,bord.char_b,
bord.char_tl,bord.char_tr,bord.char_bl,bord.char_br);
}
// vline, hline, mvvline, mvhline
pub fn vline(self:Self,char:AttrChar,len:i32) void {
_=c.wvline(self.ptr,char,len);
}
pub fn hline(self:Self,char:AttrChar,len:i32) void {
_=c.whline(self.ptr,char,len);
}
pub fn mvVline(self:Self,row:i32,col:i32,char:AttrChar,len:i32) void {
_=c.mvwvline(self.ptr,row,col,char,len);
}
pub fn mvHline(self:Self,row:i32,col:i32,char:AttrChar,len:i32) void {
_=c.mvwhline(self.ptr,row,col,char,len);
}
pub fn addCh (self:Self,char:AttrChar) void {
_=c.waddch(self.ptr,char);
}
/// Copy string to cursor pos, do not move cursor,
/// Does not overflow line, truncates
pub fn addChStr(self:Self,string:[]const AttrChar) void {
_=c.waddchstr(self.ptr,string.ptr);
}
/// See addChStr, but only n chars (-1 for whole string)
pub fn addChStrLen(self:Self,string:[]const AttrChar,len:i32) void {
_=c.waddchnstr(self.ptr,string.ptr,len);
}
pub fn mvAddCh(self:Self,row:i32,col:i32,char:AttrChar) void {
_=c.mvwaddch(self.ptr,row,col,char);
}
/// Copy string to pos, do not move cursor,
/// Does not overflow line, truncates
pub fn mvAddChStr(self:Self,row:i32,col:i32,string:[]const AttrChar) void {
_=c.mvwaddchstr(self.ptr,row,col,string.ptr);
}
/// See mvAddChStr, but only n chars (-1 for whole string)
pub fn mvAddChStrLen(self:Self,row:i32,col:i32,string:[]const AttrChar,len:i32) void {
_=c.mvwaddchnstr(self.ptr,row,col,string.ptr,len);
}
pub fn background(self:Self,attrs:AttrChar) void {
_=c.wbkgd(self.ptr,attrs);
}
pub fn setBackground(self:Self,attrs:AttrChar) void {
_=c.wbkgdset(self.ptr,attrs);
}
pub fn getBackground(self:Self) AttrChar {
return c.getbkgd(self.ptr);
}
/// Refreshes the window
pub fn refresh(self:Self) void {
_=c.wrefresh(self.ptr);
}
pub fn refreshNoUpdate(self:Self) void {
_=c.wnoutrefresh(self.ptr);
}
pub fn print(self:Self,comptime format:[]const u8,args:anytype) void {
const str = std.fmt.allocPrintZ(std.testing.allocator,format,args) catch unreachable;
_=c.wprintw(self.ptr,str);
std.testing.allocator.free(str);
}
pub fn mvPrint(self:Self,row:i32,col:i32,comptime format:[]const u8,args:anytype) void {
const str = std.fmt.allocPrintZ(std.testing.allocator,format,args) catch unreachable;
_=c.mvwprintw(self.ptr,row,col,str);
std.testing.allocator.free(str);
}
pub fn cursorPos(self:Self) Position {
return .{
.x = c.getcurx(self.ptr),
.y = c.getcury(self.ptr),
};
}
pub fn windowOffset(self:Self) Position {
return .{
.x = c.getparx(self.ptr),
.y = c.getpary(self.ptr),
};
}
pub fn windowBegin(self:Self) Position {
return .{
.x = c.getbegx(self.ptr),
.y = c.getbegy(self.ptr),
};
}
pub fn windowEnd(self:Self) Position {
return .{
.x = c.getmaxx(self.ptr),
.y = c.getmaxy(self.ptr),
};
}
pub fn dumpToFile(self:Self,file:[]const u8) !void {
var c_f = c.fopen(file.ptr,"w");
if(c.putwin(self.ptr,c_f) != c.OK) return error.errorDumpingWindow;
}
// TODO: Look into these, do they change window sizes or anything?
pub fn loadFromFile(self:Self,file:[]const u8) !void {
var c_f = c.fopen(file.ptr,"r");
if(c.getwin(self.ptr,c_f) != c.OK) return error.errorLoadingWindow;
}
pub fn overlay(self:Self,dest:Window) void {
_=c.overlay(self.ptr,dest.ptr);
}
pub fn overwrite(self:Self,dest:Window) void {
_=c.overwrite(self.ptr,dest.ptr);
}
pub fn copyToWindow(
self:Self,dest:Window,
src_row:i32,src_col:i32,
dest_srow:i32,dest_scol:i32,
dest_erow:i32,dest_ecol:i32,
ovrlay:bool
) void {
var ibool:i32 = if(ovrlay) 1 else 0;
_=c.copywin(self.ptr,dest,src_row,src_col,dest_srow,dest_scol,
dest_erow,dest_ecol,ibool);
}
pub fn attrOn (self:Self,attr:AttrChar) void {
_=c.wattr_on(self.ptr,attr,null);
}
pub fn attrOff (self:Self,attr:AttrChar) void {
_=c.wattr_off(self.ptr,attr,null);
}
pub fn attrSet (self:Self,attr:AttrChar) void {
_=c.wattr_set(self.ptr,attr,null);
}
const Style = struct { colors:?ColorPair, attr:?AttrChar };
pub fn attrGet (self:Self) Style {
var cchar:AttrChar = undefined;
var cpid:[*c]c_short = null;
_=c.wattr_get(self.ptr,&cchar,cpid,null);
if(cpid) |cid| {
return .{ .colors = ColorPair.getPair(cid.*), .attr = cchar };
} else {
return .{ .colors = null, .attr = cchar };
}
}
pub fn colorSet(self:Self,id:i16,) void {
_=c.wcolor_set(self.ptr, id, null);
}
/// num_chars of -1 is till EoL
pub fn changeAt(self:Self,num_chars:i32,attr:AttrChar,color:ColorPair) void {
_=c.wchgat(self.ptr,num_chars,attr,color.attr(),null);
}
pub fn mvChangeAt(self:Self,row:i32,col:i32,num_chars:i32,attr:AttrChar,color:ColorPair) void {
_=c.mvwchgat(self.ptr,row,col,num_chars,attr,color.attr(),null);
}
pub fn clear(self:Self) void { _=c.wclear(self.ptr); }
pub fn clearToBottom(self:Self) void { _=c.wclrtobot(self.ptr); }
pub fn clearToEol(self:Self) void { _=c.wclrtoeol(self.ptr); }
pub fn move(self:*Self,row:i32,col:i32) void {
self.row = row;
self.col = col;
_=c.mvwin(self.ptr,row,col);
}
pub fn subWindow (self:Self,num_rows:i32,num_cols:i32,row:i32,col:i32) Window {
return .{
.ptr = c.subwin(self.ptr, num_rows, num_cols, row, col),
.height = num_rows,
.width = num_cols,
.row = row,
.col = col,
.derived = true,
};
}
pub fn subWindowRel (self:Self,num_rows:i32,num_cols:i32,row:i32,col:i32) Window {
return subWindow(self,num_rows,num_cols,row + self.row,col + self.col);
}
pub fn moveDerived (self:Self,row:i32,col:i32) void {
if(!self.derived) return;
_=c.mvderwin(self, row, col);
}
pub fn duplicate(self:Self) Window {
return .{
.ptr = c.dupwin(self.ptr),
.width = self.width,
.height = self.height,
.row = self.row,
.col = self.col,
.derived = self.derived,
};
}
pub fn cursorSyncUp (self:Self) void { _=c.wcursyncup(self.ptr); }
pub fn syncUp (self:Self) void { _=c.wsyncup(self.ptr); }
pub fn syncOk (self:Self,autosync:bool) void {
_=c.wsyncok(self.ptr,autosync);
}
pub fn syncDown (self:Self) void { _=c.wsyncdown(self.ptr); }
pub fn deleteChar (self:Self) void { _=c.wdelch(self.ptr); }
pub fn deleteLine (self:Self) void { _=c.wdeleteln(self.ptr); }
pub fn erase (self:Self) void { _=c.werase(self.ptr); }
};
pub const Panel = struct {
const Self = @This();
ptr:[*c]c.PANEL = null,
window:*Window = undefined,
// Static fns
/// Creates a new panel from a window and puts
/// it at the top of the stack
pub fn init(win:*Window) Self {
var new = Self{};
new.ptr = c.new_panel(win.ptr);
new.window = win;
return new;
}
// Have to manually register for now
pub fn register (self:*Self) void {
panel_cache.put(@ptrToInt(self.ptr),self) catch unreachable;
}
pub fn unregister (self:*Self) void {
_=panel_cache.remove(@ptrToInt(self.ptr));
}
pub fn update() void {
_=c.update_panels();
}
// Member fns
pub fn delete(self:*Self) void {
_=c.del_panel(self.ptr);
self.ptr = null;
}
pub fn hide(self:*Self) void {
_=c.hide_panel(self.ptr);
}
pub fn show(self:*Self) void {
_=c.show_panel(self.ptr);
}
pub fn toTop(self:*Self) void {
_=c.top_panel(self.ptr);
}
pub fn toBottom(self:*Self) void {
_=c.bottom_panel(self.ptr);
}
pub fn move(self:*Self,start_y:i32,start_x:i32) void {
_=c.move_panel(self.ptr, start_y, start_x);
}
pub fn replaceWindow(self:*Self,win:Window) void {
_=c.replace_panel(self.ptr, win.ptr);
}
// How do we return our panel??? Cache the pointers and do a lookup?
//pub fn panelAbove(self:*Self) [*c]c.PANEL {
// return c.panel_above(self.ptr);
//}
pub fn panelAbove(self:*Self) ?*Panel {
if(c.panel_above(self.ptr)) |ptr| {
return panel_cache.get(@ptrToInt(ptr));
}
return null;
}
// How do we return our panel??? Cache the pointers and do a lookup?
//pub fn panelBelow(self:*Self) [*c]c.PANEL {
// return c.panel_below(self.ptr);
//}
pub fn panelBelow(self:*Self) ?*Panel {
if(c.panel_below(self.ptr)) |ptr| {
return panel_cache.get(@ptrToInt(ptr));
}
return null;
}
pub fn setUserPtr(self:Self,comptime T:type,ptr:*const T) void {
_=c.set_panel_userptr(self.ptr,ptr);
}
pub fn getUserPtr(self:Self,comptime T:type) ?*const T {
return @ptrCast(*const T,@alignCast(@alignOf(T),c.panel_userptr(self.ptr)));
//return @intToPtr(*const T,@ptrToInt(c.panel_userptr(self.ptr)));
}
};
pub const Color = struct { r:i16 = 0, g:i16 = 0, b:i16 = 0 };
pub const ColorPair = struct {
const Self = @This();
id:i16,
fg_color:i16,
bg_color:i16,
////////////////// Static fns
pub fn init(id:i16,fg_color:i16,bg_color:i16) Self {
_=c.init_pair(id,fg_color,bg_color);
return .{
.id = id,
.fg_color = fg_color,
.bg_color = bg_color,
};
}
// replaces pair_content
pub fn getPair (id:i16) Self {
var new = Self{ .id = id, .fg_color = -1, .bg_color = -1 };
_=c.pair_content(id, &new.fg_color, &new.bg_color);
return new;
}
////////////////// Member fns
pub fn colorContent(self:Self) Color {
var new = Color{};
_=c.color_content(self.id, [*c]new.r, [*c]new.g, [*c]new.b);
return new;
}
pub fn attr(self:*Self) AttrChar {
return @as(AttrChar,(@intCast(AttrChar,self.id) << c.PDC_COLOR_SHIFT) & c.A_COLOR);
}
};
pub fn initScr (allocator:*std.mem.Allocator) void {
global_alloc = allocator;
panel_cache = std.AutoHashMap(usize, *Panel).init(global_alloc);
_=c.initscr();
std_scr = Window {
.ptr = c.stdscr,
.width = c.getmaxx(c.stdscr),
.height = c.getmaxy(c.stdscr),
};
}
pub fn refresh() void { _=c.refresh(); }
pub fn startColor () void { _=c.start_color(); }
pub fn useDefaultColors () void { _=c.use_default_colors(); }
pub fn cBreak () void { _=c.cbreak(); }
pub fn echo () void { _=c.echo(); }
pub fn noEcho () void { _=c.noecho(); }
pub fn endWin () void { _=c.endwin(); }
pub fn halfDelay(tenths_sec:i32) void { _=c.halfdelay(tenths_sec); }
pub fn napForMs(ms:i32) void { _=c.napms(ms); }
pub fn defProgMode() void { _=c.def_prog_mode(); }
pub fn defShellMode() void { _=c.def_shell_mode(); }
pub fn resetProgMode() void { _=c.reset_prog_mode(); }
pub fn resetShellMode() void { _=c.reset_shell_mode(); }
pub fn saveTty() void { _=c.savetty(); }
pub fn resetTty() void { _=c.resetty(); }
pub fn doUpdate() void { _=c.doupdate(); }
pub fn attrOn (attr:AttrChar) void {
_=c.attron(attr);
}
pub fn attrOff (attr:AttrChar) void {
_=c.attroff(attr);
}
pub fn getCh() i32 {
return c.getch();
}
pub fn addCh (ch:AttrChar) void { _=c.addch(ch); }
pub fn mvAddCh (row:i32,col:i32,ch:AttrChar) void { _=c.mvaddch(row,col,ch); }
/// Copy string to cursor pos, do not move cursor,
/// Does not overflow line, truncates
pub fn addChStr(string:[]const u8) void {
_=c.addchstr(string.ptr);
}
/// See addChStr, but only n chars (-1 for whole string)
pub fn addChStrLen(string:[]const u8,len:i32) void {
_=c.addchnstr(string.ptr,len);
}
/// Copy string to pos, do not move cursor,
/// Does not overflow line, truncates
pub fn mvAddChStr(row:i32,col:i32,string:[]const u8) void {
_=c.mvaddchstr(row,col,string.ptr);
}
/// See mvAddChStr, but only n chars (-1 for whole string)
pub fn mvAddChStrLen(row:i32,col:i32,string:[]const u8,len:i32) void {
_=c.mvaddchnstr(row,col,string.ptr,len);
}
pub fn backgroundColor(color_attr:AttrChar) void {
_=c.bkgd(color_attr);
}
pub fn hasColors() bool {
return c.has_colors();
}
pub fn canChangeColor() bool {
return c.can_change_color();
}
pub fn keypad(win:Window,enable:bool) void {
_=c.keypad(win.ptr,enable);
}
/// Modifies a color index (see color.*), color values are 0-1000
pub fn initColor(id:i16,r:i16,g:i16,b:i16) void {
_=c.init_color(id,r,g,b);
}
pub fn clrToEol () void { _=c.clrtoeol(); }
pub fn clrToBottom () void { _=c.clrtobot(); }
/// Returns the mask with valid masks
/// Returns 0 if none were valid
pub fn mouseMask(mask:u32,old_mask:*?u32) u32 {
return c.mousemask(mask,old_mask);
}
pub fn hasMouse() bool { return c.has_mouse(); }
pub fn getMouse() ?MouseEvent {
var evt:c.MEVENT = undefined;
if(c.getmouse(&evt) == c.OK) {
return .{
.id = evt.id,
.x = evt.x,
.y = evt.y,
.z = evt.z,
.bstate = evt.bstate,
};
} else return null;
}
/// Basically shorthand for std_scr.cursorPosition()
pub fn getYX () Position {
// The macros are broken in translate-c, so whatever
return std_scr.cursorPos();
}
pub fn screenDump(file:[]const u8) !void {
if(c.scr_dump(file.ptr) != c.OK) return error.UnableToDumpScreen;
}
// TODO: Look into these, what does curses fill out behind the scenes?
// We need to duplicate it with our structures to keep Window in sync
pub fn screenRestore(file:[]const u8) !void {
if(c.scr_restore(file.ptr) != c.OK) return error.UnableToRestoreScreen;
}
pub fn screenInitFromFile(file:[]const u8) !void {
if(c.scr_restore(file.ptr) != c.OK) return error.UnableToRestoreScreen;
}
pub fn setCursor (vis:CursorVisibility) void {
_=c.curs_set(@enumToInt(vis));
}
pub fn u8to64 (string:[]const u8,attr:AttrChar) []const AttrChar {
var bytes:[512]AttrChar = .{0} ** 512;
var i:usize = 0;
while(i < string.len) : (i += 1) {
bytes[i] = string[i] | attr;
}
return bytes[0..string.len];
} | src/zig-pdcurses.zig |
const std = @import("std");
const lib = @import("lib.zig");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const types = lib.types;
const Session = @This();
pub const Setup = extern struct {
release: u32,
resource_id_base: u32,
resource_id_mask: u32,
motion_buffer_size: u32,
length_of_vendor: u16,
maximum_request_length: u16,
number_of_screens: u8,
number_of_formats: u8,
image_byte_order: u8,
bitmap_format_bit_order: u8,
bitmap_format_scanline_unit: u8,
bitmap_format_scanline_pad: u8,
min_keycode: u8,
max_keycode: u8,
pad: u32,
pub const Format = extern struct {
depth: u8,
bits_per_pixel: u8,
scanline_pad: u8,
pad: [5]u8 = [_]u8{0} ** 5,
};
pub const Depth = extern struct {
depth: u8,
pad0: u8 = 0,
visuals_length: u16,
pad: [4]u8 = [_]u8{0} ** 4,
};
pub const Visual = extern struct {
visual: types.VisualId,
class: u8,
bits_per_rgb_value: u8,
colormap_entries: u16,
red_mask: u32,
green_mask: u32,
blue_mask: u32,
pad: [4]u8 = [_]u8{0} ** 4,
};
pub const Screen = extern struct {
root: types.Window,
default_colormap: u32,
white_pixel: u32,
black_pixel: u32,
input_mask: u32,
width_pixel: u16,
height_pixel: u16,
width_milimeter: u16,
height_milimiter: u16,
min_maps: u16,
max_maps: u16,
root_visual: types.VisualId,
backing_store: u8,
save_unders: u8,
root_depth: u8,
allowed_depths_length: u8,
};
};
bytes: []align(4) const u8,
pub fn setup(self: Session) *const Setup {
return mem.bytesAsValue(Setup, self.bytes[0..@sizeOf(Setup)]);
}
pub fn vendor(self: Session) []const u8 {
const s = self.setup();
const size = @sizeOf(Setup);
return self.bytes[size .. size + s.length_of_vendor];
}
pub fn formats(self: Session) []const Setup.Format {
const s = self.setup();
const offset = s.length_of_vendor + @sizeOf(Setup);
const len = s.number_of_formats;
return @ptrCast([*]const Screen.Format, &self.bytes[offset])[0..len];
}
pub fn screens(self: Session) ScreenIterator {
const s = self.setup();
const offset = s.length_of_vendor +
@sizeOf(Setup) +
@sizeOf(Setup.Format) *
s.number_of_formats;
return .{
.bytes = self.bytes[offset..],
.remain = s.number_of_screens,
};
}
pub fn depths(self: Session, screen: *const Setup.Screen) DepthIterator {
const offset = @ptrToInt(screen) - @ptrToInt(self.bytes.ptr);
return DepthIterator{
.bytes = self.bytes[offset + @sizeOf(Setup.Screen) ..],
.remain = screen.allowed_depths_length,
};
}
pub fn visuals(self: Session, depth: *const Setup.Depth) []const Setup.Visual {
const offset = @ptrToInt(depth) - @ptrToInt(self.bytes.ptr);
return @ptrCast(
[*]const Setup.Visual,
@alignCast(4, &self.bytes[offset + @sizeOf(Setup.Depth)]),
)[0..depth.visuals_len];
}
pub const ScreenIterator = struct {
bytes: []align(4) const u8,
index: u32 = 0,
remain: u8,
pub fn next(self: *ScreenIterator) ?*const Setup.Screen {
if (self.remain == 0) return null;
defer self.remain -= 1;
const result = @ptrCast(
*const Setup.Screen,
@alignCast(4, &self.bytes[self.index]),
);
var session: Session = .{ .bytes = self.bytes };
var it = session.depths(result);
while (it.next()) |depth| {
self.index += @sizeOf(Setup.Depth) +
depth.visuals_length * @sizeOf(Setup.Visual);
}
return result;
}
};
pub const DepthIterator = struct {
bytes: []align(4) const u8,
index: u32 = 0,
remain: u8,
pub fn next(self: *DepthIterator) ?*const Setup.Depth {
if (self.remain == 0) return null;
defer self.remain -= 1;
const result = @ptrCast(
*const Setup.Depth,
@alignCast(4, &self.bytes[self.index]),
);
self.index += @sizeOf(Setup.Depth) +
result.visuals_length *
@sizeOf(Setup.Visual);
return result;
}
};
pub fn deinit(self: Session, gpa: *Allocator) void {
gpa.free(self.bytes);
} | src/Session.zig |
const std = @import("std");
const zp = @import("zplay");
const dig = zp.deps.dig;
fn init(ctx: *zp.Context) anyerror!void {
std.log.info("game init", .{});
// init imgui
try dig.init(ctx.window);
}
fn loop(ctx: *zp.Context) void {
while (ctx.pollEvent()) |e| {
_ = dig.processEvent(e);
switch (e) {
.keyboard_event => |key| {
if (key.trigger_type == .up) {
switch (key.scan_code) {
.escape => ctx.kill(),
.f1 => ctx.toggleFullscreeen(null),
else => {},
}
}
},
.quit_event => ctx.kill(),
else => {},
}
}
const S = struct {
var f: f32 = 0.0;
var counter: i32 = 0;
var show_demo_window = true;
var show_another_window = true;
var show_plot_demo_window = true;
var show_nodes_demo_window = true;
var clear_color = [4]f32{ 0.45, 0.55, 0.6, 1.0 };
};
ctx.graphics.clear(true, false, false, S.clear_color);
dig.beginFrame();
defer dig.endFrame();
var mouse_state = ctx.getMouseState();
dig.setNextWindowPos(.{
.x = @intToFloat(f32, mouse_state.x + 10),
.y = @intToFloat(f32, mouse_state.y + 10),
}, .{});
if (dig.begin("mouse context", null, dig.c.ImGuiWindowFlags_NoTitleBar)) {
dig.text("You're here!");
}
dig.end();
if (dig.begin("Hello, world!", null, null)) {
dig.text("This is some useful text");
dig.textUnformatted("some useful text");
_ = dig.checkbox("Demo Window", &S.show_demo_window);
_ = dig.checkbox("Another Window", &S.show_another_window);
_ = dig.checkbox("Plot Demo Window", &S.show_plot_demo_window);
_ = dig.checkbox("Nodes Demo Window", &S.show_nodes_demo_window);
_ = dig.sliderFloat("float", &S.f, 0, 1, .{});
_ = dig.colorEdit4("clear color", &S.clear_color, null);
if (dig.button("Button", null))
S.counter += 1;
dig.sameLine(.{});
dig.text("count = %d", S.counter);
}
dig.end();
if (S.show_demo_window) {
dig.showDemoWindow(&S.show_demo_window);
}
if (S.show_another_window) {
if (dig.begin("Another Window", &S.show_another_window, null)) {
dig.text("Hello from another window!");
if (dig.button("Close Me", null))
S.show_another_window = false;
}
dig.end();
}
if (S.show_plot_demo_window) {
dig.ext.plot.showDemoWindow(&S.show_plot_demo_window);
}
if (S.show_nodes_demo_window) {
if (dig.begin("Nodes Demo Window", &S.show_nodes_demo_window, 0)) {
dig.ext.nodes.beginNodeEditor();
dig.ext.nodes.beginNode(-1);
dig.dummy(.{ .x = 80, .y = 45 });
dig.ext.nodes.endNode();
dig.ext.nodes.endNodeEditor();
}
dig.end();
}
}
fn quit(ctx: *zp.Context) void {
_ = ctx;
std.log.info("game quit", .{});
}
pub fn main() anyerror!void {
try zp.run(.{
.initFn = init,
.loopFn = loop,
.quitFn = quit,
.enable_resizable = true,
.enable_maximized = true,
});
} | examples/imgui_demo.zig |
const std = @import("std");
const os = std.os;
const fmt = std.fmt;
const io = std.io;
const dns = @import("dns");
const rdata = dns.rdata;
pub const DNSPacket = dns.Packet;
pub const DNSPacketRCode = dns.ResponseCode;
pub const DNSClass = dns.DNSClass;
const Allocator = std.mem.Allocator;
const mainlib = @import("main.zig");
const MainDNSError = error{
UnknownReplyId,
GotQuestion,
RCodeErr,
};
test "zigdig" {
_ = @import("packet.zig");
_ = @import("proto.zig");
_ = @import("resolvconf.zig");
}
/// Print a slice of DNSResource to stderr.
fn printList(pkt: DNSPacket, resource_list: dns.ResourceList) !void {
// TODO the formatting here is not good...
std.debug.warn(";;name\t\t\trrtype\tclass\tttl\trdata\n");
for (resource_list.items) |resource| {
var pkt_rdata = try rdata.parseRData(pkt, resource, resource.opaque_rdata);
std.debug.warn(
"{}.\t{}\t{}\t{}\t{}\n",
try resource.name.toStr(pkt.allocator),
@tagName(resource.rr_type),
@tagName(resource.class),
resource.ttl,
try rdata.prettyRData(pkt.allocator, pkt_rdata),
);
}
std.debug.warn("\n");
}
/// Print a packet to stderr.
pub fn printPacket(pkt: DNSPacket) !void {
std.debug.warn(
"id: {}, opcode: {}, rcode: {}\n",
pkt.header.id,
pkt.header.opcode,
pkt.header.rcode,
);
std.debug.warn(
"qd: {}, an: {}, ns: {}, ar: {}\n\n",
pkt.header.qdcount,
pkt.header.ancount,
pkt.header.nscount,
pkt.header.arcount,
);
if (pkt.header.qdcount > 0) {
std.debug.warn(";;-- question --\n");
std.debug.warn(";;qname\tqtype\tqclass\n");
for (pkt.questions.items) |question| {
std.debug.warn(
";{}.\t{}\t{}\n",
try question.qname.toStr(pkt.allocator),
@tagName(question.qtype),
@tagName(question.qclass),
);
}
std.debug.warn("\n");
}
if (pkt.header.ancount > 0) {
std.debug.warn(";; -- answer --\n");
try printList(pkt, pkt.answers);
} else {
std.debug.warn(";; no answer\n");
}
if (pkt.header.nscount > 0) {
std.debug.warn(";; -- authority --\n");
try printList(pkt, pkt.authority);
} else {
std.debug.warn(";; no authority\n\n");
}
if (pkt.header.ancount > 0) {
std.debug.warn(";; -- additional --\n");
try printList(pkt, pkt.additional);
} else {
std.debug.warn(";; no additional\n\n");
}
}
/// Sends pkt over a given socket directed by `addr`, returns a boolean
/// if this was successful or not. A value of false should direct clients
/// to follow the next nameserver in the list.
fn resolve(allocator: *Allocator, addr: *std.net.Address, pkt: DNSPacket) !bool {
// TODO this fails on linux when addr is an ip6 addr...
var sockfd = try proto.openDNSSocket();
errdefer std.os.close(sockfd);
var buf = try allocator.alloc(u8, pkt.size());
try proto.sendDNSPacket(sockfd, addr, pkt, buf);
var recvpkt = try proto.recvDNSPacket(sockfd, allocator);
std.debug.warn("recv packet: {}\n", recvpkt.header.repr());
// safety checks against unknown udp replies on the same socket
if (recvpkt.header.id != pkt.header.id) return MainDNSError.UnknownReplyId;
if (!recvpkt.header.qr_flag) return MainDNSError.GotQuestion;
switch (recvpkt.header.rcode) {
.NoError => {
try printPacket(recvpkt);
return true;
},
.ServFail => {
// if SERVFAIL, the resolver should push to the next one.
return false;
},
.NotImpl, .Refused, .FmtError, .NameErr => {
std.debug.warn("response code: {}\n", recvpkt.header.rcode);
return MainDNSError.RCodeErr;
},
else => {
std.debug.warn("unhandled rcode: {}\n", recvpkt.header.rcode);
return false;
},
}
}
/// Make a DNSPacket containing a single question out of the question's
/// QNAME and QTYPE. Both are strings and so are converted to the respective
/// DNSName and DNSType enum values internally.
/// Sets a random packet ID.
pub fn makeDNSPacket(
allocator: *std.mem.Allocator,
name: []const u8,
qtype_str: []const u8,
) !DNSPacket {
var qtype = try dns.DNSType.fromStr(qtype_str);
var pkt = DNSPacket.init(allocator, ""[0..]);
// set random u16 as the id + all the other goodies in the header
var r = std.rand.DefaultPrng.init(std.time.timestamp());
const random_id = r.random.int(u16);
pkt.header.id = random_id;
pkt.header.rd = true;
var question = dns.Question{
.qname = try dns.DNSName.fromString(allocator, name),
.qtype = qtype,
.qclass = DNSClass.IN,
};
try pkt.addQuestion(question);
return pkt;
}
pub fn main() anyerror!void {
var allocator_instance = std.heap.GeneralPurposeAllocator(.{}){};
defer {
_ = allocator_instance.deinit();
}
const allocator = &allocator_instance.allocator;
var stdin = std.io.getStdIn();
var buffer = try allocator.alloc(u8, 1024);
var byte_count = try stdin.reader().read(buffer);
var packet_slice = buffer[0..byte_count];
var pkt = DNSPacket.init(allocator, packet_slice);
var in = dns.FixedStream{ .buffer = packet_slice, .pos = 0 };
var deserializer = dns.DNSDeserializer.init(in.reader());
try deserializer.deserializeInto(&pkt);
try mainlib.printPacket(pkt);
} | src/main_stdin.zig |
const c = @cImport({
@cInclude("cfl_table.h");
});
const widget = @import("widget.zig");
pub const Table = struct {
inner: ?*c.Fl_Table,
pub fn new(x: i32, y: i32, w: i32, h: i32, title: [*c]const u8) Table {
const ptr = c.Fl_Table_new(x, y, w, h, title);
if (ptr == null) unreachable;
return Table{
.inner = ptr,
};
}
pub fn raw(self: *Table) ?*c.Fl_Table {
return self.inner;
}
pub fn fromRaw(ptr: ?*c.Fl_Table) Table {
return Table{
.inner = ptr,
};
}
pub fn fromWidgetPtr(w: widget.WidgetPtr) Table {
return Table{
.inner = @ptrCast(?*c.Fl_Table, w),
};
}
pub fn fromVoidPtr(ptr: ?*c_void) Table {
return Table{
.inner = @ptrCast(?*c.Fl_Table, ptr),
};
}
pub fn toVoidPtr(self: *Table) ?*c_void {
return @ptrCast(?*c_void, self.inner);
}
pub fn asWidget(self: *const Table) widget.Widget {
return widget.Widget{
.inner = @ptrCast(widget.WidgetPtr, self.inner),
};
}
pub fn handle(self: *Table, cb: fn (w: widget.WidgetPtr, ev: i32, data: ?*c_void) callconv(.C) i32, data: ?*c_void) void {
c.Fl_Table_handle(self.inner, @ptrCast(c.custom_handler_callback, cb), data);
}
pub fn draw(self: *Table, cb: fn (w: widget.WidgetPtr, data: ?*c_void) callconv(.C) void, data: ?*c_void) void {
c.Fl_Table_handle(self.inner, @ptrCast(c.custom_draw_callback, cb), data);
}
};
pub const TableRow = struct {
inner: ?*c.Fl_Table_Row,
pub fn new(x: i32, y: i32, w: i32, h: i32, title: [*c]const u8) TableRow {
const ptr = c.Fl_Table_Row_new(x, y, w, h, title);
if (ptr == null) unreachable;
return TableRow{
.inner = ptr,
};
}
pub fn raw(self: *TableRow) ?*c.Fl_Table_Row {
return self.inner;
}
pub fn fromRaw(ptr: ?*c.Fl_Table_Row) TableRow {
return TableRow{
.inner = ptr,
};
}
pub fn fromWidgetPtr(w: widget.WidgetPtr) TableRow {
return TableRow{
.inner = @ptrCast(?*c.Fl_Table_Row, w),
};
}
pub fn fromVoidPtr(ptr: ?*c_void) TableRow {
return TableRow{
.inner = @ptrCast(?*c.Fl_Table_Row, ptr),
};
}
pub fn toVoidPtr(self: *TableRow) ?*c_void {
return @ptrCast(?*c_void, self.inner);
}
pub fn asWidget(self: *const TableRow) widget.Widget {
return widget.Widget{
.inner = @ptrCast(widget.WidgetPtr, self.inner),
};
}
pub fn asTable(self: *const TableRow) Table {
return Table{
.inner = @ptrCast(?*c.Fl_Table, self.inner),
};
}
pub fn handle(self: *TableRow, cb: fn (w: widget.WidgetPtr, ev: i32, data: ?*c_void) callconv(.C) i32, data: ?*c_void) void {
c.Fl_Table_Row_handle(self.inner, @ptrCast(c.custom_handler_callback, cb), data);
}
pub fn draw(self: *TableRow, cb: fn (w: widget.WidgetPtr, data: ?*c_void) callconv(.C) void, data: ?*c_void) void {
c.Fl_Table_Row_handle(self.inner, @ptrCast(c.custom_draw_callback, cb), data);
}
};
test "" {
@import("std").testing.refAllDecls(@This());
} | src/table.zig |
const std = @import("std");
const vertex_shader_source = @embedFile("shaders/vertex.glsl");
const fragment_shader_source = @embedFile("shaders/fragment.glsl");
const windows = @import("window.zig");
const Window = @import("window.zig").Window;
const CompositorOutput = @import("output.zig").CompositorOutput;
const main = @import("main.zig");
const c = @cImport({
@cInclude("GLES3/gl3.h");
@cInclude("EGL/egl.h");
@cInclude("GLES2/gl2ext.h");
});
const egl = @import("backend/drm/egl.zig");
var ortho: [16]f32 = undefined;
var rectangle: [28]f32 = undefined;
pub var PROGRAM: c_uint = undefined;
pub fn clear() !void {
c.glClearColor(0.3, 0.3, 0.36, 0.0);
try checkGLError();
c.glClear(c.GL_COLOR_BUFFER_BIT | c.GL_DEPTH_BUFFER_BIT);
try checkGLError();
}
pub fn render(output: *CompositorOutput) !void {
var width = output.getWidth();
var height = output.getHeight();
c.glUseProgram(PROGRAM);
try checkGLError();
c.glEnable(c.GL_BLEND);
try checkGLError();
c.glBlendFunc(c.GL_SRC_ALPHA, c.GL_ONE_MINUS_SRC_ALPHA);
try checkGLError();
orthographicProjection(&ortho, 0.0, @intToFloat(f32, width), 0.0, @intToFloat(f32, height), -1.0, 1.0);
try setUniformMatrix(PROGRAM, "ortho", ortho);
}
pub fn renderSurface(program: c_uint, texture: u32) !void {
var vbo: u32 = undefined;
c.glGenBuffers(1, &vbo);
try checkGLError();
c.glBindBuffer(c.GL_ARRAY_BUFFER, vbo);
try checkGLError();
c.glBufferData(c.GL_ARRAY_BUFFER, 4 * rectangle.len, &rectangle[0], c.GL_STATIC_DRAW);
try checkGLError();
var vao: u32 = undefined;
c.glGenVertexArrays(1, &vao);
try checkGLError();
c.glBindVertexArray(vao);
try checkGLError();
c.glBindBuffer(c.GL_ARRAY_BUFFER, vbo);
try checkGLError();
try setVertexAttrib(program, "position", 0);
try setVertexAttrib(program, "texcoord", 8);
c.glEnable(c.GL_BLEND);
try checkGLError();
c.glBindVertexArray(vao);
try checkGLError();
c.glBindTexture(c.GL_TEXTURE_2D, texture);
try checkGLError();
c.glDrawArrays(c.GL_TRIANGLES, 0, rectangle.len / 4);
try checkGLError();
c.glDeleteVertexArrays(1, &vao);
try checkGLError();
c.glDeleteBuffers(1, &vbo);
try checkGLError();
}
pub fn init() !void {
PROGRAM = try initShaders();
}
pub fn deinit() void {
c.glDeleteProgram(PROGRAM);
}
fn initShaders() !c_uint {
var vertex_shader = try compileShader(vertex_shader_source, c.GL_VERTEX_SHADER);
var fragment_shader = try compileShader(fragment_shader_source, c.GL_FRAGMENT_SHADER);
var program = c.glCreateProgram();
try checkGLError();
c.glAttachShader(program, vertex_shader);
try checkGLError();
c.glAttachShader(program, fragment_shader);
try checkGLError();
c.glLinkProgram(program);
try checkGLError();
c.glDeleteShader(vertex_shader);
try checkGLError();
c.glDeleteShader(fragment_shader);
try checkGLError();
return program;
}
fn compileShader(source: []const u8, shader_type: c_uint) !c_uint {
var log: [256]u8 = undefined;
var shader = c.glCreateShader(shader_type);
try checkGLError();
c.glShaderSource(shader, 1, &source.ptr, null);
try checkGLError();
c.glCompileShader(shader);
try checkGLError();
var status: i32 = c.GL_TRUE;
c.glGetShaderiv(shader, c.GL_COMPILE_STATUS, &status);
if (status == c.GL_FALSE) {
var log_length: c_int = 0;
c.glGetShaderiv(shader, c.GL_INFO_LOG_LENGTH, &log_length);
try checkGLError();
c.glGetShaderInfoLog(shader, log_length, null, log[0..]);
try checkGLError();
std.debug.warn("log: {any}\n", .{log[0..std.math.min(log.len, @intCast(usize, log_length))]});
return error.FailedToCompileShader;
}
return shader;
}
fn orthographicProjection(m: *[16]f32, left: f32, right: f32, top: f32, bottom: f32, near: f32, far: f32) void {
m[0] = 2.0 / (right - left);
m[1] = 0.0;
m[2] = 0.0;
m[3] = -((right + left) / (right - left));
m[4] = 0.0;
m[5] = 2.0 / (top - bottom);
m[6] = 0.0;
m[7] = -((top + bottom) / (top - bottom));
m[8] = 0.0;
m[9] = 0.0;
m[10] = -2.0 / (far - near);
m[11] = -((far + near) / (far - near));
m[12] = 0.0;
m[13] = 0.0;
m[14] = 0.0;
m[15] = 1.0;
}
pub fn setGeometry(width: i32, height: i32) void {
rectangle[0] = 0.0;
rectangle[1] = 0.0;
rectangle[2] = 0.0;
rectangle[3] = 0.0;
rectangle[4] = @intToFloat(f32, width);
rectangle[5] = 0.0;
rectangle[6] = 1.0;
rectangle[7] = 0.0;
rectangle[8] = 0.0;
rectangle[9] = @intToFloat(f32, height);
rectangle[10] = 0.0;
rectangle[11] = 1.0;
rectangle[12] = 0.0;
rectangle[13] = @intToFloat(f32, height);
rectangle[14] = 0.0;
rectangle[15] = 1.0;
rectangle[16] = @intToFloat(f32, width);
rectangle[17] = 0.0;
rectangle[18] = 1.0;
rectangle[19] = 0.0;
rectangle[20] = @intToFloat(f32, width);
rectangle[21] = @intToFloat(f32, height);
rectangle[22] = 1.0;
rectangle[23] = 1.0;
}
pub fn translate(x: f32, y: f32) !void {
MATRIX = identity;
MATRIX[3] = x;
MATRIX[7] = y;
try setUniformMatrix(PROGRAM, "translate", MATRIX);
}
pub fn scale(x: f32, y: f32) !void {
MATRIX = identity;
MATRIX[0] = x;
MATRIX[5] = y;
try setUniformMatrix(PROGRAM, "scale", MATRIX);
}
var MATRIX: [16]f32 = [_]f32{
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0,
};
pub const identity: [16]f32 = [_]f32{
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0,
};
pub fn setUniformMatrix(program: c_uint, location_string: []const u8, matrix: [16]f32) !void {
var location = c.glGetUniformLocation(program, location_string.ptr);
try checkGLError();
if (location == -1) {
return error.UniformNotFound;
}
c.glUniformMatrix4fv(location, 1, c.GL_TRUE, &matrix[0]);
try checkGLError();
}
pub fn setUniformFloat(program: c_uint, location_string: []const u8, value: f32) !void {
var location = c.glGetUniformLocation(program, location_string.ptr);
try checkGLError();
if (location == -1) {
return error.UniformNotFound;
}
c.glUniform1f(location, value);
try checkGLError();
}
fn setVertexAttrib(program: c_uint, attribute_string: []const u8, offset: c_uint) !void {
var attribute = c.glGetAttribLocation(program, attribute_string.ptr);
try checkGLError();
if (attribute == -1) {
return error.AttributeNotFound;
}
c.glEnableVertexAttribArray(@intCast(c_uint, attribute));
try checkGLError();
c.glVertexAttribPointer(@intCast(c_uint, attribute), 2, c.GL_FLOAT, c.GL_FALSE, 16, @intToPtr(*allowzero c_uint, offset));
try checkGLError();
}
pub fn makeTexture(width: i32, height: i32, stride: i32, format: u32, data: []const u8) !u32 {
if (stride * height > data.len) {
return error.NotEnoughTextureDataForDimensions;
}
var texture: u32 = undefined;
var err: c_uint = undefined;
c.glGenTextures(1, &texture);
try checkGLError();
c.glBindTexture(c.GL_TEXTURE_2D, texture);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MIN_FILTER, c.GL_LINEAR);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MAG_FILTER, c.GL_LINEAR);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_WRAP_S, c.GL_CLAMP_TO_EDGE);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_WRAP_T, c.GL_CLAMP_TO_EDGE);
try checkGLError();
c.glTexImage2D(c.GL_TEXTURE_2D, 0, c.GL_RGBA, width, height, 0, c.GL_RGBA, c.GL_UNSIGNED_BYTE, data.ptr);
try checkGLError();
return texture;
}
pub fn makeDmaTexture(image: *c_void, width: i32, height: i32, format: u32) !u32 {
switch (main.OUTPUT.backend) {
.DRM => |drm| {
var texture: u32 = undefined;
var err: c_uint = undefined;
c.glGenTextures(1, &texture);
try checkGLError();
c.glBindTexture(c.GL_TEXTURE_2D, texture);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MIN_FILTER, c.GL_LINEAR);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MAG_FILTER, c.GL_LINEAR);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_WRAP_S, c.GL_CLAMP_TO_EDGE);
try checkGLError();
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_WRAP_T, c.GL_CLAMP_TO_EDGE);
try checkGLError();
if (egl.glEGLImageTargetTexture2DOES) |glEGLImageTargetTexture2DOES| {
glEGLImageTargetTexture2DOES(c.GL_TEXTURE_2D, image);
} else {
return error.EGLImageTargetTexture2DOESNotAvailable;
}
try checkGLError();
return texture;
},
else => {
return error.AttemptedToMakeDmaTextureWithNoEGLContext;
},
}
}
pub fn releaseTexture(texture: u32) !void {
c.glDeleteTextures(1, &texture);
try checkGLError();
}
fn checkGLError() !void {
var err = c.glGetError();
if (err != c.GL_NO_ERROR) {
std.debug.warn("error: {}\n", .{err});
return error.GL_ERROR;
}
} | src/renderer.zig |
const std = @import("std");
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
pub fn asTypeId(comptime typeInfo: std.builtin.Type) std.builtin.TypeId {
return @as(std.builtin.TypeId, typeInfo);
}
pub fn typeIdOf(comptime T: type) std.builtin.TypeId {
return asTypeId(@typeInfo(T));
}
pub fn isStruct(comptime T: type) bool {
return typeIdOf(T) == std.builtin.TypeId.Struct;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/// UInt(bits) returns an unsigned integer type of the requested bit width.
pub fn UInt(comptime bits: u8) type {
const unsigned = std.builtin.Signedness.unsigned;
return @Type(.{ .Int = .{ .signedness = unsigned, .bits = bits } });
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/// Returns an unsigned integer type with ***at least*** `min_bits`,
/// that is also large enough to be addressable by a normal pointer.
/// The returned type will always be one of the following:
/// * `u8`
/// * `u16`
/// * `u32`
/// * `u64`
/// * `u128`
/// * `u256`
pub fn AddressableUInt(comptime min_bits: u8) type {
return switch (min_bits) {
0...8 => u8,
9...16 => u16,
17...32 => u32,
33...64 => u64,
65...128 => u128,
129...255 => u256,
};
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
/// Given: `Struct = struct { foo: u32, bar: u64 }`
/// Returns: `StructOfSlices = struct { foo: []u32, bar: []u64 }`
pub fn StructOfSlices(comptime Struct: type) type {
const StructField = std.builtin.Type.StructField;
const alignment = std.meta.alignment;
// initialize a basic slice-typed field, no name, zero sized elements
const Template = struct { @"": []u0 };
var slice_field: StructField = @typeInfo(Template).Struct.fields[0];
var slice_type_info = @typeInfo(slice_field.field_type);
// same number of fields in the new struct
const struct_fields = @typeInfo(Struct).Struct.fields;
var struct_of_slices_fields: [struct_fields.len]StructField = undefined;
inline for (struct_fields) |struct_field, i| {
// u32 -> []u32
const element_type = struct_field.field_type;
slice_type_info.Pointer.child = element_type;
slice_type_info.Pointer.alignment = alignment(element_type);
// Struct.foo: u32 -> StructOfSlices.foo : []u32
slice_field.name = struct_field.name;
slice_field.field_type = @Type(slice_type_info);
// Struct.foo: u32 -> StructOfSlices.foo : []u32
struct_of_slices_fields[i] = slice_field;
}
return @Type(.{ .Struct = .{
.layout = std.builtin.Type.ContainerLayout.Auto,
.fields = &struct_of_slices_fields,
.decls = &.{},
.is_tuple = false,
} });
}
test "StructOfSlices" {
const expectEqual = std.testing.expectEqual;
const Struct = struct { a: u16, b: u16, c: u16 };
try expectEqual(@sizeOf(u16) * 3, @sizeOf(Struct));
const SOS = StructOfSlices(Struct);
try expectEqual(@sizeOf([]u16) * 3, @sizeOf(SOS));
} | libs/zpool/src/utils.zig |
/// Do not compare directly to .True, use toBool() instead.
pub const Bool = enum(c_int) {
False,
True,
_,
pub fn fromBool(b: bool) Bool {
return @intToEnum(Bool, @boolToInt(b));
}
pub fn toBool(b: Bool) bool {
return b != .False;
}
};
pub const AttributeIndex = c_uint;
/// Make sure to use the *InContext functions instead of the global ones.
pub const Context = opaque {
pub const create = LLVMContextCreate;
extern fn LLVMContextCreate() *const Context;
pub const dispose = LLVMContextDispose;
extern fn LLVMContextDispose(C: *const Context) void;
pub const createEnumAttribute = LLVMCreateEnumAttribute;
extern fn LLVMCreateEnumAttribute(*const Context, KindID: c_uint, Val: u64) *const Attribute;
pub const intType = LLVMIntTypeInContext;
extern fn LLVMIntTypeInContext(C: *const Context, NumBits: c_uint) *const Type;
pub const halfType = LLVMHalfTypeInContext;
extern fn LLVMHalfTypeInContext(C: *const Context) *const Type;
pub const floatType = LLVMFloatTypeInContext;
extern fn LLVMFloatTypeInContext(C: *const Context) *const Type;
pub const doubleType = LLVMDoubleTypeInContext;
extern fn LLVMDoubleTypeInContext(C: *const Context) *const Type;
pub const x86FP80Type = LLVMX86FP80TypeInContext;
extern fn LLVMX86FP80TypeInContext(C: *const Context) *const Type;
pub const fp128Type = LLVMFP128TypeInContext;
extern fn LLVMFP128TypeInContext(C: *const Context) *const Type;
pub const voidType = LLVMVoidTypeInContext;
extern fn LLVMVoidTypeInContext(C: *const Context) *const Type;
pub const structType = LLVMStructTypeInContext;
extern fn LLVMStructTypeInContext(
C: *const Context,
ElementTypes: [*]const *const Type,
ElementCount: c_uint,
Packed: Bool,
) *const Type;
const structCreateNamed = LLVMStructCreateNamed;
extern fn LLVMStructCreateNamed(C: *const Context, Name: [*:0]const u8) *const Type;
pub const constString = LLVMConstStringInContext;
extern fn LLVMConstStringInContext(C: *const Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *const Value;
pub const constStruct = LLVMConstStructInContext;
extern fn LLVMConstStructInContext(
C: *const Context,
ConstantVals: [*]const *const Value,
Count: c_uint,
Packed: Bool,
) *const Value;
pub const createBasicBlock = LLVMCreateBasicBlockInContext;
extern fn LLVMCreateBasicBlockInContext(C: *const Context, Name: [*:0]const u8) *const BasicBlock;
pub const appendBasicBlock = LLVMAppendBasicBlockInContext;
extern fn LLVMAppendBasicBlockInContext(C: *const Context, Fn: *const Value, Name: [*:0]const u8) *const BasicBlock;
pub const createBuilder = LLVMCreateBuilderInContext;
extern fn LLVMCreateBuilderInContext(C: *const Context) *const Builder;
};
pub const Value = opaque {
pub const addAttributeAtIndex = LLVMAddAttributeAtIndex;
extern fn LLVMAddAttributeAtIndex(*const Value, Idx: AttributeIndex, A: *const Attribute) void;
pub const removeEnumAttributeAtIndex = LLVMRemoveEnumAttributeAtIndex;
extern fn LLVMRemoveEnumAttributeAtIndex(F: *const Value, Idx: AttributeIndex, KindID: c_uint) void;
pub const getFirstBasicBlock = LLVMGetFirstBasicBlock;
extern fn LLVMGetFirstBasicBlock(Fn: *const Value) ?*const BasicBlock;
pub const appendExistingBasicBlock = LLVMAppendExistingBasicBlock;
extern fn LLVMAppendExistingBasicBlock(Fn: *const Value, BB: *const BasicBlock) void;
pub const addIncoming = LLVMAddIncoming;
extern fn LLVMAddIncoming(PhiNode: *const Value, IncomingValues: [*]*const Value, IncomingBlocks: [*]*const BasicBlock, Count: c_uint) void;
pub const getNextInstruction = LLVMGetNextInstruction;
extern fn LLVMGetNextInstruction(Inst: *const Value) ?*const Value;
pub const typeOf = LLVMTypeOf;
extern fn LLVMTypeOf(Val: *const Value) *const Type;
pub const setGlobalConstant = LLVMSetGlobalConstant;
extern fn LLVMSetGlobalConstant(GlobalVar: *const Value, IsConstant: Bool) void;
pub const setLinkage = LLVMSetLinkage;
extern fn LLVMSetLinkage(Global: *const Value, Linkage: Linkage) void;
pub const setUnnamedAddr = LLVMSetUnnamedAddr;
extern fn LLVMSetUnnamedAddr(Global: *const Value, HasUnnamedAddr: Bool) void;
pub const deleteGlobal = LLVMDeleteGlobal;
extern fn LLVMDeleteGlobal(GlobalVar: *const Value) void;
pub const getNextGlobalAlias = LLVMGetNextGlobalAlias;
extern fn LLVMGetNextGlobalAlias(GA: *const Value) *const Value;
pub const getAliasee = LLVMAliasGetAliasee;
extern fn LLVMAliasGetAliasee(Alias: *const Value) *const Value;
pub const setAliasee = LLVMAliasSetAliasee;
extern fn LLVMAliasSetAliasee(Alias: *const Value, Aliasee: *const Value) void;
pub const constInBoundsGEP = LLVMConstInBoundsGEP;
extern fn LLVMConstInBoundsGEP(
ConstantVal: *const Value,
ConstantIndices: [*]const *const Value,
NumIndices: c_uint,
) *const Value;
pub const constBitCast = LLVMConstBitCast;
extern fn LLVMConstBitCast(ConstantVal: *const Value, ToType: *const Type) *const Value;
pub const constIntToPtr = LLVMConstIntToPtr;
extern fn LLVMConstIntToPtr(ConstantVal: *const Value, ToType: *const Type) *const Value;
pub const setWeak = LLVMSetWeak;
extern fn LLVMSetWeak(CmpXchgInst: *const Value, IsWeak: Bool) void;
pub const setOrdering = LLVMSetOrdering;
extern fn LLVMSetOrdering(MemoryAccessInst: *const Value, Ordering: AtomicOrdering) void;
pub const setVolatile = LLVMSetVolatile;
extern fn LLVMSetVolatile(MemoryAccessInst: *const Value, IsVolatile: Bool) void;
pub const setAlignment = LLVMSetAlignment;
extern fn LLVMSetAlignment(V: *const Value, Bytes: c_uint) void;
pub const getFunctionCallConv = LLVMGetFunctionCallConv;
extern fn LLVMGetFunctionCallConv(Fn: *const Value) CallConv;
pub const setFunctionCallConv = LLVMSetFunctionCallConv;
extern fn LLVMSetFunctionCallConv(Fn: *const Value, CC: CallConv) void;
pub const setValueName = LLVMSetValueName;
extern fn LLVMSetValueName(Val: *const Value, Name: [*:0]const u8) void;
pub const setValueName2 = LLVMSetValueName2;
extern fn LLVMSetValueName2(Val: *const Value, Name: [*]const u8, NameLen: usize) void;
pub const deleteFunction = LLVMDeleteFunction;
extern fn LLVMDeleteFunction(Fn: *const Value) void;
};
pub const Type = opaque {
pub const constNull = LLVMConstNull;
extern fn LLVMConstNull(Ty: *const Type) *const Value;
pub const constAllOnes = LLVMConstAllOnes;
extern fn LLVMConstAllOnes(Ty: *const Type) *const Value;
pub const constInt = LLVMConstInt;
extern fn LLVMConstInt(IntTy: *const Type, N: c_ulonglong, SignExtend: Bool) *const Value;
pub const constIntOfArbitraryPrecision = LLVMConstIntOfArbitraryPrecision;
extern fn LLVMConstIntOfArbitraryPrecision(IntTy: *const Type, NumWords: c_uint, Words: [*]const u64) *const Value;
pub const constReal = LLVMConstReal;
extern fn LLVMConstReal(RealTy: *const Type, N: f64) *const Value;
pub const constArray = LLVMConstArray;
extern fn LLVMConstArray(ElementTy: *const Type, ConstantVals: [*]*const Value, Length: c_uint) *const Value;
pub const constNamedStruct = LLVMConstNamedStruct;
extern fn LLVMConstNamedStruct(
StructTy: *const Type,
ConstantVals: [*]const *const Value,
Count: c_uint,
) *const Value;
pub const getUndef = LLVMGetUndef;
extern fn LLVMGetUndef(Ty: *const Type) *const Value;
pub const pointerType = LLVMPointerType;
extern fn LLVMPointerType(ElementType: *const Type, AddressSpace: c_uint) *const Type;
pub const arrayType = LLVMArrayType;
extern fn LLVMArrayType(ElementType: *const Type, ElementCount: c_uint) *const Type;
pub const structSetBody = LLVMStructSetBody;
extern fn LLVMStructSetBody(
StructTy: *const Type,
ElementTypes: [*]*const Type,
ElementCount: c_uint,
Packed: Bool,
) void;
pub const getTypeKind = LLVMGetTypeKind;
extern fn LLVMGetTypeKind(Ty: *const Type) TypeKind;
};
pub const Module = opaque {
pub const createWithName = LLVMModuleCreateWithNameInContext;
extern fn LLVMModuleCreateWithNameInContext(ModuleID: [*:0]const u8, C: *const Context) *const Module;
pub const dispose = LLVMDisposeModule;
extern fn LLVMDisposeModule(*const Module) void;
pub const verify = LLVMVerifyModule;
extern fn LLVMVerifyModule(*const Module, Action: VerifierFailureAction, OutMessage: *[*:0]const u8) Bool;
pub const setModuleDataLayout = LLVMSetModuleDataLayout;
extern fn LLVMSetModuleDataLayout(*const Module, *const TargetData) void;
pub const addFunction = LLVMAddFunction;
extern fn LLVMAddFunction(*const Module, Name: [*:0]const u8, FunctionTy: *const Type) *const Value;
pub const addFunctionInAddressSpace = ZigLLVMAddFunctionInAddressSpace;
extern fn ZigLLVMAddFunctionInAddressSpace(*const Module, Name: [*:0]const u8, FunctionTy: *const Type, AddressSpace: c_uint) *const Value;
pub const getNamedFunction = LLVMGetNamedFunction;
extern fn LLVMGetNamedFunction(*const Module, Name: [*:0]const u8) ?*const Value;
pub const getIntrinsicDeclaration = LLVMGetIntrinsicDeclaration;
extern fn LLVMGetIntrinsicDeclaration(Mod: *const Module, ID: c_uint, ParamTypes: ?[*]*const Type, ParamCount: usize) *const Value;
pub const printToString = LLVMPrintModuleToString;
extern fn LLVMPrintModuleToString(*const Module) [*:0]const u8;
pub const addGlobal = LLVMAddGlobal;
extern fn LLVMAddGlobal(M: *const Module, Ty: *const Type, Name: [*:0]const u8) *const Value;
pub const addGlobalInAddressSpace = LLVMAddGlobalInAddressSpace;
extern fn LLVMAddGlobalInAddressSpace(M: *const Module, Ty: *const Type, Name: [*:0]const u8, AddressSpace: c_uint) *const Value;
pub const getNamedGlobal = LLVMGetNamedGlobal;
extern fn LLVMGetNamedGlobal(M: *const Module, Name: [*:0]const u8) ?*const Value;
pub const dump = LLVMDumpModule;
extern fn LLVMDumpModule(M: *const Module) void;
pub const getFirstGlobalAlias = LLVMGetFirstGlobalAlias;
extern fn LLVMGetFirstGlobalAlias(M: *const Module) *const Value;
pub const getLastGlobalAlias = LLVMGetLastGlobalAlias;
extern fn LLVMGetLastGlobalAlias(M: *const Module) *const Value;
pub const addAlias = LLVMAddAlias;
extern fn LLVMAddAlias(
M: *const Module,
Ty: *const Type,
Aliasee: *const Value,
Name: [*:0]const u8,
) *const Value;
pub const getNamedGlobalAlias = LLVMGetNamedGlobalAlias;
extern fn LLVMGetNamedGlobalAlias(
M: *const Module,
/// Empirically, LLVM will call strlen() on `Name` and so it
/// must be both null terminated and also have `NameLen` set
/// to the size.
Name: [*:0]const u8,
NameLen: usize,
) ?*const Value;
};
pub const lookupIntrinsicID = LLVMLookupIntrinsicID;
extern fn LLVMLookupIntrinsicID(Name: [*]const u8, NameLen: usize) c_uint;
pub const disposeMessage = LLVMDisposeMessage;
extern fn LLVMDisposeMessage(Message: [*:0]const u8) void;
pub const VerifierFailureAction = enum(c_int) {
AbortProcess,
PrintMessage,
ReturnStatus,
};
pub const constNeg = LLVMConstNeg;
extern fn LLVMConstNeg(ConstantVal: *const Value) *const Value;
pub const setInitializer = LLVMSetInitializer;
extern fn LLVMSetInitializer(GlobalVar: *const Value, ConstantVal: *const Value) void;
pub const getParam = LLVMGetParam;
extern fn LLVMGetParam(Fn: *const Value, Index: c_uint) *const Value;
pub const getEnumAttributeKindForName = LLVMGetEnumAttributeKindForName;
extern fn LLVMGetEnumAttributeKindForName(Name: [*]const u8, SLen: usize) c_uint;
pub const getInlineAsm = LLVMGetInlineAsm;
extern fn LLVMGetInlineAsm(
Ty: *const Type,
AsmString: [*]const u8,
AsmStringSize: usize,
Constraints: [*]const u8,
ConstraintsSize: usize,
HasSideEffects: Bool,
IsAlignStack: Bool,
Dialect: InlineAsmDialect,
CanThrow: Bool,
) *const Value;
pub const functionType = LLVMFunctionType;
extern fn LLVMFunctionType(
ReturnType: *const Type,
ParamTypes: [*]const *const Type,
ParamCount: c_uint,
IsVarArg: Bool,
) *const Type;
pub const InlineAsmDialect = enum(c_uint) { ATT, Intel };
pub const Attribute = opaque {};
pub const Builder = opaque {
pub const dispose = LLVMDisposeBuilder;
extern fn LLVMDisposeBuilder(Builder: *const Builder) void;
pub const positionBuilder = LLVMPositionBuilder;
extern fn LLVMPositionBuilder(
Builder: *const Builder,
Block: *const BasicBlock,
Instr: *const Value,
) void;
pub const positionBuilderAtEnd = LLVMPositionBuilderAtEnd;
extern fn LLVMPositionBuilderAtEnd(Builder: *const Builder, Block: *const BasicBlock) void;
pub const getInsertBlock = LLVMGetInsertBlock;
extern fn LLVMGetInsertBlock(Builder: *const Builder) *const BasicBlock;
pub const buildZExt = LLVMBuildZExt;
extern fn LLVMBuildZExt(
*const Builder,
Value: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildSExt = LLVMBuildSExt;
extern fn LLVMBuildSExt(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildCall = ZigLLVMBuildCall;
extern fn ZigLLVMBuildCall(
*const Builder,
Fn: *const Value,
Args: [*]const *const Value,
NumArgs: c_uint,
CC: CallConv,
attr: CallAttr,
Name: [*:0]const u8,
) *const Value;
pub const buildRetVoid = LLVMBuildRetVoid;
extern fn LLVMBuildRetVoid(*const Builder) *const Value;
pub const buildRet = LLVMBuildRet;
extern fn LLVMBuildRet(*const Builder, V: *const Value) *const Value;
pub const buildUnreachable = LLVMBuildUnreachable;
extern fn LLVMBuildUnreachable(*const Builder) *const Value;
pub const buildAlloca = LLVMBuildAlloca;
extern fn LLVMBuildAlloca(*const Builder, Ty: *const Type, Name: [*:0]const u8) *const Value;
pub const buildStore = LLVMBuildStore;
extern fn LLVMBuildStore(*const Builder, Val: *const Value, Ptr: *const Value) *const Value;
pub const buildLoad = LLVMBuildLoad;
extern fn LLVMBuildLoad(*const Builder, PointerVal: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNeg = LLVMBuildNeg;
extern fn LLVMBuildNeg(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNot = LLVMBuildNot;
extern fn LLVMBuildNot(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFAdd = LLVMBuildFAdd;
extern fn LLVMBuildFAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildAdd = LLVMBuildAdd;
extern fn LLVMBuildAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNSWAdd = LLVMBuildNSWAdd;
extern fn LLVMBuildNSWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNUWAdd = LLVMBuildNUWAdd;
extern fn LLVMBuildNUWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSAddSat = ZigLLVMBuildSAddSat;
extern fn ZigLLVMBuildSAddSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildUAddSat = ZigLLVMBuildUAddSat;
extern fn ZigLLVMBuildUAddSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFSub = LLVMBuildFSub;
extern fn LLVMBuildFSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSub = LLVMBuildSub;
extern fn LLVMBuildSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNSWSub = LLVMBuildNSWSub;
extern fn LLVMBuildNSWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNUWSub = LLVMBuildNUWSub;
extern fn LLVMBuildNUWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSSubSat = ZigLLVMBuildSSubSat;
extern fn ZigLLVMBuildSSubSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildUSubSat = ZigLLVMBuildUSubSat;
extern fn ZigLLVMBuildUSubSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFMul = LLVMBuildFMul;
extern fn LLVMBuildFMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildMul = LLVMBuildMul;
extern fn LLVMBuildMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNSWMul = LLVMBuildNSWMul;
extern fn LLVMBuildNSWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNUWMul = LLVMBuildNUWMul;
extern fn LLVMBuildNUWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSMulFixSat = ZigLLVMBuildSMulFixSat;
extern fn ZigLLVMBuildSMulFixSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildUMulFixSat = ZigLLVMBuildUMulFixSat;
extern fn ZigLLVMBuildUMulFixSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildUDiv = LLVMBuildUDiv;
extern fn LLVMBuildUDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSDiv = LLVMBuildSDiv;
extern fn LLVMBuildSDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFDiv = LLVMBuildFDiv;
extern fn LLVMBuildFDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildURem = LLVMBuildURem;
extern fn LLVMBuildURem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSRem = LLVMBuildSRem;
extern fn LLVMBuildSRem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFRem = LLVMBuildFRem;
extern fn LLVMBuildFRem(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildAnd = LLVMBuildAnd;
extern fn LLVMBuildAnd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildLShr = LLVMBuildLShr;
extern fn LLVMBuildLShr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildAShr = LLVMBuildAShr;
extern fn LLVMBuildAShr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildShl = LLVMBuildShl;
extern fn LLVMBuildShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNUWShl = ZigLLVMBuildNUWShl;
extern fn ZigLLVMBuildNUWShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildNSWShl = ZigLLVMBuildNSWShl;
extern fn ZigLLVMBuildNSWShl(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildSShlSat = ZigLLVMBuildSShlSat;
extern fn ZigLLVMBuildSShlSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildUShlSat = ZigLLVMBuildUShlSat;
extern fn ZigLLVMBuildUShlSat(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildOr = LLVMBuildOr;
extern fn LLVMBuildOr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildXor = LLVMBuildXor;
extern fn LLVMBuildXor(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildIntCast2 = LLVMBuildIntCast2;
extern fn LLVMBuildIntCast2(*const Builder, Val: *const Value, DestTy: *const Type, IsSigned: Bool, Name: [*:0]const u8) *const Value;
pub const buildBitCast = LLVMBuildBitCast;
extern fn LLVMBuildBitCast(*const Builder, Val: *const Value, DestTy: *const Type, Name: [*:0]const u8) *const Value;
pub const buildInBoundsGEP = LLVMBuildInBoundsGEP;
extern fn LLVMBuildInBoundsGEP(
B: *const Builder,
Pointer: *const Value,
Indices: [*]const *const Value,
NumIndices: c_uint,
Name: [*:0]const u8,
) *const Value;
pub const buildInBoundsGEP2 = LLVMBuildInBoundsGEP2;
extern fn LLVMBuildInBoundsGEP2(
B: *const Builder,
Ty: *const Type,
Pointer: *const Value,
Indices: [*]const *const Value,
NumIndices: c_uint,
Name: [*:0]const u8,
) *const Value;
pub const buildICmp = LLVMBuildICmp;
extern fn LLVMBuildICmp(*const Builder, Op: IntPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildFCmp = LLVMBuildFCmp;
extern fn LLVMBuildFCmp(*const Builder, Op: RealPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
pub const buildBr = LLVMBuildBr;
extern fn LLVMBuildBr(*const Builder, Dest: *const BasicBlock) *const Value;
pub const buildCondBr = LLVMBuildCondBr;
extern fn LLVMBuildCondBr(*const Builder, If: *const Value, Then: *const BasicBlock, Else: *const BasicBlock) *const Value;
pub const buildPhi = LLVMBuildPhi;
extern fn LLVMBuildPhi(*const Builder, Ty: *const Type, Name: [*:0]const u8) *const Value;
pub const buildExtractValue = LLVMBuildExtractValue;
extern fn LLVMBuildExtractValue(
*const Builder,
AggVal: *const Value,
Index: c_uint,
Name: [*:0]const u8,
) *const Value;
pub const buildPtrToInt = LLVMBuildPtrToInt;
extern fn LLVMBuildPtrToInt(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildIntToPtr = LLVMBuildIntToPtr;
extern fn LLVMBuildIntToPtr(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildStructGEP = LLVMBuildStructGEP;
extern fn LLVMBuildStructGEP(
B: *const Builder,
Pointer: *const Value,
Idx: c_uint,
Name: [*:0]const u8,
) *const Value;
pub const buildTrunc = LLVMBuildTrunc;
extern fn LLVMBuildTrunc(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildInsertValue = LLVMBuildInsertValue;
extern fn LLVMBuildInsertValue(
*const Builder,
AggVal: *const Value,
EltVal: *const Value,
Index: c_uint,
Name: [*:0]const u8,
) *const Value;
pub const buildAtomicCmpXchg = LLVMBuildAtomicCmpXchg;
extern fn LLVMBuildAtomicCmpXchg(
builder: *const Builder,
ptr: *const Value,
cmp: *const Value,
new_val: *const Value,
success_ordering: AtomicOrdering,
failure_ordering: AtomicOrdering,
is_single_threaded: Bool,
) *const Value;
pub const buildSelect = LLVMBuildSelect;
extern fn LLVMBuildSelect(
*const Builder,
If: *const Value,
Then: *const Value,
Else: *const Value,
Name: [*:0]const u8,
) *const Value;
pub const buildFence = LLVMBuildFence;
extern fn LLVMBuildFence(
B: *const Builder,
ordering: AtomicOrdering,
singleThread: Bool,
Name: [*:0]const u8,
) *const Value;
pub const buildAtomicRmw = LLVMBuildAtomicRMW;
extern fn LLVMBuildAtomicRMW(
B: *const Builder,
op: AtomicRMWBinOp,
PTR: *const Value,
Val: *const Value,
ordering: AtomicOrdering,
singleThread: Bool,
) *const Value;
pub const buildFPToUI = LLVMBuildFPToUI;
extern fn LLVMBuildFPToUI(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildFPToSI = LLVMBuildFPToSI;
extern fn LLVMBuildFPToSI(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildUIToFP = LLVMBuildUIToFP;
extern fn LLVMBuildUIToFP(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildSIToFP = LLVMBuildSIToFP;
extern fn LLVMBuildSIToFP(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildFPTrunc = LLVMBuildFPTrunc;
extern fn LLVMBuildFPTrunc(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildFPExt = LLVMBuildFPExt;
extern fn LLVMBuildFPExt(
*const Builder,
Val: *const Value,
DestTy: *const Type,
Name: [*:0]const u8,
) *const Value;
pub const buildMemSet = ZigLLVMBuildMemSet;
extern fn ZigLLVMBuildMemSet(
B: *const Builder,
Ptr: *const Value,
Val: *const Value,
Len: *const Value,
Align: c_uint,
is_volatile: bool,
) *const Value;
pub const buildMemCpy = ZigLLVMBuildMemCpy;
extern fn ZigLLVMBuildMemCpy(
B: *const Builder,
Dst: *const Value,
DstAlign: c_uint,
Src: *const Value,
SrcAlign: c_uint,
Size: *const Value,
is_volatile: bool,
) *const Value;
};
pub const IntPredicate = enum(c_uint) {
EQ = 32,
NE = 33,
UGT = 34,
UGE = 35,
ULT = 36,
ULE = 37,
SGT = 38,
SGE = 39,
SLT = 40,
SLE = 41,
};
pub const RealPredicate = enum(c_uint) {
OEQ = 1,
OGT = 2,
OGE = 3,
OLT = 4,
OLE = 5,
ONE = 6,
ORD = 7,
UNO = 8,
UEQ = 9,
UGT = 10,
UGE = 11,
ULT = 12,
ULE = 13,
UNE = 14,
};
pub const BasicBlock = opaque {
pub const deleteBasicBlock = LLVMDeleteBasicBlock;
extern fn LLVMDeleteBasicBlock(BB: *const BasicBlock) void;
pub const getFirstInstruction = LLVMGetFirstInstruction;
extern fn LLVMGetFirstInstruction(BB: *const BasicBlock) ?*const Value;
};
pub const TargetMachine = opaque {
pub const create = ZigLLVMCreateTargetMachine;
extern fn ZigLLVMCreateTargetMachine(
T: *const Target,
Triple: [*:0]const u8,
CPU: ?[*:0]const u8,
Features: ?[*:0]const u8,
Level: CodeGenOptLevel,
Reloc: RelocMode,
CodeModel: CodeModel,
function_sections: bool,
float_abi: ABIType,
abi_name: ?[*:0]const u8,
) *const TargetMachine;
pub const dispose = LLVMDisposeTargetMachine;
extern fn LLVMDisposeTargetMachine(T: *const TargetMachine) void;
pub const emitToFile = ZigLLVMTargetMachineEmitToFile;
extern fn ZigLLVMTargetMachineEmitToFile(
T: *const TargetMachine,
M: *const Module,
ErrorMessage: *[*:0]const u8,
is_debug: bool,
is_small: bool,
time_report: bool,
tsan: bool,
lto: bool,
asm_filename: ?[*:0]const u8,
bin_filename: ?[*:0]const u8,
llvm_ir_filename: ?[*:0]const u8,
bitcode_filename: ?[*:0]const u8,
) bool;
pub const createTargetDataLayout = LLVMCreateTargetDataLayout;
extern fn LLVMCreateTargetDataLayout(*const TargetMachine) *const TargetData;
};
pub const TargetData = opaque {
pub const dispose = LLVMDisposeTargetData;
extern fn LLVMDisposeTargetData(*const TargetData) void;
};
pub const CodeModel = enum(c_int) {
Default,
JITDefault,
Tiny,
Small,
Kernel,
Medium,
Large,
};
pub const CodeGenOptLevel = enum(c_int) {
None,
Less,
Default,
Aggressive,
};
pub const RelocMode = enum(c_int) {
Default,
Static,
PIC,
DynamicNoPIC,
ROPI,
RWPI,
ROPI_RWPI,
};
pub const CodeGenFileType = enum(c_int) {
AssemblyFile,
ObjectFile,
};
pub const ABIType = enum(c_int) {
/// Target-specific (either soft or hard depending on triple, etc).
Default,
/// Soft float.
Soft,
// Hard float.
Hard,
};
pub const Target = opaque {
pub const getFromTriple = LLVMGetTargetFromTriple;
extern fn LLVMGetTargetFromTriple(Triple: [*:0]const u8, T: **const Target, ErrorMessage: *[*:0]const u8) Bool;
};
pub extern fn LLVMInitializeAArch64TargetInfo() void;
pub extern fn LLVMInitializeAMDGPUTargetInfo() void;
pub extern fn LLVMInitializeARMTargetInfo() void;
pub extern fn LLVMInitializeAVRTargetInfo() void;
pub extern fn LLVMInitializeBPFTargetInfo() void;
pub extern fn LLVMInitializeHexagonTargetInfo() void;
pub extern fn LLVMInitializeLanaiTargetInfo() void;
pub extern fn LLVMInitializeMipsTargetInfo() void;
pub extern fn LLVMInitializeMSP430TargetInfo() void;
pub extern fn LLVMInitializeNVPTXTargetInfo() void;
pub extern fn LLVMInitializePowerPCTargetInfo() void;
pub extern fn LLVMInitializeRISCVTargetInfo() void;
pub extern fn LLVMInitializeSparcTargetInfo() void;
pub extern fn LLVMInitializeSystemZTargetInfo() void;
pub extern fn LLVMInitializeWebAssemblyTargetInfo() void;
pub extern fn LLVMInitializeX86TargetInfo() void;
pub extern fn LLVMInitializeXCoreTargetInfo() void;
pub extern fn LLVMInitializeM68kTargetInfo() void;
pub extern fn LLVMInitializeCSKYTargetInfo() void;
pub extern fn LLVMInitializeVETargetInfo() void;
pub extern fn LLVMInitializeARCTargetInfo() void;
pub extern fn LLVMInitializeAArch64Target() void;
pub extern fn LLVMInitializeAMDGPUTarget() void;
pub extern fn LLVMInitializeARMTarget() void;
pub extern fn LLVMInitializeAVRTarget() void;
pub extern fn LLVMInitializeBPFTarget() void;
pub extern fn LLVMInitializeHexagonTarget() void;
pub extern fn LLVMInitializeLanaiTarget() void;
pub extern fn LLVMInitializeMipsTarget() void;
pub extern fn LLVMInitializeMSP430Target() void;
pub extern fn LLVMInitializeNVPTXTarget() void;
pub extern fn LLVMInitializePowerPCTarget() void;
pub extern fn LLVMInitializeRISCVTarget() void;
pub extern fn LLVMInitializeSparcTarget() void;
pub extern fn LLVMInitializeSystemZTarget() void;
pub extern fn LLVMInitializeWebAssemblyTarget() void;
pub extern fn LLVMInitializeX86Target() void;
pub extern fn LLVMInitializeXCoreTarget() void;
pub extern fn LLVMInitializeM68kTarget() void;
pub extern fn LLVMInitializeVETarget() void;
pub extern fn LLVMInitializeCSKYTarget() void;
pub extern fn LLVMInitializeARCTarget() void;
pub extern fn LLVMInitializeAArch64TargetMC() void;
pub extern fn LLVMInitializeAMDGPUTargetMC() void;
pub extern fn LLVMInitializeARMTargetMC() void;
pub extern fn LLVMInitializeAVRTargetMC() void;
pub extern fn LLVMInitializeBPFTargetMC() void;
pub extern fn LLVMInitializeHexagonTargetMC() void;
pub extern fn LLVMInitializeLanaiTargetMC() void;
pub extern fn LLVMInitializeMipsTargetMC() void;
pub extern fn LLVMInitializeMSP430TargetMC() void;
pub extern fn LLVMInitializeNVPTXTargetMC() void;
pub extern fn LLVMInitializePowerPCTargetMC() void;
pub extern fn LLVMInitializeRISCVTargetMC() void;
pub extern fn LLVMInitializeSparcTargetMC() void;
pub extern fn LLVMInitializeSystemZTargetMC() void;
pub extern fn LLVMInitializeWebAssemblyTargetMC() void;
pub extern fn LLVMInitializeX86TargetMC() void;
pub extern fn LLVMInitializeXCoreTargetMC() void;
pub extern fn LLVMInitializeM68kTargetMC() void;
pub extern fn LLVMInitializeCSKYTargetMC() void;
pub extern fn LLVMInitializeVETargetMC() void;
pub extern fn LLVMInitializeARCTargetMC() void;
pub extern fn LLVMInitializeAArch64AsmPrinter() void;
pub extern fn LLVMInitializeAMDGPUAsmPrinter() void;
pub extern fn LLVMInitializeARMAsmPrinter() void;
pub extern fn LLVMInitializeAVRAsmPrinter() void;
pub extern fn LLVMInitializeBPFAsmPrinter() void;
pub extern fn LLVMInitializeHexagonAsmPrinter() void;
pub extern fn LLVMInitializeLanaiAsmPrinter() void;
pub extern fn LLVMInitializeMipsAsmPrinter() void;
pub extern fn LLVMInitializeMSP430AsmPrinter() void;
pub extern fn LLVMInitializeNVPTXAsmPrinter() void;
pub extern fn LLVMInitializePowerPCAsmPrinter() void;
pub extern fn LLVMInitializeRISCVAsmPrinter() void;
pub extern fn LLVMInitializeSparcAsmPrinter() void;
pub extern fn LLVMInitializeSystemZAsmPrinter() void;
pub extern fn LLVMInitializeWebAssemblyAsmPrinter() void;
pub extern fn LLVMInitializeX86AsmPrinter() void;
pub extern fn LLVMInitializeXCoreAsmPrinter() void;
pub extern fn LLVMInitializeM68kAsmPrinter() void;
pub extern fn LLVMInitializeVEAsmPrinter() void;
pub extern fn LLVMInitializeARCAsmPrinter() void;
pub extern fn LLVMInitializeAArch64AsmParser() void;
pub extern fn LLVMInitializeAMDGPUAsmParser() void;
pub extern fn LLVMInitializeARMAsmParser() void;
pub extern fn LLVMInitializeAVRAsmParser() void;
pub extern fn LLVMInitializeBPFAsmParser() void;
pub extern fn LLVMInitializeHexagonAsmParser() void;
pub extern fn LLVMInitializeLanaiAsmParser() void;
pub extern fn LLVMInitializeMipsAsmParser() void;
pub extern fn LLVMInitializeMSP430AsmParser() void;
pub extern fn LLVMInitializePowerPCAsmParser() void;
pub extern fn LLVMInitializeRISCVAsmParser() void;
pub extern fn LLVMInitializeSparcAsmParser() void;
pub extern fn LLVMInitializeSystemZAsmParser() void;
pub extern fn LLVMInitializeWebAssemblyAsmParser() void;
pub extern fn LLVMInitializeX86AsmParser() void;
pub extern fn LLVMInitializeM68kAsmParser() void;
pub extern fn LLVMInitializeCSKYAsmParser() void;
pub extern fn LLVMInitializeVEAsmParser() void;
extern fn ZigLLDLinkCOFF(argc: c_int, argv: [*:null]const ?[*:0]const u8, can_exit_early: bool) c_int;
extern fn ZigLLDLinkELF(argc: c_int, argv: [*:null]const ?[*:0]const u8, can_exit_early: bool) c_int;
extern fn ZigLLDLinkWasm(argc: c_int, argv: [*:null]const ?[*:0]const u8, can_exit_early: bool) c_int;
pub const LinkCOFF = ZigLLDLinkCOFF;
pub const LinkELF = ZigLLDLinkELF;
pub const LinkWasm = ZigLLDLinkWasm;
pub const ObjectFormatType = enum(c_int) {
Unknown,
COFF,
ELF,
GOFF,
MachO,
Wasm,
XCOFF,
};
pub const WriteArchive = ZigLLVMWriteArchive;
extern fn ZigLLVMWriteArchive(
archive_name: [*:0]const u8,
file_names_ptr: [*]const [*:0]const u8,
file_names_len: usize,
os_type: OSType,
) bool;
pub const OSType = enum(c_int) {
UnknownOS,
Ananas,
CloudABI,
Darwin,
DragonFly,
FreeBSD,
Fuchsia,
IOS,
KFreeBSD,
Linux,
Lv2,
MacOSX,
NetBSD,
OpenBSD,
Solaris,
Win32,
ZOS,
Haiku,
Minix,
RTEMS,
NaCl,
AIX,
CUDA,
NVCL,
AMDHSA,
PS4,
ELFIAMCU,
TvOS,
WatchOS,
Mesa3D,
Contiki,
AMDPAL,
HermitCore,
Hurd,
WASI,
Emscripten,
};
pub const ArchType = enum(c_int) {
UnknownArch,
arm,
armeb,
aarch64,
aarch64_be,
aarch64_32,
arc,
avr,
bpfel,
bpfeb,
csky,
hexagon,
m68k,
mips,
mipsel,
mips64,
mips64el,
msp430,
ppc,
ppcle,
ppc64,
ppc64le,
r600,
amdgcn,
riscv32,
riscv64,
sparc,
sparcv9,
sparcel,
systemz,
tce,
tcele,
thumb,
thumbeb,
x86,
x86_64,
xcore,
nvptx,
nvptx64,
le32,
le64,
amdil,
amdil64,
hsail,
hsail64,
spir,
spir64,
kalimba,
shave,
lanai,
wasm32,
wasm64,
renderscript32,
renderscript64,
ve,
};
pub const ParseCommandLineOptions = ZigLLVMParseCommandLineOptions;
extern fn ZigLLVMParseCommandLineOptions(argc: usize, argv: [*]const [*:0]const u8) void;
pub const WriteImportLibrary = ZigLLVMWriteImportLibrary;
extern fn ZigLLVMWriteImportLibrary(
def_path: [*:0]const u8,
arch: ArchType,
output_lib_path: [*c]const u8,
kill_at: bool,
) bool;
pub const Linkage = enum(c_uint) {
External,
AvailableExternally,
LinkOnceAny,
LinkOnceODR,
LinkOnceODRAutoHide,
WeakAny,
WeakODR,
Appending,
Internal,
Private,
DLLImport,
DLLExport,
ExternalWeak,
Ghost,
Common,
LinkerPrivate,
LinkerPrivateWeak,
};
pub const AtomicOrdering = enum(c_uint) {
NotAtomic = 0,
Unordered = 1,
Monotonic = 2,
Acquire = 4,
Release = 5,
AcquireRelease = 6,
SequentiallyConsistent = 7,
};
pub const AtomicRMWBinOp = enum(c_int) {
Xchg,
Add,
Sub,
And,
Nand,
Or,
Xor,
Max,
Min,
UMax,
UMin,
FAdd,
FSub,
};
pub const TypeKind = enum(c_int) {
Void,
Half,
Float,
Double,
X86_FP80,
FP128,
PPC_FP128,
Label,
Integer,
Function,
Struct,
Array,
Pointer,
Vector,
Metadata,
X86_MMX,
Token,
ScalableVector,
BFloat,
X86_AMX,
};
pub const CallConv = enum(c_uint) {
C = 0,
Fast = 8,
Cold = 9,
GHC = 10,
HiPE = 11,
WebKit_JS = 12,
AnyReg = 13,
PreserveMost = 14,
PreserveAll = 15,
Swift = 16,
CXX_FAST_TLS = 17,
X86_StdCall = 64,
X86_FastCall = 65,
ARM_APCS = 66,
ARM_AAPCS = 67,
ARM_AAPCS_VFP = 68,
MSP430_INTR = 69,
X86_ThisCall = 70,
PTX_Kernel = 71,
PTX_Device = 72,
SPIR_FUNC = 75,
SPIR_KERNEL = 76,
Intel_OCL_BI = 77,
X86_64_SysV = 78,
Win64 = 79,
X86_VectorCall = 80,
HHVM = 81,
HHVM_C = 82,
X86_INTR = 83,
AVR_INTR = 84,
AVR_SIGNAL = 85,
AVR_BUILTIN = 86,
AMDGPU_VS = 87,
AMDGPU_GS = 88,
AMDGPU_PS = 89,
AMDGPU_CS = 90,
AMDGPU_KERNEL = 91,
X86_RegCall = 92,
AMDGPU_HS = 93,
MSP430_BUILTIN = 94,
AMDGPU_LS = 95,
AMDGPU_ES = 96,
AArch64_VectorCall = 97,
};
pub const CallAttr = enum(c_int) {
Auto,
NeverTail,
NeverInline,
AlwaysTail,
AlwaysInline,
};
pub const address_space = struct {
pub const default: c_uint = 0;
// See llvm/lib/Target/X86/X86.h
pub const x86_64 = x86;
pub const x86 = struct {
pub const gs: c_uint = 256;
pub const fs: c_uint = 257;
pub const ss: c_uint = 258;
pub const ptr32_sptr: c_uint = 270;
pub const ptr32_uptr: c_uint = 271;
pub const ptr64: c_uint = 272;
};
// See llvm/lib/Target/AVR/AVR.h
pub const avr = struct {
pub const data_memory: c_uint = 0;
pub const program_memory: c_uint = 1;
};
// See llvm/lib/Target/NVPTX/NVPTX.h
pub const nvptx = struct {
pub const generic: c_uint = 0;
pub const global: c_uint = 1;
pub const constant: c_uint = 2;
pub const shared: c_uint = 3;
pub const param: c_uint = 4;
pub const local: c_uint = 5;
};
// See llvm/lib/Target/AMDGPU/AMDGPU.h
pub const amdgpu = struct {
pub const flat: c_uint = 0;
pub const global: c_uint = 1;
pub const region: c_uint = 2;
pub const local: c_uint = 3;
pub const constant: c_uint = 4;
pub const private: c_uint = 5;
pub const constant_32bit: c_uint = 6;
pub const buffer_fat_pointer: c_uint = 7;
pub const param_d: c_uint = 6;
pub const param_i: c_uint = 7;
pub const constant_buffer_0: c_uint = 8;
pub const constant_buffer_1: c_uint = 9;
pub const constant_buffer_2: c_uint = 10;
pub const constant_buffer_3: c_uint = 11;
pub const constant_buffer_4: c_uint = 12;
pub const constant_buffer_5: c_uint = 13;
pub const constant_buffer_6: c_uint = 14;
pub const constant_buffer_7: c_uint = 15;
pub const constant_buffer_8: c_uint = 16;
pub const constant_buffer_9: c_uint = 17;
pub const constant_buffer_10: c_uint = 18;
pub const constant_buffer_11: c_uint = 19;
pub const constant_buffer_12: c_uint = 20;
pub const constant_buffer_13: c_uint = 21;
pub const constant_buffer_14: c_uint = 22;
pub const constant_buffer_15: c_uint = 23;
};
}; | src/codegen/llvm/bindings.zig |
usingnamespace @import("bits.zig");
pub const SOCKET = *@OpaqueType();
pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0));
pub const SOCKET_ERROR = -1;
pub const WSADESCRIPTION_LEN = 256;
pub const WSASYS_STATUS_LEN = 128;
pub const WSADATA = if (usize.bit_count == u64.bit_count)
extern struct {
wVersion: WORD,
wHighVersion: WORD,
iMaxSockets: u16,
iMaxUdpDg: u16,
lpVendorInfo: *u8,
szDescription: [WSADESCRIPTION_LEN + 1]u8,
szSystemStatus: [WSASYS_STATUS_LEN + 1]u8,
}
else
extern struct {
wVersion: WORD,
wHighVersion: WORD,
szDescription: [WSADESCRIPTION_LEN + 1]u8,
szSystemStatus: [WSASYS_STATUS_LEN + 1]u8,
iMaxSockets: u16,
iMaxUdpDg: u16,
lpVendorInfo: *u8,
};
pub const MAX_PROTOCOL_CHAIN = 7;
pub const WSAPROTOCOLCHAIN = extern struct {
ChainLen: c_int,
ChainEntries: [MAX_PROTOCOL_CHAIN]DWORD,
};
pub const WSAPROTOCOL_LEN = 255;
pub const WSAPROTOCOL_INFOA = extern struct {
dwServiceFlags1: DWORD,
dwServiceFlags2: DWORD,
dwServiceFlags3: DWORD,
dwServiceFlags4: DWORD,
dwProviderFlags: DWORD,
ProviderId: GUID,
dwCatalogEntryId: DWORD,
ProtocolChain: WSAPROTOCOLCHAIN,
iVersion: c_int,
iAddressFamily: c_int,
iMaxSockAddr: c_int,
iMinSockAddr: c_int,
iSocketType: c_int,
iProtocol: c_int,
iProtocolMaxOffset: c_int,
iNetworkByteOrder: c_int,
iSecurityScheme: c_int,
dwMessageSize: DWORD,
dwProviderReserved: DWORD,
szProtocol: [WSAPROTOCOL_LEN + 1]CHAR,
};
pub const WSAPROTOCOL_INFOW = extern struct {
dwServiceFlags1: DWORD,
dwServiceFlags2: DWORD,
dwServiceFlags3: DWORD,
dwServiceFlags4: DWORD,
dwProviderFlags: DWORD,
ProviderId: GUID,
dwCatalogEntryId: DWORD,
ProtocolChain: WSAPROTOCOLCHAIN,
iVersion: c_int,
iAddressFamily: c_int,
iMaxSockAddr: c_int,
iMinSockAddr: c_int,
iSocketType: c_int,
iProtocol: c_int,
iProtocolMaxOffset: c_int,
iNetworkByteOrder: c_int,
iSecurityScheme: c_int,
dwMessageSize: DWORD,
dwProviderReserved: DWORD,
szProtocol: [WSAPROTOCOL_LEN + 1]WCHAR,
};
pub const GROUP = u32;
pub const SG_UNCONSTRAINED_GROUP = 0x1;
pub const SG_CONSTRAINED_GROUP = 0x2;
pub const WSA_FLAG_OVERLAPPED = 0x01;
pub const WSA_FLAG_MULTIPOINT_C_ROOT = 0x02;
pub const WSA_FLAG_MULTIPOINT_C_LEAF = 0x04;
pub const WSA_FLAG_MULTIPOINT_D_ROOT = 0x08;
pub const WSA_FLAG_MULTIPOINT_D_LEAF = 0x10;
pub const WSA_FLAG_ACCESS_SYSTEM_SECURITY = 0x40;
pub const WSA_FLAG_NO_HANDLE_INHERIT = 0x80;
pub const WSAEVENT = HANDLE;
pub const WSAOVERLAPPED = extern struct {
Internal: DWORD,
InternalHigh: DWORD,
Offset: DWORD,
OffsetHigh: DWORD,
hEvent: ?WSAEVENT,
};
pub const WSAOVERLAPPED_COMPLETION_ROUTINE = extern fn (
dwError: DWORD,
cbTransferred: DWORD,
lpOverlapped: *WSAOVERLAPPED,
dwFlags: DWORD
) void;
pub const WSA_INVALID_HANDLE = 6;
pub const WSA_NOT_ENOUGH_MEMORY = 8;
pub const WSA_INVALID_PARAMETER = 87;
pub const WSA_OPERATION_ABORTED = 995;
pub const WSA_IO_INCOMPLETE = 996;
pub const WSA_IO_PENDING = 997;
pub const WSAEINTR = 10004;
pub const WSAEBADF = 10009;
pub const WSAEACCES = 10013;
pub const WSAEFAULT = 10014;
pub const WSAEINVAL = 10022;
pub const WSAEMFILE = 10024;
pub const WSAEWOULDBLOCK = 10035;
pub const WSAEINPROGRESS = 10036;
pub const WSAEALREADY = 10037;
pub const WSAENOTSOCK = 10038;
pub const WSAEDESTADDRREQ = 10039;
pub const WSAEMSGSIZE = 10040;
pub const WSAEPROTOTYPE = 10041;
pub const WSAENOPROTOOPT = 10042;
pub const WSAEPROTONOSUPPORT = 10043;
pub const WSAESOCKTNOSUPPORT = 10044;
pub const WSAEOPNOTSUPP = 10045;
pub const WSAEPFNOSUPPORT = 10046;
pub const WSAEAFNOSUPPORT = 10047;
pub const WSAEADDRINUSE = 10048;
pub const WSAEADDRNOTAVAIL = 10049;
pub const WSAENETDOWN = 10050;
pub const WSAENETUNREACH = 10051;
pub const WSAENETRESET = 10052;
pub const WSAECONNABORTED = 10053;
pub const WSAECONNRESET = 10054;
pub const WSAENOBUFS = 10055;
pub const WSAEISCONN = 10056;
pub const WSAENOTCONN = 10057;
pub const WSAESHUTDOWN = 10058;
pub const WSAETOOMANYREFS = 10059;
pub const WSAETIMEDOUT = 10060;
pub const WSAECONNREFUSED = 10061;
pub const WSAELOOP = 10062;
pub const WSAENAMETOOLONG = 10063;
pub const WSAEHOSTDOWN = 10064;
pub const WSAEHOSTUNREACH = 10065;
pub const WSAENOTEMPTY = 10066;
pub const WSAEPROCLIM = 10067;
pub const WSAEUSERS = 10068;
pub const WSAEDQUOT = 10069;
pub const WSAESTALE = 10070;
pub const WSAEREMOTE = 10071;
pub const WSASYSNOTREADY = 10091;
pub const WSAVERNOTSUPPORTED = 10092;
pub const WSANOTINITIALISED = 10093;
pub const WSAEDISCON = 10101;
pub const WSAENOMORE = 10102;
pub const WSAECANCELLED = 10103;
pub const WSAEINVALIDPROCTABLE = 10104;
pub const WSAEINVALIDPROVIDER = 10105;
pub const WSAEPROVIDERFAILEDINIT = 10106;
pub const WSASYSCALLFAILURE = 10107;
pub const WSASERVICE_NOT_FOUND = 10108;
pub const WSATYPE_NOT_FOUND = 10109;
pub const WSA_E_NO_MORE = 10110;
pub const WSA_E_CANCELLED = 10111;
pub const WSAEREFUSED = 10112;
pub const WSAHOST_NOT_FOUND = 11001;
pub const WSATRY_AGAIN = 11002;
pub const WSANO_RECOVERY = 11003;
pub const WSANO_DATA = 11004;
pub const WSA_QOS_RECEIVERS = 11005;
pub const WSA_QOS_SENDERS = 11006;
pub const WSA_QOS_NO_SENDERS = 11007;
pub const WSA_QOS_NO_RECEIVERS = 11008;
pub const WSA_QOS_REQUEST_CONFIRMED = 11009;
pub const WSA_QOS_ADMISSION_FAILURE = 11010;
pub const WSA_QOS_POLICY_FAILURE = 11011;
pub const WSA_QOS_BAD_STYLE = 11012;
pub const WSA_QOS_BAD_OBJECT = 11013;
pub const WSA_QOS_TRAFFIC_CTRL_ERROR = 11014;
pub const WSA_QOS_GENERIC_ERROR = 11015;
pub const WSA_QOS_ESERVICETYPE = 11016;
pub const WSA_QOS_EFLOWSPEC = 11017;
pub const WSA_QOS_EPROVSPECBUF = 11018;
pub const WSA_QOS_EFILTERSTYLE = 11019;
pub const WSA_QOS_EFILTERTYPE = 11020;
pub const WSA_QOS_EFILTERCOUNT = 11021;
pub const WSA_QOS_EOBJLENGTH = 11022;
pub const WSA_QOS_EFLOWCOUNT = 11023;
pub const WSA_QOS_EUNKOWNPSOBJ = 11024;
pub const WSA_QOS_EPOLICYOBJ = 11025;
pub const WSA_QOS_EFLOWDESC = 11026;
pub const WSA_QOS_EPSFLOWSPEC = 11027;
pub const WSA_QOS_EPSFILTERSPEC = 11028;
pub const WSA_QOS_ESDMODEOBJ = 11029;
pub const WSA_QOS_ESHAPERATEOBJ = 11030;
pub const WSA_QOS_RESERVED_PETYPE = 11031;
/// no parameters
const IOC_VOID = 0x80000000;
/// copy out parameters
const IOC_OUT = 0x40000000;
/// copy in parameters
const IOC_IN = 0x80000000;
/// The IOCTL is a generic Windows Sockets 2 IOCTL code. New IOCTL codes defined for Windows Sockets 2 will have T == 1.
const IOC_WS2 = 0x08000000;
pub const SIO_BASE_HANDLE = IOC_OUT | IOC_WS2 | 34;
pub extern "ws2_32" stdcallcc fn WSAStartup(
wVersionRequired: WORD,
lpWSAData: *WSADATA,
) c_int;
pub extern "ws2_32" stdcallcc fn WSACleanup() c_int;
pub extern "ws2_32" stdcallcc fn WSAGetLastError() c_int;
pub extern "ws2_32" stdcallcc fn WSASocketA(
af: c_int,
type: c_int,
protocol: c_int,
lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
g: GROUP,
dwFlags: DWORD,
) SOCKET;
pub extern "ws2_32" stdcallcc fn WSASocketW(
af: c_int,
type: c_int,
protocol: c_int,
lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
g: GROUP,
dwFlags: DWORD,
) SOCKET;
pub extern "ws2_32" stdcallcc fn WSAIoctl(
s: SOCKET,
dwIoControlCode: DWORD,
lpvInBuffer: ?*const c_void,
cbInBuffer: DWORD,
lpvOutBuffer: ?LPVOID,
cbOutBuffer: DWORD,
lpcbBytesReturned: LPDWORD,
lpOverlapped: ?*WSAOVERLAPPED,
lpCompletionRoutine: ?*WSAOVERLAPPED_COMPLETION_ROUTINE,
) c_int; | lib/std/os/windows/ws2_32.zig |
const std = @import("std");
/// Contains constants for the C0 control codes of the ASCII encoding.
/// https://en.wikipedia.org/wiki/C0_and_C1_control_codes
pub const control_code = struct {
pub const NUL = 0x00;
pub const SOH = 0x01;
pub const STX = 0x02;
pub const ETX = 0x03;
pub const EOT = 0x04;
pub const ENQ = 0x05;
pub const ACK = 0x06;
pub const BEL = 0x07;
pub const BS = 0x08;
pub const TAB = 0x09;
pub const LF = 0x0A;
pub const VT = 0x0B;
pub const FF = 0x0C;
pub const CR = 0x0D;
pub const SO = 0x0E;
pub const SI = 0x0F;
pub const DLE = 0x10;
pub const DC1 = 0x11;
pub const DC2 = 0x12;
pub const DC3 = 0x13;
pub const DC4 = 0x14;
pub const NAK = 0x15;
pub const SYN = 0x16;
pub const ETB = 0x17;
pub const CAN = 0x18;
pub const EM = 0x19;
pub const SUB = 0x1A;
pub const ESC = 0x1B;
pub const FS = 0x1C;
pub const GS = 0x1D;
pub const RS = 0x1E;
pub const US = 0x1F;
pub const DEL = 0x7F;
pub const XON = 0x11;
pub const XOFF = 0x13;
};
const tIndex = enum(u3) {
Alpha,
Hex,
Space,
Digit,
Lower,
Upper,
// Ctrl, < 0x20 || == DEL
// Print, = Graph || == ' '. NOT '\t' et cetera
Punct,
Graph,
//ASCII, | ~0b01111111
//isBlank, == ' ' || == '\x09'
};
const combinedTable = init: {
comptime var table: [256]u8 = undefined;
const mem = std.mem;
const alpha = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
};
const lower = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
};
const upper = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const digit = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const hex = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const space = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
const punct = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
};
const graph = [_]u1{
// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
};
comptime var i = 0;
inline while (i < 128) : (i += 1) {
table[i] =
@as(u8, alpha[i]) << @enumToInt(tIndex.Alpha) |
@as(u8, hex[i]) << @enumToInt(tIndex.Hex) |
@as(u8, space[i]) << @enumToInt(tIndex.Space) |
@as(u8, digit[i]) << @enumToInt(tIndex.Digit) |
@as(u8, lower[i]) << @enumToInt(tIndex.Lower) |
@as(u8, upper[i]) << @enumToInt(tIndex.Upper) |
@as(u8, punct[i]) << @enumToInt(tIndex.Punct) |
@as(u8, graph[i]) << @enumToInt(tIndex.Graph);
}
mem.set(u8, table[128..256], 0);
break :init table;
};
fn inTable(c: u8, t: tIndex) bool {
return (combinedTable[c] & (@as(u8, 1) << @enumToInt(t))) != 0;
}
pub fn isAlNum(c: u8) bool {
return (combinedTable[c] & ((@as(u8, 1) << @enumToInt(tIndex.Alpha)) |
@as(u8, 1) << @enumToInt(tIndex.Digit))) != 0;
}
pub fn isAlpha(c: u8) bool {
return inTable(c, tIndex.Alpha);
}
pub fn isCntrl(c: u8) bool {
return c < 0x20 or c == 127; //DEL
}
pub fn isDigit(c: u8) bool {
return inTable(c, tIndex.Digit);
}
pub fn isGraph(c: u8) bool {
return inTable(c, tIndex.Graph);
}
pub fn isLower(c: u8) bool {
return inTable(c, tIndex.Lower);
}
pub fn isPrint(c: u8) bool {
return inTable(c, tIndex.Graph) or c == ' ';
}
pub fn isPunct(c: u8) bool {
return inTable(c, tIndex.Punct);
}
pub fn isSpace(c: u8) bool {
return inTable(c, tIndex.Space);
}
/// All the values for which isSpace() returns true. This may be used with
/// e.g. std.mem.trim() to trim whiteSpace.
pub const spaces = [_]u8{ ' ', '\t', '\n', '\r', control_code.VT, control_code.FF };
test "spaces" {
const testing = std.testing;
for (spaces) |space| testing.expect(isSpace(space));
var i: u8 = 0;
while (isASCII(i)) : (i += 1) {
if (isSpace(i)) testing.expect(std.mem.indexOfScalar(u8, &spaces, i) != null);
}
}
pub fn isUpper(c: u8) bool {
return inTable(c, tIndex.Upper);
}
pub fn isXDigit(c: u8) bool {
return inTable(c, tIndex.Hex);
}
pub fn isASCII(c: u8) bool {
return c < 128;
}
pub fn isBlank(c: u8) bool {
return (c == ' ') or (c == '\x09');
}
pub fn toUpper(c: u8) u8 {
if (isLower(c)) {
return c & 0b11011111;
} else {
return c;
}
}
pub fn toLower(c: u8) u8 {
if (isUpper(c)) {
return c | 0b00100000;
} else {
return c;
}
}
test "ascii character classes" {
const testing = std.testing;
testing.expect('C' == toUpper('c'));
testing.expect(':' == toUpper(':'));
testing.expect('\xab' == toUpper('\xab'));
testing.expect('c' == toLower('C'));
testing.expect(isAlpha('c'));
testing.expect(!isAlpha('5'));
testing.expect(isSpace(' '));
}
/// Allocates a lower case copy of `ascii_string`.
/// Caller owns returned string and must free with `allocator`.
pub fn allocLowerString(allocator: *std.mem.Allocator, ascii_string: []const u8) ![]u8 {
const result = try allocator.alloc(u8, ascii_string.len);
for (result) |*c, i| {
c.* = toLower(ascii_string[i]);
}
return result;
}
test "allocLowerString" {
const result = try allocLowerString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
defer std.testing.allocator.free(result);
std.testing.expect(std.mem.eql(u8, "abcdefghijklmnopqrst0234+💩!", result));
}
/// Allocates an upper case copy of `ascii_string`.
/// Caller owns returned string and must free with `allocator`.
pub fn allocUpperString(allocator: *std.mem.Allocator, ascii_string: []const u8) ![]u8 {
const result = try allocator.alloc(u8, ascii_string.len);
for (result) |*c, i| {
c.* = toUpper(ascii_string[i]);
}
return result;
}
test "allocUpperString" {
const result = try allocUpperString(std.testing.allocator, "aBcDeFgHiJkLmNOPqrst0234+💩!");
defer std.testing.allocator.free(result);
std.testing.expect(std.mem.eql(u8, "ABCDEFGHIJKLMNOPQRST0234+💩!", result));
}
/// Compares strings `a` and `b` case insensitively and returns whether they are equal.
pub fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {
if (a.len != b.len) return false;
for (a) |a_c, i| {
if (toLower(a_c) != toLower(b[i])) return false;
}
return true;
}
test "eqlIgnoreCase" {
std.testing.expect(eqlIgnoreCase("HEl💩Lo!", "hel💩lo!"));
std.testing.expect(!eqlIgnoreCase("hElLo!", "hello! "));
std.testing.expect(!eqlIgnoreCase("hElLo!", "helro!"));
}
pub fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[0..needle.len], needle);
}
test "ascii.startsWithIgnoreCase" {
std.testing.expect(startsWithIgnoreCase("boB", "Bo"));
std.testing.expect(!startsWithIgnoreCase("Needle in hAyStAcK", "haystack"));
}
pub fn endsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
return if (needle.len > haystack.len) false else eqlIgnoreCase(haystack[haystack.len - needle.len ..], needle);
}
test "ascii.endsWithIgnoreCase" {
std.testing.expect(endsWithIgnoreCase("Needle in HaYsTaCk", "haystack"));
std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));
}
/// Finds `substr` in `container`, ignoring case, starting at `start_index`.
/// TODO boyer-moore algorithm
pub fn indexOfIgnoreCasePos(container: []const u8, start_index: usize, substr: []const u8) ?usize {
if (substr.len > container.len) return null;
var i: usize = start_index;
const end = container.len - substr.len;
while (i <= end) : (i += 1) {
if (eqlIgnoreCase(container[i .. i + substr.len], substr)) return i;
}
return null;
}
/// Finds `substr` in `container`, ignoring case, starting at index 0.
pub fn indexOfIgnoreCase(container: []const u8, substr: []const u8) ?usize {
return indexOfIgnoreCasePos(container, 0, substr);
}
test "indexOfIgnoreCase" {
std.testing.expect(indexOfIgnoreCase("one Two Three Four", "foUr").? == 14);
std.testing.expect(indexOfIgnoreCase("one two three FouR", "gOur") == null);
std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);
std.testing.expect(indexOfIgnoreCase("foo", "fool") == null);
std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0);
} | lib/std/ascii.zig |
const std = @import("std");
const expect = std.testing.expect;
const mem = std.mem;
const maxInt = std.math.maxInt;
const Vector = std.meta.Vector;
const native_endian = @import("builtin").target.cpu.arch.endian();
test "int to ptr cast" {
const x = @as(usize, 13);
const y = @intToPtr(*u8, x);
const z = @ptrToInt(y);
try expect(z == 13);
}
test "integer literal to pointer cast" {
const vga_mem = @intToPtr(*u16, 0xB8000);
try expect(@ptrToInt(vga_mem) == 0xB8000);
}
test "peer type resolution: ?T and T" {
try expect(peerTypeTAndOptionalT(true, false).? == 0);
try expect(peerTypeTAndOptionalT(false, false).? == 3);
comptime {
try expect(peerTypeTAndOptionalT(true, false).? == 0);
try 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 "resolve undefined with integer" {
try testResolveUndefWithInt(true, 1234);
comptime try testResolveUndefWithInt(true, 1234);
}
fn testResolveUndefWithInt(b: bool, x: i32) !void {
const value = if (b) x else undefined;
if (b) {
try expect(value == x);
}
}
test "@intCast i32 to u7" {
var x: u128 = maxInt(u128);
var y: i32 = 120;
var z = x >> @intCast(u7, y);
try expect(z == 0xff);
}
test "@intCast to comptime_int" {
try 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;
try expect(b == 255);
}
test "implicit cast comptime_int to comptime_float" {
comptime try expect(@as(comptime_float, 10) == @as(f32, 10));
try expect(2 == 2.0);
}
test "pointer reinterpret const float to int" {
// The hex representation is 0x3fe3333333333303.
const float: f64 = 5.99999999999994648725e-01;
const float_ptr = &float;
const int_ptr = @ptrCast(*const i32, float_ptr);
const int_val = int_ptr.*;
if (native_endian == .Little)
try expect(int_val == 0x33333303)
else
try expect(int_val == 0x3fe33333);
}
test "comptime_int @intToFloat" {
{
const result = @intToFloat(f16, 1234);
try expect(@TypeOf(result) == f16);
try expect(result == 1234.0);
}
{
const result = @intToFloat(f32, 1234);
try expect(@TypeOf(result) == f32);
try expect(result == 1234.0);
}
{
const result = @intToFloat(f64, 1234);
try expect(@TypeOf(result) == f64);
try expect(result == 1234.0);
}
{
const result = @intToFloat(f128, 1234);
try expect(@TypeOf(result) == f128);
try expect(result == 1234.0);
}
// big comptime_int (> 64 bits) to f128 conversion
{
const result = @intToFloat(f128, 0x1_0000_0000_0000_0000);
try expect(@TypeOf(result) == f128);
try expect(result == 0x1_0000_0000_0000_0000.0);
}
} | test/behavior/cast.zig |
const expectEqual = @import("std").testing.expectEqual;
const std = @import("std");
const expect = std.testing.expect;
test "@byteSwap integers" {
const ByteSwapIntTest = struct {
fn run() !void {
try t(u0, 0, 0);
try t(u8, 0x12, 0x12);
try t(u16, 0x1234, 0x3412);
try t(u24, 0x123456, 0x563412);
try t(u32, 0x12345678, 0x78563412);
try t(u40, 0x123456789a, 0x9a78563412);
try t(i48, 0x123456789abc, @bitCast(i48, @as(u48, 0xbc9a78563412)));
try t(u56, 0x123456789abcde, 0xdebc9a78563412);
try t(u64, 0x123456789abcdef1, 0xf1debc9a78563412);
try t(u128, 0x123456789abcdef11121314151617181, 0x8171615141312111f1debc9a78563412);
try t(u0, @as(u0, 0), 0);
try t(i8, @as(i8, -50), -50);
try t(i16, @bitCast(i16, @as(u16, 0x1234)), @bitCast(i16, @as(u16, 0x3412)));
try t(i24, @bitCast(i24, @as(u24, 0x123456)), @bitCast(i24, @as(u24, 0x563412)));
try t(i32, @bitCast(i32, @as(u32, 0x12345678)), @bitCast(i32, @as(u32, 0x78563412)));
try t(u40, @bitCast(i40, @as(u40, 0x123456789a)), @as(u40, 0x9a78563412));
try t(i48, @bitCast(i48, @as(u48, 0x123456789abc)), @bitCast(i48, @as(u48, 0xbc9a78563412)));
try t(i56, @bitCast(i56, @as(u56, 0x123456789abcde)), @bitCast(i56, @as(u56, 0xdebc9a78563412)));
try t(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1)), @bitCast(i64, @as(u64, 0xf1debc9a78563412)));
try t(
i128,
@bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181)),
@bitCast(i128, @as(u128, 0x8171615141312111f1debc9a78563412)),
);
}
fn t(comptime I: type, input: I, expected_output: I) !void {
try std.testing.expectEqual(expected_output, @byteSwap(I, input));
}
};
comptime try ByteSwapIntTest.run();
try ByteSwapIntTest.run();
}
test "@byteSwap vectors" {
// https://github.com/ziglang/zig/issues/3317
if (std.Target.current.cpu.arch == .mipsel or std.Target.current.cpu.arch == .mips) return error.SkipZigTest;
const ByteSwapVectorTest = struct {
fn run() !void {
try t(u8, 2, [_]u8{ 0x12, 0x13 }, [_]u8{ 0x12, 0x13 });
try t(u16, 2, [_]u16{ 0x1234, 0x2345 }, [_]u16{ 0x3412, 0x4523 });
try t(u24, 2, [_]u24{ 0x123456, 0x234567 }, [_]u24{ 0x563412, 0x674523 });
}
fn t(
comptime I: type,
comptime n: comptime_int,
input: std.meta.Vector(n, I),
expected_vector: std.meta.Vector(n, I),
) !void {
const actual_output: [n]I = @byteSwap(I, input);
const expected_output: [n]I = expected_vector;
try std.testing.expectEqual(expected_output, actual_output);
}
};
comptime try ByteSwapVectorTest.run();
try ByteSwapVectorTest.run();
} | test/behavior/byteswap.zig |
const builtin = @import("builtin");
const std = @import("std");
const Mode = builtin.Mode;
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const mode = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const test_all_step = b.step("test", "Run all tests in all modes.");
inline for ([_]Mode{ Mode.Debug, Mode.ReleaseFast, Mode.ReleaseSafe, Mode.ReleaseSmall }) |test_mode| {
const mode_str = comptime modeToString(test_mode);
const tests = b.addTest("clap.zig");
tests.setBuildMode(test_mode);
tests.setTarget(target);
tests.setNamePrefix(mode_str ++ " ");
const test_step = b.step("test-" ++ mode_str, "Run all tests in " ++ mode_str ++ ".");
test_step.dependOn(&tests.step);
test_all_step.dependOn(test_step);
}
const example_step = b.step("examples", "Build examples");
inline for ([_][]const u8{
"simple",
"simple-ex",
//"simple-error",
"streaming-clap",
"help",
"usage",
}) |example_name| {
const example = b.addExecutable(example_name, "example/" ++ example_name ++ ".zig");
example.addPackagePath("clap", "clap.zig");
example.setBuildMode(mode);
example.setTarget(target);
example.install();
example_step.dependOn(&example.step);
}
const readme_step = b.step("readme", "Remake README.");
const readme = readMeStep(b);
readme.dependOn(example_step);
readme_step.dependOn(readme);
const all_step = b.step("all", "Build everything and runs all tests");
all_step.dependOn(test_all_step);
all_step.dependOn(example_step);
all_step.dependOn(readme_step);
b.default_step.dependOn(all_step);
}
fn readMeStep(b: *Builder) *std.build.Step {
const s = b.allocator.create(std.build.Step) catch unreachable;
s.* = std.build.Step.init(.Custom, "ReadMeStep", b.allocator, struct {
fn make(step: *std.build.Step) anyerror!void {
@setEvalBranchQuota(10000);
const file = try std.fs.cwd().createFile("README.md", .{});
const stream = &file.outStream();
try stream.print(@embedFile("example/README.md.template"), .{
@embedFile("example/simple.zig"),
@embedFile("example/simple-error.zig"),
@embedFile("example/streaming-clap.zig"),
@embedFile("example/help.zig"),
@embedFile("example/usage.zig"),
});
}
}.make);
return s;
}
fn modeToString(mode: Mode) []const u8 {
return switch (mode) {
Mode.Debug => "debug",
Mode.ReleaseFast => "release-fast",
Mode.ReleaseSafe => "release-safe",
Mode.ReleaseSmall => "release-small",
};
} | build.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const List = std.ArrayList;
const Str = []const u8;
const BitSet = std.DynamicBitSet;
const StrMap = std.StringHashMap;
const HashMap = std.HashMap;
const Map = std.AutoHashMap;
const PriorityQueue = std.PriorityQueue;
const assert = std.debug.assert;
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const print = std.debug.print;
const parseInt = std.fmt.parseInt;
const abs = std.math.absInt;
const OOM = error{OutOfMemory};
const fs = std.fs;
fn sort(comptime T: type, items: []T) void {
std.sort.sort(T, items, {}, comptime std.sort.asc(T));
}
fn println(x: Str) void {
print("{s}\n", .{x});
}
// Module level constants, change accordingly
const fortuneFile = @embedFile("./fortune.txt");
const fortuneOut = "fortunes-all.dat";
// size of OS page (or multiple of)
const pageSize = 4096;
const headerLocation = "header2.txt";
const maxIntSizeInBytes = 5;
const fortuneSeparator = "\r\n%\r\n";
// Fixed sized buffer so we don't have to allocate
var buf = [_]u8{0} ** pageSize;
pub fn main() !void {
// Open files
var headerFile = try fs.Dir.createFile(fs.cwd(), headerLocation, .{});
defer headerFile.close();
var fortuneIt = split(u8, fortuneFile, fortuneSeparator);
var maxFortuneLen: u32 = 0;
var numFortunes: u32 = 0;
while (fortuneIt.next()) |fortune| : (numFortunes += 1) {
if (fortune.len > pageSize) {
print("Fortune {s} too large. Extend the page size.\n", .{fortune});
return error.FortuneTooLarge;
}
if (fortune.len > maxFortuneLen) maxFortuneLen = @intCast(u32, fortune.len);
}
try headerFile.writer().writeIntNative(u32, maxFortuneLen);
try headerFile.writer().writeIntNative(u32, numFortunes);
var fortuneOutFile = try fs.Dir.createFile(fs.cwd(), fortuneOut, .{});
defer fortuneOutFile.close();
var fortuneBuf = buf[0..maxFortuneLen];
fortuneIt = split(u8, fortuneFile, fortuneSeparator);
while (fortuneIt.next()) |fortune| {
std.mem.set(u8, fortuneBuf, 0);
std.mem.copy(u8, fortuneBuf, fortune);
_ = try fortuneOutFile.write(fortuneBuf);
}
} | chunkFortunes.zig |
const std = @import("std");
const os = std.os;
const common = @import("common.zig");
pub const Object = common.Object;
pub const Message = common.Message;
pub const Interface = common.Interface;
pub const Array = common.Array;
pub const Fixed = common.Fixed;
pub const Argument = common.Argument;
/// This is wayland-server's wl_display. It has been renamed as zig-wayland has
/// decided to hide wl_resources with opaque pointers in the same way that
/// wayland-client does with wl_proxys. This of course creates a name conflict.
pub const Server = opaque {
extern fn wl_display_create() ?*Server;
pub fn create() !*Server {
return wl_display_create() orelse error.ServerCreateFailed;
}
extern fn wl_display_destroy(server: *Server) void;
pub const destroy = wl_display_destroy;
extern fn wl_display_get_event_loop(server: *Server) *EventLoop;
pub const getEventLoop = wl_display_get_event_loop;
extern fn wl_display_add_socket(server: *Server, name: [*:0]const u8) c_int;
pub fn addSocket(server: *Server, name: [*:0]const u8) !void {
if (wl_display_add_socket(server, name) == -1)
return error.AddSocketFailed;
}
// wayland-client will connect to wayland-0 even if WAYLAND_DISPLAY is
// unset due to an unfortunate piece of code that was not removed before
// the library was stabilized. Because of this, it is a good idea to never
// call the socket wayland-0. So, instead of binding to wayland-server's
// wl_display_add_socket_auto we implement a version which skips wayland-0.
pub fn addSocketAuto(server: *Server, buf: *[11]u8) ![:0]const u8 {
// Don't use wayland-0
var i: u32 = 1;
while (i <= 32) : (i += 1) {
const name = std.fmt.bufPrintZ(buf, "wayland-{}", .{i}) catch unreachable;
server.addSocket(name.ptr) catch continue;
return name;
}
return error.AddSocketFailed;
}
extern fn wl_display_add_socket_fd(server: *Server, sock_fd: c_int) c_int;
pub fn addSocketFd(server: *Server, sock_fd: c_int) !void {
if (wl_display_add_socket_fd(server, sock_fd) == -1)
return error.AddSocketFailed;
}
extern fn wl_display_terminate(server: *Server) void;
pub const terminate = wl_display_terminate;
extern fn wl_display_run(server: *Server) void;
pub const run = wl_display_run;
extern fn wl_display_flush_clients(server: *Server) void;
pub const flushClients = wl_display_flush_clients;
extern fn wl_display_destroy_clients(server: *Server) void;
pub const destroyClients = wl_display_destroy_clients;
extern fn wl_display_get_serial(server: *Server) u32;
pub const getSerial = wl_display_get_serial;
extern fn wl_display_next_serial(server: *Server) u32;
pub const nextSerial = wl_display_next_serial;
extern fn wl_display_add_destroy_listener(server: *Server, listener: *Listener(*Server)) void;
pub const addDestroyListener = wl_display_add_destroy_listener;
extern fn wl_display_add_client_created_listener(server: *Server, listener: *Listener(*Client)) void;
pub const addClientCreatedListener = wl_display_add_client_created_listener;
// Doesn't really make sense with our Listener API as we would need to
// pass a pointer to the wrapper function
//extern fn wl_display_get_destroy_listener(server: *Server, notify: @TypeOf(Listener(*Server).notify)) ?*Listener(*Server);
extern fn wl_display_set_global_filter(
server: *Server,
filter: fn (client: *const Client, global: *const Global, data: ?*c_void) callconv(.C) bool,
data: ?*c_void,
) void;
pub inline fn setGlobalFilter(
server: *Server,
comptime T: type,
filter: fn (client: *const Client, global: *const Global, data: T) callconv(.C) bool,
data: T,
) void {
wl_display_set_global_filter(server, filter, data);
}
extern fn wl_display_get_client_list(server: *Server) *list.Head(Client, null);
pub const getClientList = wl_display_get_client_list;
extern fn wl_display_init_shm(server: *Server) c_int;
pub fn initShm(server: *Server) !void {
if (wl_display_init_shm(server) == -1) return error.OutOfMemory;
}
extern fn wl_display_add_shm_format(server: *Server, format: u32) ?*u32;
pub fn addShmFormat(server: *Server, format: u32) !*u32 {
return wl_display_add_shm_format(server, format) orelse error.OutOfMemory;
}
extern fn wl_display_add_protocol_logger(
server: *Server,
func: fn (data: ?*c_void, direction: ProtocolLogger.Type, message: *const ProtocolLogger.LogMessage) callconv(.C) void,
data: ?*c_void,
) void;
pub inline fn addProtocolLogger(
server: *Server,
comptime T: type,
func: fn (data: T, direction: ProtocolLogger.Type, message: *const ProtocolLogger.LogMessage) callconv(.C) void,
data: T,
) void {
wl_display_add_protocol_logger(server, func, data);
}
};
pub const Client = opaque {
extern fn wl_client_create(server: *Server, fd: c_int) ?*Client;
pub const create = wl_client_create;
extern fn wl_client_destroy(client: *Client) void;
pub const destroy = wl_client_destroy;
extern fn wl_client_flush(client: *Client) void;
pub const flush = wl_client_flush;
extern fn wl_client_get_link(client: *Client) *list.Link;
pub const getLink = wl_client_get_link;
extern fn wl_client_from_link(link: *list.Link) *Client;
pub const fromLink = wl_client_from_link;
const Credentials = struct {
pid: os.pid_t,
gid: os.gid_t,
uid: os.uid_t,
};
extern fn wl_client_get_credentials(client: *Client, pid: *os.pid_t, uid: *os.uid_t, gid: *os.gid_t) void;
pub fn getCredentials(client: *Client) Credentials {
var credentials: Credentials = undefined;
wl_client_get_credentials(client, &credentials.pid, &credentials.uid, &credentials.gid);
return credentials;
}
extern fn wl_client_add_destroy_listener(client: *Client, listener: *Listener(*Client)) void;
pub const addDestroyListener = wl_client_add_destroy_listener;
// Doesn't really make sense with our Listener API as we would need to
// pass a pointer to the wrapper function
//extern fn wl_client_get_destroy_listener(client: *Client, notify: @TypeOf(Listener(*Client).notify)) ?*Listener(*Client);
extern fn wl_client_get_object(client: *Client, id: u32) ?*Resource;
pub const getObject = wl_client_get_object;
extern fn wl_client_post_no_memory(client: *Client) void;
pub const postNoMemory = wl_client_post_no_memory;
extern fn wl_client_post_implementation_error(client: *Client, msg: [*:0]const u8, ...) void;
pub const postImplementationError = wl_client_post_implementation_error;
extern fn wl_client_add_resource_created_listener(client: *Client, listener: *Listener(*Resource)) void;
pub const addResourceCreatedListener = wl_client_add_resource_created_listener;
const IteratorResult = extern enum { stop, cont };
extern fn wl_client_for_each_resource(
client: *Client,
iterator: fn (resource: *Resource, data: ?*c_void) callconv(.C) IteratorResult,
data: ?*c_void,
) void;
pub inline fn forEachResource(
client: *Client,
comptime T: type,
iterator: fn (resource: *Resource, data: T) callconv(.C) IteratorResult,
data: T,
) void {
wl_client_for_each_resource(client, iterator, data);
}
extern fn wl_client_get_fd(client: *Client) c_int;
pub const getFd = wl_client_get_fd;
extern fn wl_client_get_display(client: *Client) *Server;
pub const getDisplay = wl_client_get_display;
};
pub const Global = opaque {
extern fn wl_global_create(
server: *Server,
interface: *const Interface,
version: c_int,
data: ?*c_void,
bind: fn (client: *Client, data: ?*c_void, version: u32, id: u32) callconv(.C) void,
) ?*Global;
pub inline fn create(
server: *Server,
comptime T: type,
version: u32,
comptime DataT: type,
data: DataT,
bind: fn (client: *Client, data: DataT, version: u32, id: u32) callconv(.C) void,
) !*Global {
return wl_global_create(
server,
T.getInterface(),
@intCast(c_int, version),
data,
@ptrCast(fn (client: *Client, data: ?*c_void, version: u32, id: u32) callconv(.C) void, bind),
) orelse error.GlobalCreateFailed;
}
extern fn wl_global_remove(global: *Global) void;
pub const remove = wl_global_remove;
extern fn wl_global_destroy(global: *Global) void;
pub const destroy = wl_global_destroy;
extern fn wl_global_get_interface(global: *const Global) *const Interface;
pub const getInterface = wl_global_get_interface;
extern fn wl_global_get_user_data(global: *const Global) ?*c_void;
pub const getUserData = wl_global_get_user_data;
};
pub const Resource = opaque {
extern fn wl_resource_create(client: *Client, interface: *const Interface, version: c_int, id: u32) ?*Resource;
pub inline fn create(client: *Client, comptime T: type, version: u32, id: u32) !*Resource {
// This is only a c_int because of legacy libwayland reasons. Negative versions are invalid.
// Version is a u32 on the wire and for wl_global, wl_proxy, etc.
return wl_resource_create(client, T.getInterface(), @intCast(c_int, version), id) orelse error.ResourceCreateFailed;
}
extern fn wl_resource_destroy(resource: *Resource) void;
pub const destroy = wl_resource_destroy;
extern fn wl_resource_post_event_array(resource: *Resource, opcode: u32, args: ?[*]Argument) void;
pub const postEvent = wl_resource_post_event_array;
extern fn wl_resource_queue_event_array(resource: *Resource, opcode: u32, args: ?[*]Argument) void;
pub const queueEvent = wl_resource_queue_event_array;
extern fn wl_resource_post_error(resource: *Resource, code: u32, message: [*:0]const u8, ...) void;
pub const postError = wl_resource_post_error;
extern fn wl_resource_post_no_memory(resource: *Resource) void;
pub const postNoMemory = wl_resource_post_no_memory;
const DispatcherFn = fn (
implementation: ?*const c_void,
resource: *Resource,
opcode: u32,
message: *const Message,
args: [*]Argument,
) callconv(.C) c_int;
pub const DestroyFn = fn (resource: *Resource) callconv(.C) void;
extern fn wl_resource_set_dispatcher(
resource: *Resource,
dispatcher: ?DispatcherFn,
implementation: ?*const c_void,
data: ?*c_void,
destroy_fn: ?DestroyFn,
) void;
pub fn setDispatcher(
resource: *Resource,
dispatcher: ?DispatcherFn,
implementation: ?*const c_void,
data: ?*c_void,
destroy_fn: ?DestroyFn,
) void {
wl_resource_set_dispatcher(resource, dispatcher, implementation, data, destroy_fn);
}
extern fn wl_resource_get_user_data(resource: *Resource) ?*c_void;
pub const getUserData = wl_resource_get_user_data;
extern fn wl_resource_get_id(resource: *Resource) u32;
pub const getId = wl_resource_get_id;
extern fn wl_resource_get_link(resource: *Resource) *list.Link;
pub const getLink = wl_resource_get_link;
extern fn wl_resource_from_link(link: *list.Link) *Resource;
pub const fromLink = wl_resource_from_link;
extern fn wl_resource_find_for_client(list: *list.Head(Resource, null), client: *Client) ?*Resource;
pub const findForClient = wl_resource_find_for_client;
extern fn wl_resource_get_client(resource: *Resource) *Client;
pub const getClient = wl_resource_get_client;
extern fn wl_resource_get_version(resource: *Resource) c_int;
pub fn getVersion(resource: *Resource) u32 {
// The fact that wl_resource.version is a int in libwayland is
// a mistake. Negative versions are impossible and u32 is used
// everywhere else in libwayland
return @intCast(u32, wl_resource_get_version(resource));
}
// TOOD: unsure if this should be bound
extern fn wl_resource_set_destructor(resource: *Resource, destroy: DestroyFn) void;
extern fn wl_resource_get_class(resource: *Resource) [*:0]const u8;
pub const getClass = wl_resource_get_class;
extern fn wl_resource_add_destroy_listener(resource: *Resource, listener: *Listener(*Resource)) void;
pub const addDestroyListener = wl_resource_add_destroy_listener;
// Doesn't really make sense with our Listener API as we would need to
// pass a pointer to the wrapper function
//extern fn wl_resource_get_destroy_listener(resource: *Resource, notify: @TypeOf(Listener(*Resource).notify)) ?*Listener(*Resource);
};
pub const ProtocolLogger = opaque {
pub const Type = extern enum {
request,
event,
};
pub const LogMessage = extern struct {
resource: *Resource,
message_opcode: c_int,
message: *Message,
arguments_count: c_int,
arguments: ?[*]Argument,
};
extern fn wl_protocol_logger_destroy(logger: *ProtocolLogger) void;
pub const destroy = wl_protocol_logger_destroy;
};
pub const list = struct {
pub const Link = extern struct {
prev: ?*Link,
next: ?*Link,
pub fn insertAfter(link: *Link, other: *Link) void {
other.prev = link;
other.next = link.next;
link.next = other;
other.next.?.prev = other;
}
pub fn remove(link: *Link) void {
link.prev.?.next = link.next;
link.next.?.prev = link.prev;
link.* = .{ .prev = null, .next = null };
}
};
pub const Direction = enum {
forward,
reverse,
};
/// This has the same ABI as wl.list.Link/wl_list. If link_field is null, then
/// T.getLink()/T.fromLink() will be used. This allows for compatiability
/// with wl.Client and wl.Resource
pub fn Head(comptime T: type, comptime link_field: ?[]const u8) type {
return extern struct {
const Self = @This();
link: Link,
pub fn init(head: *Self) void {
head.* = .{ .link = .{ .prev = &head.link, .next = &head.link } };
}
pub fn prepend(head: *Self, elem: *T) void {
const link = if (link_field) |f| &@field(elem, f) else elem.getLink();
head.link.insertAfter(link);
}
pub fn append(head: *Self, elem: *T) void {
const link = if (link_field) |f| &@field(elem, f) else elem.getLink();
head.link.prev.?.insertAfter(link);
}
pub fn length(head: *const Self) usize {
var count: usize = 0;
var current = head.link.next.?;
while (current != &head.link) : (current = current.next.?) {
count += 1;
}
return count;
}
pub fn empty(head: *const Self) bool {
return head.link.next == &head.link;
}
pub fn insertList(head: *Self, other: *Self) void {
if (other.empty()) return;
other.link.next.?.prev = head.link;
other.link.prev.?.next = head.link.next;
head.link.next.?.prev = other.link.prev;
head.link.next = other.link.next;
}
/// Removal of elements during iteration is illegal
pub fn Iterator(comptime direction: Direction) type {
return struct {
head: *Link,
current: *Link,
pub fn next(it: *@This()) ?*T {
it.current = switch (direction) {
.forward => it.current.next.?,
.reverse => it.current.prev.?,
};
if (it.current == it.head) return null;
return if (link_field) |f| @fieldParentPtr(T, f, it.current) else T.fromLink(it.current);
}
};
}
/// Removal of elements during iteration is illegal
pub fn iterator(head: *Self, comptime direction: Direction) Iterator(direction) {
return .{ .head = &head.link, .current = &head.link };
}
/// Removal of the current element during iteration is permitted.
/// Removal of other elements is illegal.
pub fn SafeIterator(comptime direction: Direction) type {
return struct {
head: *Link,
current: *Link,
future: *Link,
pub fn next(it: *@This()) ?*T {
it.current = it.future;
it.future = switch (direction) {
.forward => it.future.next.?,
.reverse => it.future.prev.?,
};
if (it.current == it.head) return null;
return if (link_field) |f| @fieldParentPtr(T, f, it.current) else T.fromLink(it.current);
}
};
}
/// Removal of the current element during iteration is permitted.
/// Removal of other elements is illegal.
pub fn safeIterator(head: *Self, comptime direction: Direction) SafeIterator(direction) {
return .{
.head = &head.link,
.current = &head.link,
.future = switch (direction) {
.forward => head.link.next.?,
.reverse => head.link.prev.?,
},
};
}
};
}
};
pub fn Listener(comptime T: type) type {
return extern struct {
const Self = @This();
pub const NotifyFn = if (T == void)
fn (listener: *Self) void
else
fn (listener: *Self, data: T) void;
link: list.Link,
notify: fn (listener: *Self, data: ?*c_void) callconv(.C) void,
pub fn init(comptime notify: NotifyFn) Self {
var self: Self = undefined;
self.setNotify(notify);
return self;
}
pub fn setNotify(self: *Self, comptime notify: NotifyFn) void {
self.notify = if (T == void)
struct {
fn wrapper(listener: *Self, _: ?*c_void) callconv(.C) void {
@call(.{ .modifier = .always_inline }, notify, .{listener});
}
}.wrapper
else
struct {
fn wrapper(listener: *Self, data: ?*c_void) callconv(.C) void {
@call(.{ .modifier = .always_inline }, notify, .{ listener, @intToPtr(T, @ptrToInt(data)) });
}
}.wrapper;
}
};
}
pub fn Signal(comptime T: type) type {
return extern struct {
const Self = @This();
listener_list: list.Head(Listener(T), "link"),
pub fn init(signal: *Self) void {
signal.listener_list.init();
}
pub fn add(signal: *Self, listener: *Listener(T)) void {
signal.listener_list.append(listener);
}
pub fn get(signal: *Self, notify: @TypeOf(Listener(T).notify)) ?*Listener(T) {
var it = signal.listener_list.iterator(.forward);
return while (it.next()) |listener| {
if (listener.notify == notify) break listener;
} else null;
}
pub const emit = if (T == void)
struct {
pub inline fn emit(signal: *Self) void {
emitInner(signal, null);
}
}.emit
else
struct {
pub inline fn emit(signal: *Self, data: T) void {
emitInner(signal, data);
}
}.emit;
/// This is similar to wlroots' wlr_signal_emit_safe. It handles
/// removal of any element in the list during iteration and stops at
/// whatever the last element was when iteration started.
fn emitInner(signal: *Self, data: ?*c_void) void {
var cursor: Listener(T) = undefined;
signal.listener_list.prepend(&cursor);
var end: Listener(T) = undefined;
signal.listener_list.append(&end);
while (cursor.link.next != &end.link) {
const pos = cursor.link.next.?;
const listener = @fieldParentPtr(Listener(T), "link", pos);
cursor.link.remove();
pos.insertAfter(&cursor.link);
listener.notify(listener, data);
}
cursor.link.remove();
end.link.remove();
}
};
}
pub const EventLoop = opaque {
extern fn wl_event_loop_create() ?*EventLoop;
pub fn create() !*EventLoop {
return wl_event_loop_create() orelse error.EventLoopCreateFailed;
}
extern fn wl_event_loop_destroy(loop: *EventLoop) void;
pub const destroy = wl_event_loop_destroy;
extern fn wl_event_loop_add_fd(
loop: *EventLoop,
fd: c_int,
mask: u32,
func: fn (fd: c_int, mask: u32, data: ?*c_void) callconv(.C) c_int,
data: ?*c_void,
) ?*EventSource;
pub inline fn addFd(
loop: *EventLoop,
comptime T: type,
fd: c_int,
mask: u32,
func: fn (fd: c_int, mask: u32, data: T) callconv(.C) c_int,
data: T,
) !*EventSource {
return wl_event_loop_add_fd(
loop,
fd,
mask,
@ptrCast(fn (fd: c_int, mask: u32, data: ?*c_void) callconv(.C) c_int, func),
data,
) orelse error.AddFdFailed;
}
extern fn wl_event_loop_add_timer(
loop: *EventLoop,
func: fn (data: ?*c_void) callconv(.C) c_int,
data: ?*c_void,
) ?*EventSource;
pub inline fn addTimer(
loop: *EventLoop,
comptime T: type,
func: fn (data: T) callconv(.C) c_int,
data: T,
) !*EventSource {
return wl_event_loop_add_timer(
loop,
@ptrCast(fn (?*c_void) callconv(.C) c_int, func),
data,
) orelse error.AddTimerFailed;
}
extern fn wl_event_loop_add_signal(
loop: *EventLoop,
signal_number: c_int,
func: fn (c_int, ?*c_void) callconv(.C) c_int,
data: ?*c_void,
) ?*EventSource;
pub inline fn addSignal(
loop: *EventLoop,
comptime T: type,
signal_number: c_int,
func: fn (signal_number: c_int, data: T) callconv(.C) c_int,
data: T,
) !*EventSource {
return wl_event_loop_add_signal(
loop,
signal_number,
@ptrCast(fn (c_int, ?*c_void) callconv(.C) c_int, func),
data,
) orelse error.AddSignalFailed;
}
extern fn wl_event_loop_add_idle(
loop: *EventLoop,
func: fn (data: ?*c_void) callconv(.C) void,
data: ?*c_void,
) ?*EventSource;
pub inline fn addIdle(
loop: *EventLoop,
comptime T: type,
func: fn (data: T) callconv(.C) void,
data: T,
) error{OutOfMemory}!*EventSource {
return wl_event_loop_add_idle(
loop,
@ptrCast(fn (?*c_void) callconv(.C) void, func),
data,
) orelse error.OutOfMemory;
}
extern fn wl_event_loop_dispatch(loop: *EventLoop, timeout: c_int) c_int;
pub fn dispatch(loop: *EventLoop, timeout: c_int) !void {
const rc = wl_event_loop_dispatch(loop, timeout);
switch (os.errno(rc)) {
0 => return,
// TODO
else => |err| return os.unexpectedErrno(err),
}
}
extern fn wl_event_loop_dispatch_idle(loop: *EventLoop) void;
pub const dispatchIdle = wl_event_loop_dispatch_idle;
extern fn wl_event_loop_get_fd(loop: *EventLoop) c_int;
pub const getFd = wl_event_loop_get_fd;
extern fn wl_event_loop_add_destroy_listener(loop: *EventLoop, listener: *Listener(*EventLoop)) void;
pub const addDestroyListener = wl_event_loop_add_destroy_listener;
//extern fn wl_event_loop_get_destroy_listener(loop: *EventLoop, notify: @TypeOf(Listener(*EventLoop).notify)) ?*Listener;
//pub const getDestroyListener = wl_event_loop_get_destroy_listener;
};
pub const EventSource = opaque {
extern fn wl_event_source_remove(source: *EventSource) c_int;
pub fn remove(source: *EventSource) void {
if (wl_event_source_remove(source) != 0) unreachable;
}
extern fn wl_event_source_check(source: *EventSource) void;
pub const check = wl_event_source_check;
extern fn wl_event_source_fd_update(source: *EventSource, mask: u32) c_int;
pub fn fdUpdate(source: *EventSource, mask: u32) !void {
const rc = wl_event_source_fd_update(source, mask);
switch (os.errno(rc)) {
0 => return,
// TODO
else => |err| return os.unexpectedErrno(err),
}
}
extern fn wl_event_source_timer_update(source: *EventSource, ms_delay: c_int) c_int;
pub fn timerUpdate(source: *EventSource, ms_delay: c_int) !void {
const rc = wl_event_source_timer_update(source, ms_delay);
switch (os.errno(rc)) {
0 => return,
// TODO
else => |err| return os.unexpectedErrno(err),
}
}
};
pub const shm = struct {
pub const Buffer = opaque {
extern fn wl_shm_buffer_get(resource: *Resource) ?*Buffer;
pub const get = wl_shm_buffer_get;
extern fn wl_shm_buffer_begin_access(buffer: *Buffer) void;
pub const beginAccess = wl_shm_buffer_begin_access;
extern fn wl_shm_buffer_end_access(buffer: *Buffer) void;
pub const endAccess = wl_shm_buffer_end_access;
extern fn wl_shm_buffer_get_data(buffer: *Buffer) ?*c_void;
pub const getData = wl_shm_buffer_get_data;
extern fn wl_shm_buffer_get_format(buffer: *Buffer) u32;
pub const getFormat = wl_shm_buffer_get_format;
extern fn wl_shm_buffer_get_height(buffer: *Buffer) i32;
pub const getHeight = wl_shm_buffer_get_height;
extern fn wl_shm_buffer_get_width(buffer: *Buffer) i32;
pub const getWidth = wl_shm_buffer_get_width;
extern fn wl_shm_buffer_get_stride(buffer: *Buffer) i32;
pub const getStride = wl_shm_buffer_get_stride;
extern fn wl_shm_buffer_ref_pool(buffer: *Buffer) *Pool;
pub const refPool = wl_shm_buffer_ref_pool;
};
pub const Pool = opaque {
extern fn wl_shm_pool_unref(pool: *Pool) void;
pub const unref = wl_shm_pool_unref;
};
}; | src/wayland_server_core.zig |
const std = @import( "std" );
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
pub usingnamespace @import( "c.zig" );
pub const GtkzError = error {
GenericFailure,
};
pub const GtkzHandlerConnection = struct {
instance: gpointer,
handlerId: gulong,
};
pub fn gtkzInit( allocator: *Allocator ) !void {
// TODO: Probably need some errdefers
var it = std.process.args( );
defer it.deinit( );
var args = ArrayList( [:0]u8 ).init( allocator );
defer {
for ( args.items ) |arg| {
allocator.free( arg );
}
args.deinit( );
}
var argsAsCstrs = ArrayList( [*c]u8 ).init( allocator );
defer argsAsCstrs.deinit( );
while ( true ) {
const arg = try ( it.next( allocator ) orelse break );
try args.append( arg );
try argsAsCstrs.append( arg.ptr );
}
var argc = @intCast( c_int, argsAsCstrs.items.len );
var argv = @as( [*c][*c]u8, argsAsCstrs.items.ptr );
if ( gtk_init_check( &argc, &argv ) != 1 ) {
return GtkzError.GenericFailure;
}
}
pub fn gtkzConnectHandler( instance: gpointer, signalName: [*c]const gchar, handlerFn: anytype, userData: gpointer ) !GtkzHandlerConnection {
return GtkzHandlerConnection {
.instance = instance,
.handlerId = try gtkz_signal_connect( instance, signalName, @ptrCast( GCallback, handlerFn ), userData ),
};
}
pub fn gtkzDisconnectHandlers( connections: []const GtkzHandlerConnection ) void {
for ( connections ) |conn| {
g_signal_handler_disconnect( conn.instance, conn.handlerId );
}
}
pub fn gtkzDrawWidgets( widgets: []*GtkWidget ) void {
for ( widgets ) |widget| {
gtk_widget_queue_draw( widget );
}
}
pub fn gtkzCloseWindows( windows: []*GtkWindow ) void {
for ( windows ) |window| {
gtk_window_close( window );
}
}
pub fn gtkzScaleFactor( widget: *GtkWidget ) f64 {
return @intToFloat( f64, gtk_widget_get_scale_factor( widget ) );
}
pub fn gtkzClickCount( ev: *GdkEventButton ) u32 {
return switch ( ev.type ) {
.GDK_BUTTON_PRESS => 1,
.GDK_2BUTTON_PRESS => 2,
.GDK_3BUTTON_PRESS => 3,
else => 0,
};
}
/// Y coord increases upward.
pub fn gtkzMousePos_PX( widget: *GtkWidget, ev: anytype ) [2]f64 {
// The event also knows what window and device it came from ...
// but ultimately the mouse is interacting with the contents of
// a widget, so it's the widget's scale factor (not the window's
// or the device's) that we care about here
const scale = gtkzScaleFactor( widget );
const h_LPX = @intToFloat( f64, gtk_widget_get_allocated_height( widget ) );
const mouse_LPX = switch ( @TypeOf( ev ) ) {
*GdkEventMotion => [_]f64 { ev.x, h_LPX - ev.y },
*GdkEventButton => [_]f64 { ev.x, h_LPX - ev.y },
*GdkEventScroll => [_]f64 { ev.x, h_LPX - ev.y },
else => @compileError( "Unsupported type: " ++ @typeName( @TypeOf( ev ) ) ),
};
var mouse_PX = @as( [2]f64, undefined );
for ( mouse_LPX ) |coord_LPX, n| {
// Scale, then add 0.5 to get the center of a physical pixel
mouse_PX[n] = scale*coord_LPX + 0.5;
}
return mouse_PX;
}
pub fn gtkzWheelSteps( ev: *GdkEventScroll ) f64 {
var direction: GdkScrollDirection = undefined;
if ( gdk_event_get_scroll_direction( @ptrCast( *GdkEvent, ev ), &direction ) != 0 ) {
return switch ( direction ) {
.GDK_SCROLL_UP => 1.0,
.GDK_SCROLL_DOWN => -1.0,
else => 0.0,
};
}
var xDelta: f64 = undefined;
var yDelta: f64 = undefined;
if ( gdk_event_get_scroll_deltas( @ptrCast( *GdkEvent, ev ), &xDelta, &yDelta ) != 0 ) {
return yDelta;
}
return 0.0;
}
pub fn gtkz_signal_connect( instance: gpointer, signalName: [*c]const gchar, handler: GCallback, userData: gpointer ) !gulong {
return gtkz_signal_connect_data( instance, signalName, handler, userData, null, .G_CONNECT_FLAGS_NONE );
}
pub fn gtkz_signal_connect_data( instance: gpointer, signalName: [*c]const gchar, handler: GCallback, userData: gpointer, userDataDestroyFn: GClosureNotify, flags: GConnectFlags ) !gulong {
const handlerId = g_signal_connect_data( instance, signalName, @ptrCast( GCallback, handler ), userData, userDataDestroyFn, flags );
return switch ( handlerId ) {
0 => GtkzError.GenericFailure,
else => handlerId,
};
}
pub const FullscreenKeysHandler = struct {
keyvals: []const guint,
pub fn init( keyvals: []const guint ) @This() {
return @This() {
.keyvals = keyvals,
};
}
pub fn onKeyDown( widget: *GtkWidget, ev: *GdkEventKey, self: *@This() ) callconv(.C) gboolean {
// TODO: Use a hash set
for ( self.keyvals ) |keyval| {
if ( ev.keyval == keyval ) {
const gtkAncestor = gtk_widget_get_toplevel( widget );
if ( gtk_widget_is_toplevel( gtkAncestor ) == 1 ) {
const gtkWindow = @ptrCast( *GtkWindow, gtkAncestor );
const gdkWindow = gtk_widget_get_window( gtkAncestor );
if ( gdkWindow != null ) {
const windowState = gdk_window_get_state( gdkWindow );
if ( @enumToInt( windowState ) & GDK_WINDOW_STATE_FULLSCREEN != 0 ) {
gtk_window_unfullscreen( gtkWindow );
// If mouse is not in the unfullscreened window, and using focus-
// follows-mouse, then the window loses focus, so call present to
// get focus back ... and the focus loss isn't quite immediate, so
// pass a timestep that tells the window manager that the "regain
// focus" comes AFTER the "lose focus"
gtk_window_present_with_time( gtkWindow, ev.time + 500 );
}
else {
gtk_window_fullscreen( gtkWindow );
}
return 1;
}
}
}
}
return 0;
}
};
pub const CloseKeysHandler = struct {
keyvals: []const guint,
pub fn init( keyvals: []const guint ) @This() {
return @This() {
.keyvals = keyvals,
};
}
pub fn onKeyDown( widget: *GtkWidget, ev: *GdkEventKey, self: *@This() ) callconv(.C) gboolean {
// TODO: Use a hash set
for ( self.keyvals ) |keyval| {
if ( ev.keyval == keyval ) {
const ancestor = gtk_widget_get_toplevel( widget );
if ( gtk_widget_is_toplevel( ancestor ) == 1 ) {
gtk_window_close( @ptrCast( *GtkWindow, ancestor ) );
return 1;
}
}
}
return 0;
}
};
pub const QuittingHandler = struct {
_ignored: u32 = undefined,
pub fn init( ) QuittingHandler {
return QuittingHandler {};
}
pub fn onWindowClosing( window: *GtkWindow, ev: *GdkEvent, self: *@This() ) callconv(.C) gboolean {
gtk_main_quit( );
return 0;
}
}; | src/core/gtkz.zig |
const basename = @import("basename.zig");
const dirname = @import("dirname.zig");
const fls = @import("false.zig");
const ls = @import("ls.zig");
const mkdir = @import("mkdir.zig");
const rm = @import("rm.zig");
const sleep = @import("sleep.zig");
const tail = @import("tail.zig");
const tru = @import("true.zig");
const head = @import("head.zig");
const wc = @import("wc.zig");
const zigsay = @import("zigsay.zig");
const cat = @import("cat.zig");
const std = @import("std");
const du = @import("du.zig");
const uniq = @import("uniq.zig");
const shuf = @import("shuf.zig");
const sha1 = @import("sha1.zig");
const sort = @import("sort.zig");
const pwd = @import("pwd.zig");
const stdout = &std.io.getStdOut().outStream();
const warn = std.debug.warn;
const testing = std.testing;
const assert = @import("std").debug.assert;
pub fn usage(args: [][]u8) anyerror!u8 {
try stdout.print(
\\Usage: ./pbui APPLET [arguments]
\\
\\Applets list:
\\basename
\\dirname
\\false
\\head
\\ls
\\mkdir
\\rm
\\sleep
\\tail
\\true
\\zigsay
\\cat
\\du
\\uniq
\\shuf
\\sha1
\\sort
\\pwd
\\
, .{});
const r: u8 = 1;
return r;
}
var func_map = std.StringHashMap(fn ([][]u8) anyerror!u8).init(std.heap.page_allocator);
pub fn main() anyerror!u8 {
const r: anyerror!u8 = 1;
// Out of memory panic
const args = std.process.argsAlloc(std.heap.page_allocator) catch |err| {
try stdout.print("Out of memory: {}\n", .{err});
return r;
};
defer std.process.argsFree(std.heap.page_allocator, args);
_ = try func_map.put("basename", basename.main);
_ = try func_map.put("false", fls.main);
_ = try func_map.put("dirname", dirname.main);
_ = try func_map.put("head", head.main);
_ = try func_map.put("mkdir", mkdir.main);
_ = try func_map.put("rm", rm.main);
_ = try func_map.put("sleep", sleep.main);
_ = try func_map.put("tail", tail.main);
_ = try func_map.put("true", tru.main);
_ = try func_map.put("wc", wc.main);
_ = try func_map.put("cat", cat.main);
_ = try func_map.put("zigsay", zigsay.main);
_ = try func_map.put("du", du.main);
_ = try func_map.put("uniq", uniq.main);
_ = try func_map.put("ls", ls.main);
_ = try func_map.put("shuf", shuf.main);
_ = try func_map.put("sha1", sha1.main);
_ = try func_map.put("sort", sort.main);
_ = try func_map.put("pwd", pwd.main);
// check basename of exe
var buffer: [100]u8 = undefined;
const allocator = &std.heap.FixedBufferAllocator.init(&buffer).allocator;
var empty = "";
var tes = try basename.basename(args[0], empty[0..], null, allocator);
// check if basename is right
var yeet = func_map.getValue(tes) orelse null;
if (yeet) |applet| {
return applet(args[0..]);
}
// otherwise check argv for applet name
if (args.len < 2 or std.mem.eql(u8, args[1], "-h") or std.mem.eql(u8, args[1], "--help")) {
return usage(args);
}
var applet_name = args[1];
var ab = func_map.getValue(applet_name) orelse usage;
return ab(args[1..]);
}
test "Test assertion: addition" {
std.debug.assert(3 + 7 == 10);
} | src/main.zig |
const c = @import("../../c_global.zig").c_imp;
const std = @import("std");
// dross-zig
const OpenGlError = @import("renderer_opengl.zig").OpenGlError;
const FileLoader = @import("../../utils/file_loader.zig");
const ShaderGl = @import("shader_opengl.zig").ShaderGl;
const Matrix4 = @import("../../core/matrix4.zig").Matrix4;
const Vector3 = @import("../../core/vector3.zig").Vector3;
const Vector2 = @import("../../core/vector2.zig").Vector2;
// -----------------------------------------
// -----------------------------------------
// - ShaderProgramGl -
// -----------------------------------------
/// The central point for the multiple shaders. The shaders are linked to this.
pub const ShaderProgramGl = struct {
/// OpenGL generated ID
handle: c_uint,
const Self = @This();
/// Allocates and build a ShaderProgramGl instance
/// Comments: The caller will own the allocated memory
pub fn new(allocator: *std.mem.Allocator) !*Self {
var self = try allocator.create(ShaderProgramGl);
self.handle = c.glCreateProgram();
return self;
}
/// Cleans up and de-allocates ShaderProgramGl instance
pub fn free(allocator: *std.mem.Allocator, self: *Self) void {
c.glDeleteProgram(self.handle);
allocator.destroy(self);
}
/// Attaches the requested shader to be used for rendering
pub fn attach(self: *Self, shader: *ShaderGl) void {
c.glAttachShader(self.handle, shader.id());
}
/// Links the shader program and checks for any errors
pub fn link(self: *Self) !void {
var no_errors: c_int = undefined;
var linking_log: [512]u8 = undefined;
c.glLinkProgram(self.handle);
c.glGetProgramiv(self.handle, c.GL_LINK_STATUS, &no_errors);
// If the linking failed, log the message
if (no_errors == 0) {
c.glGetProgramInfoLog(self.handle, 512, null, &linking_log);
std.log.err("[Renderer][OpenGL]: Failed to link shader program: \n{s}", .{linking_log});
return OpenGlError.ShaderLinkingFailure;
}
}
/// Tells OpenGL to make this the active pipeline
pub fn use(self: *Self) void {
c.glUseProgram(self.handle);
}
/// Sets a uniform boolean of `name` to the requested `value`
pub fn setBool(self: *Self, name: [*c]const u8, value: bool) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
const int_value: c_int = @intCast(c_int, @boolToInt(value));
c.glUniform1i(uniform_location, int_value);
}
/// Sets a uniform integer of `name` to the requested `value`
pub fn setInt(self: *Self, name: [*c]const u8, value: i32) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
const int_value: c_int = @intCast(c_int, value);
c.glUniform1i(uniform_location, int_value);
}
/// Sets a uniform integer of `name` to the requested `value`
pub fn setIntArray(self: *Self, name: [*c]const u8, values: []c_int, count: u32) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
//const int_value: c_uint = @intCast(c_uint, values);
const count_c: c_int = @intCast(c_int, count);
c.glUniform1iv(uniform_location, count_c, @ptrCast(*const c_int, &values[0]));
}
/// Sets a uniform float of `name` to the requested `value`
pub fn setFloat(self: *Self, name: [*c]const u8, value: f32) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
c.glUniform1f(uniform_location, value);
}
/// Sets a uniform vec3 of `name` to the corresponding values of the group of 3 floats
pub fn setFloat3(self: *Self, name: [*c]const u8, x: f32, y: f32, z: f32) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
c.glUniform3f(uniform_location, x, y, z);
}
/// Sets a uniform vec4 of `name` to the corresponding values of the group of 3 floats
pub fn setFloat4(self: *Self, name: [*c]const u8, x: f32, y: f32, z: f32, w: f32) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
c.glUniform4f(uniform_location, x, y, z, w);
}
/// Sets a uniform vec3 of `name` to the corresponding values of the group of 3 floats
pub fn setVector3(self: *Self, name: [*c]const u8, vector: Vector3) void {
const uniform_location: c_int = c.glGetUniformLocation(self.handle, name);
const data = vector.data.to_array();
const gl_error = c.glGetError();
if (gl_error != c.GL_NO_ERROR) {
std.debug.print("{}\n", .{gl_error});
}
c.glUniform3fv(
uniform_location, // Location
1, // Count
@ptrCast(*const f32, &data[0]), // Data
);
}
/// Sets a uniform mat4 of `name` to the requested `value`
pub fn setMatrix4(self: *Self, name: [*c]const u8, matrix: Matrix4) void {
const uniform_location = c.glGetUniformLocation(self.handle, name);
c.glUniformMatrix4fv(uniform_location, // Location
1, // Count
c.GL_FALSE, // Transpose
@ptrCast(*const f32, &matrix.data.data) // Data pointer
);
}
}; | src/renderer/backend/shader_program_opengl.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;
const AutoHashMap = std.AutoHashMap;
const StringHashMap = std.StringHashMap;
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const trim = std.mem.trim;
const parseInt = std.fmt.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;
const util = @import("util.zig");
const gpa = util.gpa;
const Answer = struct {
part1: u64,
part2: u64,
};
const Map = struct {
width: i32 = 0,
height: i32 = 0,
border: u8 = 0,
data: ArrayList(u8),
fn init(allocator: *Allocator) Map {
var data = ArrayList(u8).init(allocator);
return .{ .data = data };
}
fn deinit(self: *Map) void {
self.data.deinit();
}
fn cell(self: Map, row: i32, col: i32) u8 {
if (row < 0 or row >= self.height) return self.border;
if (col < 0 or col >= self.width) return self.border;
return self.data.items[@intCast(u32, row * self.height + col)];
}
fn setCell(self: *Map, row: i32, col: i32, val: u8) void {
self.data.items[@intCast(u32, row * self.height + col)] = val;
}
fn printMap(self: Map, bsize: i32) void {
var idx: i32 = -bsize;
while (idx < self.height + bsize) : (idx += 1) {
var jdx: i32 = -bsize;
while (jdx < self.width + bsize) : (jdx += 1) {
var c: u8 = ' ';
if (self.cell(idx, jdx) == 1) c = '#';
print("{c}", .{c});
}
print("\n", .{});
}
print("\n", .{});
}
};
fn compute(data: []const u8) Answer {
var lines = tokenize(data, "\r\n");
var rules_str = lines.next().?;
var rules: [512]u8 = std.mem.zeroes([512]u8);
for (rules_str) |c, idx| {
if (c == '#') rules[idx] = 1;
}
var map = Map.init(gpa);
defer map.deinit();
while (lines.next()) |line| {
var len = line.len;
map.height += 1;
map.width = @intCast(i32, len);
map.data.ensureUnusedCapacity(len) catch unreachable;
var arena = map.data.unusedCapacitySlice();
map.data.items.len += len;
for (line) |c, idx| {
if (c == '#') {
arena[idx] = 1;
} else {
arena[idx] = 0;
}
}
}
// map.printMap(2);
var answer = Answer{ .part1 = 0, .part2 = 0 };
var iteration: i32 = 0;
{
var max_iterations: i32 = 2;
while (iteration < max_iterations) : (iteration += 1) {
var new_map = Map.init(gpa);
defer new_map.deinit();
new_map.width = map.width + 2;
new_map.height = map.height + 2;
var new_len = @intCast(u32, new_map.width * new_map.height);
new_map.data.ensureCapacity(new_len) catch unreachable;
new_map.data.items.len = new_len;
new_map.border = map.border;
if (map.border == 0 and rules[0] == 1) new_map.border = 1;
if (map.border == 1 and rules[511] == 0) new_map.border = 0;
std.mem.set(u8, new_map.data.items, new_map.border);
var idx: i32 = 0;
while (idx < new_map.height) : (idx += 1) {
var jdx: i32 = 0;
while (jdx < new_map.width) : (jdx += 1) {
var mask: u9 = 0;
// zig fmt: off
mask |= @intCast(u9, map.cell(idx-2, jdx-2)) << 8;
mask |= @intCast(u9, map.cell(idx-2, jdx-1)) << 7;
mask |= @intCast(u9, map.cell(idx-2, jdx)) << 6;
mask |= @intCast(u9, map.cell(idx-1, jdx-2)) << 5;
mask |= @intCast(u9, map.cell(idx-1, jdx-1)) << 4;
mask |= @intCast(u9, map.cell(idx-1, jdx)) << 3;
mask |= @intCast(u9, map.cell(idx, jdx-2)) << 2;
mask |= @intCast(u9, map.cell(idx, jdx-1)) << 1;
mask |= @intCast(u9, map.cell(idx, jdx));
new_map.setCell(idx, jdx, rules[mask]);
// zig fmt: on
}
}
std.mem.swap(Map, &map, &new_map);
}
}
for (map.data.items) |c| {
answer.part1 += c;
}
{
var max_iterations: i32 = 50;
while (iteration < max_iterations) : (iteration += 1) {
var new_map = Map.init(gpa);
defer new_map.deinit();
new_map.width = map.width + 2;
new_map.height = map.height + 2;
var new_len = @intCast(u32, new_map.width * new_map.height);
new_map.data.ensureCapacity(new_len) catch unreachable;
new_map.data.items.len = new_len;
new_map.border = map.border;
if (map.border == 0 and rules[0] == 1) new_map.border = 1;
if (map.border == 1 and rules[511] == 0) new_map.border = 0;
std.mem.set(u8, new_map.data.items, new_map.border);
var idx: i32 = 0;
while (idx < new_map.height) : (idx += 1) {
var jdx: i32 = 0;
while (jdx < new_map.width) : (jdx += 1) {
var mask: u9 = 0;
// zig fmt: off
mask |= @intCast(u9, map.cell(idx-2, jdx-2)) << 8;
mask |= @intCast(u9, map.cell(idx-2, jdx-1)) << 7;
mask |= @intCast(u9, map.cell(idx-2, jdx)) << 6;
mask |= @intCast(u9, map.cell(idx-1, jdx-2)) << 5;
mask |= @intCast(u9, map.cell(idx-1, jdx-1)) << 4;
mask |= @intCast(u9, map.cell(idx-1, jdx)) << 3;
mask |= @intCast(u9, map.cell(idx, jdx-2)) << 2;
mask |= @intCast(u9, map.cell(idx, jdx-1)) << 1;
mask |= @intCast(u9, map.cell(idx, jdx));
new_map.setCell(idx, jdx, rules[mask]);
// zig fmt: on
}
}
std.mem.swap(Map, &map, &new_map);
}
}
for (map.data.items) |c| {
answer.part2 += c;
}
return answer;
}
pub fn main() !void {
const data = @embedFile("../data/puzzle/day20.txt");
// const data = @embedFile("../data/test/day20.txt");
var answer = compute(data);
print("Part 1: {}\n", .{answer.part1});
print("Part 2: {}\n", .{answer.part2});
}
test "sample data" {
const data = @embedFile("../data/test/day20.txt");
var answer = compute(data);
try std.testing.expectEqual(answer.part1, 35);
try std.testing.expectEqual(answer.part2, 3351);
} | src/day20.zig |
pub const MI_FLAG_ANY = @as(u32, 127);
pub const MI_FLAG_VERSION = @as(u32, 469762048);
pub const MI_FLAG_ADOPT = @as(u32, 2147483648);
pub const MI_FLAG_CLASS = @as(u32, 1);
pub const MI_FLAG_METHOD = @as(u32, 2);
pub const MI_FLAG_PROPERTY = @as(u32, 4);
pub const MI_FLAG_PARAMETER = @as(u32, 8);
pub const MI_FLAG_ASSOCIATION = @as(u32, 16);
pub const MI_FLAG_INDICATION = @as(u32, 32);
pub const MI_FLAG_REFERENCE = @as(u32, 64);
pub const MI_FLAG_ENABLEOVERRIDE = @as(u32, 128);
pub const MI_FLAG_DISABLEOVERRIDE = @as(u32, 256);
pub const MI_FLAG_RESTRICTED = @as(u32, 512);
pub const MI_FLAG_TOSUBCLASS = @as(u32, 1024);
pub const MI_FLAG_TRANSLATABLE = @as(u32, 2048);
pub const MI_FLAG_KEY = @as(u32, 4096);
pub const MI_FLAG_IN = @as(u32, 8192);
pub const MI_FLAG_OUT = @as(u32, 16384);
pub const MI_FLAG_REQUIRED = @as(u32, 32768);
pub const MI_FLAG_STATIC = @as(u32, 65536);
pub const MI_FLAG_ABSTRACT = @as(u32, 131072);
pub const MI_FLAG_TERMINAL = @as(u32, 262144);
pub const MI_FLAG_EXPENSIVE = @as(u32, 524288);
pub const MI_FLAG_STREAM = @as(u32, 1048576);
pub const MI_FLAG_READONLY = @as(u32, 2097152);
pub const MI_FLAG_EXTENDED = @as(u32, 4096);
pub const MI_FLAG_NOT_MODIFIED = @as(u32, 33554432);
pub const MI_FLAG_NULL = @as(u32, 536870912);
pub const MI_FLAG_BORROW = @as(u32, 1073741824);
pub const MI_MODULE_FLAG_STANDARD_QUALIFIERS = @as(u32, 1);
pub const MI_MODULE_FLAG_DESCRIPTIONS = @as(u32, 2);
pub const MI_MODULE_FLAG_VALUES = @as(u32, 4);
pub const MI_MODULE_FLAG_MAPPING_STRINGS = @as(u32, 8);
pub const MI_MODULE_FLAG_BOOLEANS = @as(u32, 16);
pub const MI_MODULE_FLAG_CPLUSPLUS = @as(u32, 32);
pub const MI_MODULE_FLAG_LOCALIZED = @as(u32, 64);
pub const MI_MODULE_FLAG_FILTER_SUPPORT = @as(u32, 128);
pub const MI_MAX_LOCALE_SIZE = @as(u32, 128);
pub const MI_WRITEMESSAGE_CHANNEL_WARNING = @as(u32, 0);
pub const MI_WRITEMESSAGE_CHANNEL_VERBOSE = @as(u32, 1);
pub const MI_WRITEMESSAGE_CHANNEL_DEBUG = @as(u32, 2);
pub const MI_CALL_VERSION = @as(u32, 1);
pub const MI_OPERATIONFLAGS_MANUAL_ACK_RESULTS = @as(u32, 1);
pub const MI_OPERATIONFLAGS_NO_RTTI = @as(u32, 1024);
pub const MI_OPERATIONFLAGS_BASIC_RTTI = @as(u32, 2);
pub const MI_OPERATIONFLAGS_STANDARD_RTTI = @as(u32, 2048);
pub const MI_OPERATIONFLAGS_FULL_RTTI = @as(u32, 4);
pub const MI_OPERATIONFLAGS_DEFAULT_RTTI = @as(u32, 0);
pub const MI_OPERATIONFLAGS_LOCALIZED_QUALIFIERS = @as(u32, 8);
pub const MI_OPERATIONFLAGS_EXPENSIVE_PROPERTIES = @as(u32, 64);
pub const MI_OPERATIONFLAGS_POLYMORPHISM_SHALLOW = @as(u32, 128);
pub const MI_OPERATIONFLAGS_POLYMORPHISM_DEEP_BASE_PROPS_ONLY = @as(u32, 384);
pub const MI_OPERATIONFLAGS_REPORT_OPERATION_STARTED = @as(u32, 512);
pub const MI_SERIALIZER_FLAGS_CLASS_DEEP = @as(u32, 1);
pub const MI_SERIALIZER_FLAGS_INSTANCE_WITH_CLASS = @as(u32, 1);
pub const WBEMS_DISPID_DERIVATION = @as(u32, 23);
pub const WBEMS_DISPID_OBJECT_READY = @as(u32, 1);
pub const WBEMS_DISPID_COMPLETED = @as(u32, 2);
pub const WBEMS_DISPID_PROGRESS = @as(u32, 3);
pub const WBEMS_DISPID_OBJECT_PUT = @as(u32, 4);
pub const WBEMS_DISPID_CONNECTION_READY = @as(u32, 5);
//--------------------------------------------------------------------------------
// Section: Types (370)
//--------------------------------------------------------------------------------
pub const MI_Result = enum(i32) {
OK = 0,
FAILED = 1,
ACCESS_DENIED = 2,
INVALID_NAMESPACE = 3,
INVALID_PARAMETER = 4,
INVALID_CLASS = 5,
NOT_FOUND = 6,
NOT_SUPPORTED = 7,
CLASS_HAS_CHILDREN = 8,
CLASS_HAS_INSTANCES = 9,
INVALID_SUPERCLASS = 10,
ALREADY_EXISTS = 11,
NO_SUCH_PROPERTY = 12,
TYPE_MISMATCH = 13,
QUERY_LANGUAGE_NOT_SUPPORTED = 14,
INVALID_QUERY = 15,
METHOD_NOT_AVAILABLE = 16,
METHOD_NOT_FOUND = 17,
NAMESPACE_NOT_EMPTY = 20,
INVALID_ENUMERATION_CONTEXT = 21,
INVALID_OPERATION_TIMEOUT = 22,
PULL_HAS_BEEN_ABANDONED = 23,
PULL_CANNOT_BE_ABANDONED = 24,
FILTERED_ENUMERATION_NOT_SUPPORTED = 25,
CONTINUATION_ON_ERROR_NOT_SUPPORTED = 26,
SERVER_LIMITS_EXCEEDED = 27,
SERVER_IS_SHUTTING_DOWN = 28,
};
pub const MI_RESULT_OK = MI_Result.OK;
pub const MI_RESULT_FAILED = MI_Result.FAILED;
pub const MI_RESULT_ACCESS_DENIED = MI_Result.ACCESS_DENIED;
pub const MI_RESULT_INVALID_NAMESPACE = MI_Result.INVALID_NAMESPACE;
pub const MI_RESULT_INVALID_PARAMETER = MI_Result.INVALID_PARAMETER;
pub const MI_RESULT_INVALID_CLASS = MI_Result.INVALID_CLASS;
pub const MI_RESULT_NOT_FOUND = MI_Result.NOT_FOUND;
pub const MI_RESULT_NOT_SUPPORTED = MI_Result.NOT_SUPPORTED;
pub const MI_RESULT_CLASS_HAS_CHILDREN = MI_Result.CLASS_HAS_CHILDREN;
pub const MI_RESULT_CLASS_HAS_INSTANCES = MI_Result.CLASS_HAS_INSTANCES;
pub const MI_RESULT_INVALID_SUPERCLASS = MI_Result.INVALID_SUPERCLASS;
pub const MI_RESULT_ALREADY_EXISTS = MI_Result.ALREADY_EXISTS;
pub const MI_RESULT_NO_SUCH_PROPERTY = MI_Result.NO_SUCH_PROPERTY;
pub const MI_RESULT_TYPE_MISMATCH = MI_Result.TYPE_MISMATCH;
pub const MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED = MI_Result.QUERY_LANGUAGE_NOT_SUPPORTED;
pub const MI_RESULT_INVALID_QUERY = MI_Result.INVALID_QUERY;
pub const MI_RESULT_METHOD_NOT_AVAILABLE = MI_Result.METHOD_NOT_AVAILABLE;
pub const MI_RESULT_METHOD_NOT_FOUND = MI_Result.METHOD_NOT_FOUND;
pub const MI_RESULT_NAMESPACE_NOT_EMPTY = MI_Result.NAMESPACE_NOT_EMPTY;
pub const MI_RESULT_INVALID_ENUMERATION_CONTEXT = MI_Result.INVALID_ENUMERATION_CONTEXT;
pub const MI_RESULT_INVALID_OPERATION_TIMEOUT = MI_Result.INVALID_OPERATION_TIMEOUT;
pub const MI_RESULT_PULL_HAS_BEEN_ABANDONED = MI_Result.PULL_HAS_BEEN_ABANDONED;
pub const MI_RESULT_PULL_CANNOT_BE_ABANDONED = MI_Result.PULL_CANNOT_BE_ABANDONED;
pub const MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED = MI_Result.FILTERED_ENUMERATION_NOT_SUPPORTED;
pub const MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED = MI_Result.CONTINUATION_ON_ERROR_NOT_SUPPORTED;
pub const MI_RESULT_SERVER_LIMITS_EXCEEDED = MI_Result.SERVER_LIMITS_EXCEEDED;
pub const MI_RESULT_SERVER_IS_SHUTTING_DOWN = MI_Result.SERVER_IS_SHUTTING_DOWN;
pub const MI_ErrorCategory = enum(i32) {
NOT_SPECIFIED = 0,
OPEN_ERROR = 1,
CLOS_EERROR = 2,
DEVICE_ERROR = 3,
DEADLOCK_DETECTED = 4,
INVALID_ARGUMENT = 5,
INVALID_DATA = 6,
INVALID_OPERATION = 7,
INVALID_RESULT = 8,
INVALID_TYPE = 9,
METADATA_ERROR = 10,
NOT_IMPLEMENTED = 11,
NOT_INSTALLED = 12,
OBJECT_NOT_FOUND = 13,
OPERATION_STOPPED = 14,
OPERATION_TIMEOUT = 15,
SYNTAX_ERROR = 16,
PARSER_ERROR = 17,
ACCESS_DENIED = 18,
RESOURCE_BUSY = 19,
RESOURCE_EXISTS = 20,
RESOURCE_UNAVAILABLE = 21,
READ_ERROR = 22,
WRITE_ERROR = 23,
FROM_STDERR = 24,
SECURITY_ERROR = 25,
PROTOCOL_ERROR = 26,
CONNECTION_ERROR = 27,
AUTHENTICATION_ERROR = 28,
LIMITS_EXCEEDED = 29,
QUOTA_EXCEEDED = 30,
NOT_ENABLED = 31,
};
pub const MI_ERRORCATEGORY_NOT_SPECIFIED = MI_ErrorCategory.NOT_SPECIFIED;
pub const MI_ERRORCATEGORY_OPEN_ERROR = MI_ErrorCategory.OPEN_ERROR;
pub const MI_ERRORCATEGORY_CLOS_EERROR = MI_ErrorCategory.CLOS_EERROR;
pub const MI_ERRORCATEGORY_DEVICE_ERROR = MI_ErrorCategory.DEVICE_ERROR;
pub const MI_ERRORCATEGORY_DEADLOCK_DETECTED = MI_ErrorCategory.DEADLOCK_DETECTED;
pub const MI_ERRORCATEGORY_INVALID_ARGUMENT = MI_ErrorCategory.INVALID_ARGUMENT;
pub const MI_ERRORCATEGORY_INVALID_DATA = MI_ErrorCategory.INVALID_DATA;
pub const MI_ERRORCATEGORY_INVALID_OPERATION = MI_ErrorCategory.INVALID_OPERATION;
pub const MI_ERRORCATEGORY_INVALID_RESULT = MI_ErrorCategory.INVALID_RESULT;
pub const MI_ERRORCATEGORY_INVALID_TYPE = MI_ErrorCategory.INVALID_TYPE;
pub const MI_ERRORCATEGORY_METADATA_ERROR = MI_ErrorCategory.METADATA_ERROR;
pub const MI_ERRORCATEGORY_NOT_IMPLEMENTED = MI_ErrorCategory.NOT_IMPLEMENTED;
pub const MI_ERRORCATEGORY_NOT_INSTALLED = MI_ErrorCategory.NOT_INSTALLED;
pub const MI_ERRORCATEGORY_OBJECT_NOT_FOUND = MI_ErrorCategory.OBJECT_NOT_FOUND;
pub const MI_ERRORCATEGORY_OPERATION_STOPPED = MI_ErrorCategory.OPERATION_STOPPED;
pub const MI_ERRORCATEGORY_OPERATION_TIMEOUT = MI_ErrorCategory.OPERATION_TIMEOUT;
pub const MI_ERRORCATEGORY_SYNTAX_ERROR = MI_ErrorCategory.SYNTAX_ERROR;
pub const MI_ERRORCATEGORY_PARSER_ERROR = MI_ErrorCategory.PARSER_ERROR;
pub const MI_ERRORCATEGORY_ACCESS_DENIED = MI_ErrorCategory.ACCESS_DENIED;
pub const MI_ERRORCATEGORY_RESOURCE_BUSY = MI_ErrorCategory.RESOURCE_BUSY;
pub const MI_ERRORCATEGORY_RESOURCE_EXISTS = MI_ErrorCategory.RESOURCE_EXISTS;
pub const MI_ERRORCATEGORY_RESOURCE_UNAVAILABLE = MI_ErrorCategory.RESOURCE_UNAVAILABLE;
pub const MI_ERRORCATEGORY_READ_ERROR = MI_ErrorCategory.READ_ERROR;
pub const MI_ERRORCATEGORY_WRITE_ERROR = MI_ErrorCategory.WRITE_ERROR;
pub const MI_ERRORCATEGORY_FROM_STDERR = MI_ErrorCategory.FROM_STDERR;
pub const MI_ERRORCATEGORY_SECURITY_ERROR = MI_ErrorCategory.SECURITY_ERROR;
pub const MI_ERRORCATEGORY_PROTOCOL_ERROR = MI_ErrorCategory.PROTOCOL_ERROR;
pub const MI_ERRORCATEGORY_CONNECTION_ERROR = MI_ErrorCategory.CONNECTION_ERROR;
pub const MI_ERRORCATEGORY_AUTHENTICATION_ERROR = MI_ErrorCategory.AUTHENTICATION_ERROR;
pub const MI_ERRORCATEGORY_LIMITS_EXCEEDED = MI_ErrorCategory.LIMITS_EXCEEDED;
pub const MI_ERRORCATEGORY_QUOTA_EXCEEDED = MI_ErrorCategory.QUOTA_EXCEEDED;
pub const MI_ERRORCATEGORY_NOT_ENABLED = MI_ErrorCategory.NOT_ENABLED;
pub const MI_PromptType = enum(i32) {
NORMAL = 0,
CRITICAL = 1,
};
pub const MI_PROMPTTYPE_NORMAL = MI_PromptType.NORMAL;
pub const MI_PROMPTTYPE_CRITICAL = MI_PromptType.CRITICAL;
pub const MI_CallbackMode = enum(i32) {
REPORT = 0,
INQUIRE = 1,
IGNORE = 2,
};
pub const MI_CALLBACKMODE_REPORT = MI_CallbackMode.REPORT;
pub const MI_CALLBACKMODE_INQUIRE = MI_CallbackMode.INQUIRE;
pub const MI_CALLBACKMODE_IGNORE = MI_CallbackMode.IGNORE;
pub const MI_ProviderArchitecture = enum(i32) {
@"32BIT" = 0,
@"64BIT" = 1,
};
pub const MI_PROVIDER_ARCHITECTURE_32BIT = MI_ProviderArchitecture.@"32BIT";
pub const MI_PROVIDER_ARCHITECTURE_64BIT = MI_ProviderArchitecture.@"64BIT";
pub const MI_Type = enum(i32) {
BOOLEAN = 0,
UINT8 = 1,
SINT8 = 2,
UINT16 = 3,
SINT16 = 4,
UINT32 = 5,
SINT32 = 6,
UINT64 = 7,
SINT64 = 8,
REAL32 = 9,
REAL64 = 10,
CHAR16 = 11,
DATETIME = 12,
STRING = 13,
REFERENCE = 14,
INSTANCE = 15,
BOOLEANA = 16,
UINT8A = 17,
SINT8A = 18,
UINT16A = 19,
SINT16A = 20,
UINT32A = 21,
SINT32A = 22,
UINT64A = 23,
SINT64A = 24,
REAL32A = 25,
REAL64A = 26,
CHAR16A = 27,
DATETIMEA = 28,
STRINGA = 29,
REFERENCEA = 30,
INSTANCEA = 31,
// ARRAY = 16, this enum value conflicts with BOOLEANA
};
pub const MI_BOOLEAN = MI_Type.BOOLEAN;
pub const MI_UINT8 = MI_Type.UINT8;
pub const MI_SINT8 = MI_Type.SINT8;
pub const MI_UINT16 = MI_Type.UINT16;
pub const MI_SINT16 = MI_Type.SINT16;
pub const MI_UINT32 = MI_Type.UINT32;
pub const MI_SINT32 = MI_Type.SINT32;
pub const MI_UINT64 = MI_Type.UINT64;
pub const MI_SINT64 = MI_Type.SINT64;
pub const MI_REAL32 = MI_Type.REAL32;
pub const MI_REAL64 = MI_Type.REAL64;
pub const MI_CHAR16 = MI_Type.CHAR16;
pub const MI_DATETIME = MI_Type.DATETIME;
pub const MI_STRING = MI_Type.STRING;
pub const MI_REFERENCE = MI_Type.REFERENCE;
pub const MI_INSTANCE = MI_Type.INSTANCE;
pub const MI_BOOLEANA = MI_Type.BOOLEANA;
pub const MI_UINT8A = MI_Type.UINT8A;
pub const MI_SINT8A = MI_Type.SINT8A;
pub const MI_UINT16A = MI_Type.UINT16A;
pub const MI_SINT16A = MI_Type.SINT16A;
pub const MI_UINT32A = MI_Type.UINT32A;
pub const MI_SINT32A = MI_Type.SINT32A;
pub const MI_UINT64A = MI_Type.UINT64A;
pub const MI_SINT64A = MI_Type.SINT64A;
pub const MI_REAL32A = MI_Type.REAL32A;
pub const MI_REAL64A = MI_Type.REAL64A;
pub const MI_CHAR16A = MI_Type.CHAR16A;
pub const MI_DATETIMEA = MI_Type.DATETIMEA;
pub const MI_STRINGA = MI_Type.STRINGA;
pub const MI_REFERENCEA = MI_Type.REFERENCEA;
pub const MI_INSTANCEA = MI_Type.INSTANCEA;
pub const MI_ARRAY = MI_Type.BOOLEANA;
pub const MI_Timestamp = extern struct {
year: u32,
month: u32,
day: u32,
hour: u32,
minute: u32,
second: u32,
microseconds: u32,
utc: i32,
};
pub const MI_Interval = extern struct {
days: u32,
hours: u32,
minutes: u32,
seconds: u32,
microseconds: u32,
__padding1: u32,
__padding2: u32,
__padding3: u32,
};
pub const MI_Datetime = extern struct {
isTimestamp: u32,
u: extern union {
timestamp: MI_Timestamp,
interval: MI_Interval,
},
};
pub const MI_BooleanA = extern struct {
data: ?*u8,
size: u32,
};
pub const MI_Uint8A = extern struct {
data: ?*u8,
size: u32,
};
pub const MI_Sint8A = extern struct {
data: ?*i8,
size: u32,
};
pub const MI_Uint16A = extern struct {
data: ?*u16,
size: u32,
};
pub const MI_Sint16A = extern struct {
data: ?*i16,
size: u32,
};
pub const MI_Uint32A = extern struct {
data: ?*u32,
size: u32,
};
pub const MI_Sint32A = extern struct {
data: ?*i32,
size: u32,
};
pub const MI_Uint64A = extern struct {
data: ?*u64,
size: u32,
};
pub const MI_Sint64A = extern struct {
data: ?*i64,
size: u32,
};
pub const MI_Real32A = extern struct {
data: ?*f32,
size: u32,
};
pub const MI_Real64A = extern struct {
data: ?*f64,
size: u32,
};
pub const MI_Char16A = extern struct {
data: ?*u16,
size: u32,
};
pub const MI_DatetimeA = extern struct {
data: ?*MI_Datetime,
size: u32,
};
pub const MI_StringA = extern struct {
data: ?*?*u16,
size: u32,
};
pub const MI_ReferenceA = extern struct {
data: ?*?*MI_Instance,
size: u32,
};
pub const MI_InstanceA = extern struct {
data: ?*?*MI_Instance,
size: u32,
};
pub const MI_Array = extern struct {
data: ?*anyopaque,
size: u32,
};
pub const MI_ConstBooleanA = extern struct {
data: ?*const u8,
size: u32,
};
pub const MI_ConstUint8A = extern struct {
data: ?*const u8,
size: u32,
};
pub const MI_ConstSint8A = extern struct {
data: ?*const i8,
size: u32,
};
pub const MI_ConstUint16A = extern struct {
data: ?*const u16,
size: u32,
};
pub const MI_ConstSint16A = extern struct {
data: ?*const i16,
size: u32,
};
pub const MI_ConstUint32A = extern struct {
data: ?*const u32,
size: u32,
};
pub const MI_ConstSint32A = extern struct {
data: ?*const i32,
size: u32,
};
pub const MI_ConstUint64A = extern struct {
data: ?*const u64,
size: u32,
};
pub const MI_ConstSint64A = extern struct {
data: ?*const i64,
size: u32,
};
pub const MI_ConstReal32A = extern struct {
data: ?*const f32,
size: u32,
};
pub const MI_ConstReal64A = extern struct {
data: ?*const f64,
size: u32,
};
pub const MI_ConstChar16A = extern struct {
data: ?*const u16,
size: u32,
};
pub const MI_ConstDatetimeA = extern struct {
data: ?*const MI_Datetime,
size: u32,
};
pub const MI_ConstStringA = extern struct {
data: ?*const ?*u16,
size: u32,
};
pub const MI_ConstReferenceA = extern struct {
data: ?*const ?*MI_Instance,
size: u32,
};
pub const MI_ConstInstanceA = extern struct {
data: ?*const ?*MI_Instance,
size: u32,
};
pub const MI_Value = extern union {
boolean: u8,
uint8: u8,
sint8: i8,
uint16: u16,
sint16: i16,
uint32: u32,
sint32: i32,
uint64: u64,
sint64: i64,
real32: f32,
real64: f64,
char16: u16,
datetime: MI_Datetime,
string: ?*u16,
instance: ?*MI_Instance,
reference: ?*MI_Instance,
booleana: MI_BooleanA,
uint8a: MI_Uint8A,
sint8a: MI_Sint8A,
uint16a: MI_Uint16A,
sint16a: MI_Sint16A,
uint32a: MI_Uint32A,
sint32a: MI_Sint32A,
uint64a: MI_Uint64A,
sint64a: MI_Sint64A,
real32a: MI_Real32A,
real64a: MI_Real64A,
char16a: MI_Char16A,
datetimea: MI_DatetimeA,
stringa: MI_StringA,
referencea: MI_ReferenceA,
instancea: MI_InstanceA,
array: MI_Array,
};
pub const MI_BooleanField = extern struct {
value: u8,
exists: u8,
flags: u8,
};
pub const MI_Sint8Field = extern struct {
value: i8,
exists: u8,
flags: u8,
};
pub const MI_Uint8Field = extern struct {
value: u8,
exists: u8,
flags: u8,
};
pub const MI_Sint16Field = extern struct {
value: i16,
exists: u8,
flags: u8,
};
pub const MI_Uint16Field = extern struct {
value: u16,
exists: u8,
flags: u8,
};
pub const MI_Sint32Field = extern struct {
value: i32,
exists: u8,
flags: u8,
};
pub const MI_Uint32Field = extern struct {
value: u32,
exists: u8,
flags: u8,
};
pub const MI_Sint64Field = extern struct {
value: i64,
exists: u8,
flags: u8,
};
pub const MI_Uint64Field = extern struct {
value: u64,
exists: u8,
flags: u8,
};
pub const MI_Real32Field = extern struct {
value: f32,
exists: u8,
flags: u8,
};
pub const MI_Real64Field = extern struct {
value: f64,
exists: u8,
flags: u8,
};
pub const MI_Char16Field = extern struct {
value: u16,
exists: u8,
flags: u8,
};
pub const MI_DatetimeField = extern struct {
value: MI_Datetime,
exists: u8,
flags: u8,
};
pub const MI_StringField = extern struct {
value: ?*u16,
exists: u8,
flags: u8,
};
pub const MI_ReferenceField = extern struct {
value: ?*MI_Instance,
exists: u8,
flags: u8,
};
pub const MI_InstanceField = extern struct {
value: ?*MI_Instance,
exists: u8,
flags: u8,
};
pub const MI_BooleanAField = extern struct {
value: MI_BooleanA,
exists: u8,
flags: u8,
};
pub const MI_Uint8AField = extern struct {
value: MI_Uint8A,
exists: u8,
flags: u8,
};
pub const MI_Sint8AField = extern struct {
value: MI_Sint8A,
exists: u8,
flags: u8,
};
pub const MI_Uint16AField = extern struct {
value: MI_Uint16A,
exists: u8,
flags: u8,
};
pub const MI_Sint16AField = extern struct {
value: MI_Sint16A,
exists: u8,
flags: u8,
};
pub const MI_Uint32AField = extern struct {
value: MI_Uint32A,
exists: u8,
flags: u8,
};
pub const MI_Sint32AField = extern struct {
value: MI_Sint32A,
exists: u8,
flags: u8,
};
pub const MI_Uint64AField = extern struct {
value: MI_Uint64A,
exists: u8,
flags: u8,
};
pub const MI_Sint64AField = extern struct {
value: MI_Sint64A,
exists: u8,
flags: u8,
};
pub const MI_Real32AField = extern struct {
value: MI_Real32A,
exists: u8,
flags: u8,
};
pub const MI_Real64AField = extern struct {
value: MI_Real64A,
exists: u8,
flags: u8,
};
pub const MI_Char16AField = extern struct {
value: MI_Char16A,
exists: u8,
flags: u8,
};
pub const MI_DatetimeAField = extern struct {
value: MI_DatetimeA,
exists: u8,
flags: u8,
};
pub const MI_StringAField = extern struct {
value: MI_StringA,
exists: u8,
flags: u8,
};
pub const MI_ReferenceAField = extern struct {
value: MI_ReferenceA,
exists: u8,
flags: u8,
};
pub const MI_InstanceAField = extern struct {
value: MI_InstanceA,
exists: u8,
flags: u8,
};
pub const MI_ArrayField = extern struct {
value: MI_Array,
exists: u8,
flags: u8,
};
pub const MI_ConstBooleanField = extern struct {
value: u8,
exists: u8,
flags: u8,
};
pub const MI_ConstSint8Field = extern struct {
value: i8,
exists: u8,
flags: u8,
};
pub const MI_ConstUint8Field = extern struct {
value: u8,
exists: u8,
flags: u8,
};
pub const MI_ConstSint16Field = extern struct {
value: i16,
exists: u8,
flags: u8,
};
pub const MI_ConstUint16Field = extern struct {
value: u16,
exists: u8,
flags: u8,
};
pub const MI_ConstSint32Field = extern struct {
value: i32,
exists: u8,
flags: u8,
};
pub const MI_ConstUint32Field = extern struct {
value: u32,
exists: u8,
flags: u8,
};
pub const MI_ConstSint64Field = extern struct {
value: i64,
exists: u8,
flags: u8,
};
pub const MI_ConstUint64Field = extern struct {
value: u64,
exists: u8,
flags: u8,
};
pub const MI_ConstReal32Field = extern struct {
value: f32,
exists: u8,
flags: u8,
};
pub const MI_ConstReal64Field = extern struct {
value: f64,
exists: u8,
flags: u8,
};
pub const MI_ConstChar16Field = extern struct {
value: u16,
exists: u8,
flags: u8,
};
pub const MI_ConstDatetimeField = extern struct {
value: MI_Datetime,
exists: u8,
flags: u8,
};
pub const MI_ConstStringField = extern struct {
value: ?*const u16,
exists: u8,
flags: u8,
};
pub const MI_ConstReferenceField = extern struct {
value: ?*const MI_Instance,
exists: u8,
flags: u8,
};
pub const MI_ConstInstanceField = extern struct {
value: ?*const MI_Instance,
exists: u8,
flags: u8,
};
pub const MI_ConstBooleanAField = extern struct {
value: MI_ConstBooleanA,
exists: u8,
flags: u8,
};
pub const MI_ConstUint8AField = extern struct {
value: MI_ConstUint8A,
exists: u8,
flags: u8,
};
pub const MI_ConstSint8AField = extern struct {
value: MI_ConstSint8A,
exists: u8,
flags: u8,
};
pub const MI_ConstUint16AField = extern struct {
value: MI_ConstUint16A,
exists: u8,
flags: u8,
};
pub const MI_ConstSint16AField = extern struct {
value: MI_ConstSint16A,
exists: u8,
flags: u8,
};
pub const MI_ConstUint32AField = extern struct {
value: MI_ConstUint32A,
exists: u8,
flags: u8,
};
pub const MI_ConstSint32AField = extern struct {
value: MI_ConstSint32A,
exists: u8,
flags: u8,
};
pub const MI_ConstUint64AField = extern struct {
value: MI_ConstUint64A,
exists: u8,
flags: u8,
};
pub const MI_ConstSint64AField = extern struct {
value: MI_ConstSint64A,
exists: u8,
flags: u8,
};
pub const MI_ConstReal32AField = extern struct {
value: MI_ConstReal32A,
exists: u8,
flags: u8,
};
pub const MI_ConstReal64AField = extern struct {
value: MI_ConstReal64A,
exists: u8,
flags: u8,
};
pub const MI_ConstChar16AField = extern struct {
value: MI_ConstChar16A,
exists: u8,
flags: u8,
};
pub const MI_ConstDatetimeAField = extern struct {
value: MI_ConstDatetimeA,
exists: u8,
flags: u8,
};
pub const MI_ConstStringAField = extern struct {
value: MI_ConstStringA,
exists: u8,
flags: u8,
};
pub const MI_ConstReferenceAField = extern struct {
value: MI_ConstReferenceA,
exists: u8,
flags: u8,
};
pub const MI_ConstInstanceAField = extern struct {
value: MI_ConstInstanceA,
exists: u8,
flags: u8,
};
pub const MI_ServerFT = extern struct {
GetVersion: isize,
GetSystemName: isize,
};
pub const MI_Server = extern struct {
serverFT: ?*const MI_ServerFT,
contextFT: ?*const MI_ContextFT,
instanceFT: ?*const MI_InstanceFT,
propertySetFT: ?*const MI_PropertySetFT,
filterFT: ?*const MI_FilterFT,
};
pub const MI_FilterFT = extern struct {
Evaluate: isize,
GetExpression: isize,
};
pub const MI_Filter = extern struct {
ft: ?*const MI_FilterFT,
reserved: [3]isize,
};
pub const MI_PropertySetFT = extern struct {
GetElementCount: isize,
ContainsElement: isize,
AddElement: isize,
GetElementAt: isize,
Clear: isize,
Destruct: isize,
Delete: isize,
Clone: isize,
};
pub const MI_PropertySet = extern struct {
ft: ?*const MI_PropertySetFT,
reserved: [3]isize,
};
pub const MI_ObjectDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
properties: ?*const ?*MI_PropertyDecl,
numProperties: u32,
size: u32,
};
pub const MI_ClassDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
properties: ?*const ?*MI_PropertyDecl,
numProperties: u32,
size: u32,
superClass: ?*const u16,
superClassDecl: ?*const MI_ClassDecl,
methods: ?*const ?*MI_MethodDecl,
numMethods: u32,
schema: ?*const MI_SchemaDecl,
providerFT: ?*const MI_ProviderFT,
owningClass: ?*MI_Class,
};
pub const MI_FeatureDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
};
pub const MI_ParameterDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
type: u32,
className: ?*const u16,
subscript: u32,
offset: u32,
};
pub const MI_PropertyDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
type: u32,
className: ?*const u16,
subscript: u32,
offset: u32,
origin: ?*const u16,
propagator: ?*const u16,
value: ?*const anyopaque,
};
pub const MI_MethodDecl_Invoke = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
methodName: ?*const u16,
instanceName: ?*const MI_Instance,
parameters: ?*const MI_Instance,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_MethodDecl = extern struct {
flags: u32,
code: u32,
name: ?*const u16,
qualifiers: ?*const ?*MI_Qualifier,
numQualifiers: u32,
parameters: ?*const ?*MI_ParameterDecl,
numParameters: u32,
size: u32,
returnType: u32,
origin: ?*const u16,
propagator: ?*const u16,
schema: ?*const MI_SchemaDecl,
function: ?MI_MethodDecl_Invoke,
};
pub const MI_QualifierDecl = extern struct {
name: ?*const u16,
type: u32,
scope: u32,
flavor: u32,
subscript: u32,
value: ?*const anyopaque,
};
pub const MI_Qualifier = extern struct {
name: ?*const u16,
type: u32,
flavor: u32,
value: ?*const anyopaque,
};
pub const MI_SchemaDecl = extern struct {
qualifierDecls: ?*const ?*MI_QualifierDecl,
numQualifierDecls: u32,
classDecls: ?*const ?*MI_ClassDecl,
numClassDecls: u32,
};
pub const MI_Module_Self = extern struct {
placeholder: usize, // TODO: why is this type empty?
};
pub const MI_ProviderFT_Load = fn(
self: ?*?*anyopaque,
selfModule: ?*MI_Module_Self,
context: ?*MI_Context,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_Unload = fn(
self: ?*anyopaque,
context: ?*MI_Context,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_GetInstance = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
instanceName: ?*const MI_Instance,
propertySet: ?*const MI_PropertySet,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_EnumerateInstances = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
propertySet: ?*const MI_PropertySet,
keysOnly: u8,
filter: ?*const MI_Filter,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_CreateInstance = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
newInstance: ?*const MI_Instance,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_ModifyInstance = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
modifiedInstance: ?*const MI_Instance,
propertySet: ?*const MI_PropertySet,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_DeleteInstance = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
instanceName: ?*const MI_Instance,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_AssociatorInstances = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
instanceName: ?*const MI_Instance,
resultClass: ?*const u16,
role: ?*const u16,
resultRole: ?*const u16,
propertySet: ?*const MI_PropertySet,
keysOnly: u8,
filter: ?*const MI_Filter,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_ReferenceInstances = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
instanceName: ?*const MI_Instance,
role: ?*const u16,
propertySet: ?*const MI_PropertySet,
keysOnly: u8,
filter: ?*const MI_Filter,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_EnableIndications = fn(
self: ?*anyopaque,
indicationsContext: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_DisableIndications = fn(
self: ?*anyopaque,
indicationsContext: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_Subscribe = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
filter: ?*const MI_Filter,
bookmark: ?*const u16,
subscriptionID: u64,
subscriptionSelf: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_Unsubscribe = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
subscriptionID: u64,
subscriptionSelf: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT_Invoke = fn(
self: ?*anyopaque,
context: ?*MI_Context,
nameSpace: ?*const u16,
className: ?*const u16,
methodName: ?*const u16,
instanceName: ?*const MI_Instance,
inputParameters: ?*const MI_Instance,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ProviderFT = extern struct {
Load: ?MI_ProviderFT_Load,
Unload: ?MI_ProviderFT_Unload,
GetInstance: ?MI_ProviderFT_GetInstance,
EnumerateInstances: ?MI_ProviderFT_EnumerateInstances,
CreateInstance: ?MI_ProviderFT_CreateInstance,
ModifyInstance: ?MI_ProviderFT_ModifyInstance,
DeleteInstance: ?MI_ProviderFT_DeleteInstance,
AssociatorInstances: ?MI_ProviderFT_AssociatorInstances,
ReferenceInstances: ?MI_ProviderFT_ReferenceInstances,
EnableIndications: ?MI_ProviderFT_EnableIndications,
DisableIndications: ?MI_ProviderFT_DisableIndications,
Subscribe: ?MI_ProviderFT_Subscribe,
Unsubscribe: ?MI_ProviderFT_Unsubscribe,
Invoke: ?MI_ProviderFT_Invoke,
};
pub const MI_Module_Load = fn(
self: ?*?*MI_Module_Self,
context: ?*MI_Context,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_Module_Unload = fn(
self: ?*MI_Module_Self,
context: ?*MI_Context,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_Module = extern struct {
version: u32,
generatorVersion: u32,
flags: u32,
charSize: u32,
schemaDecl: ?*MI_SchemaDecl,
Load: ?MI_Module_Load,
Unload: ?MI_Module_Unload,
dynamicProviderFT: ?*const MI_ProviderFT,
};
pub const MI_InstanceFT = extern struct {
Clone: isize,
Destruct: isize,
Delete: isize,
IsA: isize,
GetClassNameA: isize,
SetNameSpace: isize,
GetNameSpace: isize,
GetElementCount: isize,
AddElement: isize,
SetElement: isize,
SetElementAt: isize,
GetElement: isize,
GetElementAt: isize,
ClearElement: isize,
ClearElementAt: isize,
GetServerName: isize,
SetServerName: isize,
GetClass: isize,
};
pub const MI_InstanceExFT = extern struct {
parent: MI_InstanceFT,
Normalize: isize,
};
pub const MI_Instance = extern struct {
ft: ?*const MI_InstanceFT,
classDecl: ?*const MI_ClassDecl,
serverName: ?*const u16,
nameSpace: ?*const u16,
reserved: [4]isize,
};
pub const MI_LocaleType = enum(i32) {
REQUESTED_UI = 0,
REQUESTED_DATA = 1,
CLOSEST_UI = 2,
CLOSEST_DATA = 3,
};
pub const MI_LOCALE_TYPE_REQUESTED_UI = MI_LocaleType.REQUESTED_UI;
pub const MI_LOCALE_TYPE_REQUESTED_DATA = MI_LocaleType.REQUESTED_DATA;
pub const MI_LOCALE_TYPE_CLOSEST_UI = MI_LocaleType.CLOSEST_UI;
pub const MI_LOCALE_TYPE_CLOSEST_DATA = MI_LocaleType.CLOSEST_DATA;
pub const MI_CancellationReason = enum(i32) {
NONE = 0,
TIMEOUT = 1,
SHUTDOWN = 2,
SERVICESTOP = 3,
};
pub const MI_REASON_NONE = MI_CancellationReason.NONE;
pub const MI_REASON_TIMEOUT = MI_CancellationReason.TIMEOUT;
pub const MI_REASON_SHUTDOWN = MI_CancellationReason.SHUTDOWN;
pub const MI_REASON_SERVICESTOP = MI_CancellationReason.SERVICESTOP;
pub const MI_CancelCallback = fn(
reason: MI_CancellationReason,
callbackData: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_ContextFT = extern struct {
PostResult: isize,
PostInstance: isize,
PostIndication: isize,
ConstructInstance: isize,
ConstructParameters: isize,
NewInstance: isize,
NewDynamicInstance: isize,
NewParameters: isize,
Canceled: isize,
GetLocale: isize,
RegisterCancel: isize,
RequestUnload: isize,
RefuseUnload: isize,
GetLocalSession: isize,
SetStringOption: isize,
GetStringOption: isize,
GetNumberOption: isize,
GetCustomOption: isize,
GetCustomOptionCount: isize,
GetCustomOptionAt: isize,
WriteMessage: isize,
WriteProgress: isize,
WriteStreamParameter: isize,
WriteCimError: isize,
PromptUser: isize,
ShouldProcess: isize,
ShouldContinue: isize,
PostError: isize,
PostCimError: isize,
WriteError: isize,
};
pub const MI_Context = extern struct {
ft: ?*const MI_ContextFT,
reserved: [3]isize,
};
pub const MI_MainFunction = fn(
server: ?*MI_Server,
) callconv(@import("std").os.windows.WINAPI) ?*MI_Module;
pub const MI_QualifierSetFT = extern struct {
GetQualifierCount: isize,
GetQualifierAt: isize,
GetQualifier: isize,
};
pub const MI_QualifierSet = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_QualifierSetFT,
};
pub const MI_ParameterSetFT = extern struct {
GetMethodReturnType: isize,
GetParameterCount: isize,
GetParameterAt: isize,
GetParameter: isize,
};
pub const MI_ParameterSet = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_ParameterSetFT,
};
pub const MI_ClassFT = extern struct {
GetClassNameA: isize,
GetNameSpace: isize,
GetServerName: isize,
GetElementCount: isize,
GetElement: isize,
GetElementAt: isize,
GetClassQualifierSet: isize,
GetMethodCount: isize,
GetMethodAt: isize,
GetMethod: isize,
GetParentClassName: isize,
GetParentClass: isize,
Delete: isize,
Clone: isize,
};
pub const MI_Class = extern struct {
ft: ?*const MI_ClassFT,
classDecl: ?*const MI_ClassDecl,
namespaceName: ?*const u16,
serverName: ?*const u16,
reserved: [4]isize,
};
pub const MI_OperationCallback_ResponseType = enum(i32) {
No = 0,
Yes = 1,
NoToAll = 2,
YesToAll = 3,
};
pub const MI_OperationCallback_ResponseType_No = MI_OperationCallback_ResponseType.No;
pub const MI_OperationCallback_ResponseType_Yes = MI_OperationCallback_ResponseType.Yes;
pub const MI_OperationCallback_ResponseType_NoToAll = MI_OperationCallback_ResponseType.NoToAll;
pub const MI_OperationCallback_ResponseType_YesToAll = MI_OperationCallback_ResponseType.YesToAll;
pub const MI_OperationCallback_PromptUser = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
message: ?*const u16,
promptType: MI_PromptType,
promptUserResult: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_WriteError = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
instance: ?*MI_Instance,
writeErrorResult: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_WriteMessage = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
channel: u32,
message: ?*const u16,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_WriteProgress = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
activity: ?*const u16,
currentOperation: ?*const u16,
statusDescription: ?*const u16,
percentageComplete: u32,
secondsRemaining: u32,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_Instance = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
instance: ?*const MI_Instance,
moreResults: u8,
resultCode: MI_Result,
errorString: ?*const u16,
errorDetails: ?*const MI_Instance,
resultAcknowledgement: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_StreamedParameter = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
parameterName: ?*const u16,
resultType: MI_Type,
result: ?*const MI_Value,
resultAcknowledgement: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_Indication = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
instance: ?*const MI_Instance,
bookmark: ?*const u16,
machineID: ?*const u16,
moreResults: u8,
resultCode: MI_Result,
errorString: ?*const u16,
errorDetails: ?*const MI_Instance,
resultAcknowledgement: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallback_Class = fn(
operation: ?*MI_Operation,
callbackContext: ?*anyopaque,
classResult: ?*const MI_Class,
moreResults: u8,
resultCode: MI_Result,
errorString: ?*const u16,
errorDetails: ?*const MI_Instance,
resultAcknowledgement: isize,
) callconv(@import("std").os.windows.WINAPI) void;
pub const MI_OperationCallbacks = extern struct {
callbackContext: ?*anyopaque,
promptUser: ?MI_OperationCallback_PromptUser,
writeError: ?MI_OperationCallback_WriteError,
writeMessage: ?MI_OperationCallback_WriteMessage,
writeProgress: ?MI_OperationCallback_WriteProgress,
instanceResult: ?MI_OperationCallback_Instance,
indicationResult: ?MI_OperationCallback_Indication,
classResult: ?MI_OperationCallback_Class,
streamedParameterResult: ?MI_OperationCallback_StreamedParameter,
};
pub const MI_SessionCallbacks = extern struct {
callbackContext: ?*anyopaque,
writeMessage: isize,
writeError: isize,
};
pub const MI_UsernamePasswordCreds = extern struct {
domain: ?*const u16,
username: ?*const u16,
password: ?*const u16,
};
pub const MI_UserCredentials = extern struct {
authenticationType: ?*const u16,
credentials: extern union {
usernamePassword: MI_UsernamePasswordCreds,
certificateThumbprint: ?*const u16,
},
};
pub const MI_SubscriptionDeliveryType = enum(i32) {
ll = 1,
sh = 2,
};
pub const MI_SubscriptionDeliveryType_Pull = MI_SubscriptionDeliveryType.ll;
pub const MI_SubscriptionDeliveryType_Push = MI_SubscriptionDeliveryType.sh;
pub const MI_SubscriptionDeliveryOptionsFT = extern struct {
SetString: isize,
SetNumber: isize,
SetDateTime: isize,
SetInterval: isize,
AddCredentials: isize,
Delete: isize,
GetString: isize,
GetNumber: isize,
GetDateTime: isize,
GetInterval: isize,
GetOptionCount: isize,
GetOptionAt: isize,
GetOption: isize,
GetCredentialsCount: isize,
GetCredentialsAt: isize,
GetCredentialsPasswordAt: isize,
Clone: isize,
};
pub const MI_SubscriptionDeliveryOptions = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_SubscriptionDeliveryOptionsFT,
};
pub const MI_Serializer = extern struct {
reserved1: u64,
reserved2: isize,
};
pub const MI_Deserializer = extern struct {
reserved1: u64,
reserved2: isize,
};
pub const MI_SerializerFT = extern struct {
Close: isize,
SerializeClass: isize,
SerializeInstance: isize,
};
pub const MI_Deserializer_ClassObjectNeeded = fn(
context: ?*anyopaque,
serverName: ?*const u16,
namespaceName: ?*const u16,
className: ?*const u16,
requestedClassObject: ?*?*MI_Class,
) callconv(@import("std").os.windows.WINAPI) MI_Result;
pub const MI_DeserializerFT = extern struct {
Close: isize,
DeserializeClass: isize,
Class_GetClassName: isize,
Class_GetParentClassName: isize,
DeserializeInstance: isize,
Instance_GetClassName: isize,
};
pub const MI_ApplicationFT = extern struct {
Close: isize,
NewSession: isize,
NewHostedProvider: isize,
NewInstance: isize,
NewDestinationOptions: isize,
NewOperationOptions: isize,
NewSubscriptionDeliveryOptions: isize,
NewSerializer: isize,
NewDeserializer: isize,
NewInstanceFromClass: isize,
NewClass: isize,
};
pub const MI_HostedProviderFT = extern struct {
Close: isize,
GetApplication: isize,
};
pub const MI_SessionFT = extern struct {
Close: isize,
GetApplication: isize,
GetInstance: isize,
ModifyInstance: isize,
CreateInstance: isize,
DeleteInstance: isize,
Invoke: isize,
EnumerateInstances: isize,
QueryInstances: isize,
AssociatorInstances: isize,
ReferenceInstances: isize,
Subscribe: isize,
GetClass: isize,
EnumerateClasses: isize,
TestConnection: isize,
};
pub const MI_OperationFT = extern struct {
Close: isize,
Cancel: isize,
GetSession: isize,
GetInstance: isize,
GetIndication: isize,
GetClass: isize,
};
pub const MI_DestinationOptionsFT = extern struct {
Delete: isize,
SetString: isize,
SetNumber: isize,
AddCredentials: isize,
GetString: isize,
GetNumber: isize,
GetOptionCount: isize,
GetOptionAt: isize,
GetOption: isize,
GetCredentialsCount: isize,
GetCredentialsAt: isize,
GetCredentialsPasswordAt: isize,
Clone: isize,
SetInterval: isize,
GetInterval: isize,
};
pub const MI_OperationOptionsFT = extern struct {
Delete: isize,
SetString: isize,
SetNumber: isize,
SetCustomOption: isize,
GetString: isize,
GetNumber: isize,
GetOptionCount: isize,
GetOptionAt: isize,
GetOption: isize,
GetEnabledChannels: isize,
Clone: isize,
SetInterval: isize,
GetInterval: isize,
};
pub const MI_Application = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_ApplicationFT,
};
pub const MI_Session = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_SessionFT,
};
pub const MI_Operation = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_OperationFT,
};
pub const MI_HostedProvider = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_HostedProviderFT,
};
pub const MI_DestinationOptions = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_DestinationOptionsFT,
};
pub const MI_OperationOptions = extern struct {
reserved1: u64,
reserved2: isize,
ft: ?*const MI_OperationOptionsFT,
};
pub const MI_UtilitiesFT = extern struct {
MapErrorToMiErrorCategory: isize,
CimErrorFromErrorCode: isize,
};
pub const MI_ClientFT_V1 = extern struct {
applicationFT: ?*const MI_ApplicationFT,
sessionFT: ?*const MI_SessionFT,
operationFT: ?*const MI_OperationFT,
hostedProviderFT: ?*const MI_HostedProviderFT,
serializerFT: ?*const MI_SerializerFT,
deserializerFT: ?*const MI_DeserializerFT,
subscribeDeliveryOptionsFT: ?*const MI_SubscriptionDeliveryOptionsFT,
destinationOptionsFT: ?*const MI_DestinationOptionsFT,
operationOptionsFT: ?*const MI_OperationOptionsFT,
utilitiesFT: ?*const MI_UtilitiesFT,
};
pub const MI_DestinationOptions_ImpersonationType = enum(i32) {
Default = 0,
None = 1,
Identify = 2,
Impersonate = 3,
Delegate = 4,
};
pub const MI_DestinationOptions_ImpersonationType_Default = MI_DestinationOptions_ImpersonationType.Default;
pub const MI_DestinationOptions_ImpersonationType_None = MI_DestinationOptions_ImpersonationType.None;
pub const MI_DestinationOptions_ImpersonationType_Identify = MI_DestinationOptions_ImpersonationType.Identify;
pub const MI_DestinationOptions_ImpersonationType_Impersonate = MI_DestinationOptions_ImpersonationType.Impersonate;
pub const MI_DestinationOptions_ImpersonationType_Delegate = MI_DestinationOptions_ImpersonationType.Delegate;
const CLSID_WbemDefPath_Value = @import("../zig.zig").Guid.initString("cf4cc405-e2c5-4ddd-b3ce-5e7582d8c9fa");
pub const CLSID_WbemDefPath = &CLSID_WbemDefPath_Value;
const CLSID_WbemQuery_Value = @import("../zig.zig").Guid.initString("eac8a024-21e2-4523-ad73-a71a0aa2f56a");
pub const CLSID_WbemQuery = &CLSID_WbemQuery_Value;
pub const WBEM_PATH_STATUS_FLAG = enum(i32) {
ANON_LOCAL_MACHINE = 1,
HAS_MACHINE_NAME = 2,
IS_CLASS_REF = 4,
IS_INST_REF = 8,
HAS_SUBSCOPES = 16,
IS_COMPOUND = 32,
HAS_V2_REF_PATHS = 64,
HAS_IMPLIED_KEY = 128,
CONTAINS_SINGLETON = 256,
V1_COMPLIANT = 512,
V2_COMPLIANT = 1024,
CIM_COMPLIANT = 2048,
IS_SINGLETON = 4096,
IS_PARENT = 8192,
SERVER_NAMESPACE_ONLY = 16384,
NATIVE_PATH = 32768,
WMI_PATH = 65536,
PATH_HAD_SERVER = 131072,
};
pub const WBEMPATH_INFO_ANON_LOCAL_MACHINE = WBEM_PATH_STATUS_FLAG.ANON_LOCAL_MACHINE;
pub const WBEMPATH_INFO_HAS_MACHINE_NAME = WBEM_PATH_STATUS_FLAG.HAS_MACHINE_NAME;
pub const WBEMPATH_INFO_IS_CLASS_REF = WBEM_PATH_STATUS_FLAG.IS_CLASS_REF;
pub const WBEMPATH_INFO_IS_INST_REF = WBEM_PATH_STATUS_FLAG.IS_INST_REF;
pub const WBEMPATH_INFO_HAS_SUBSCOPES = WBEM_PATH_STATUS_FLAG.HAS_SUBSCOPES;
pub const WBEMPATH_INFO_IS_COMPOUND = WBEM_PATH_STATUS_FLAG.IS_COMPOUND;
pub const WBEMPATH_INFO_HAS_V2_REF_PATHS = WBEM_PATH_STATUS_FLAG.HAS_V2_REF_PATHS;
pub const WBEMPATH_INFO_HAS_IMPLIED_KEY = WBEM_PATH_STATUS_FLAG.HAS_IMPLIED_KEY;
pub const WBEMPATH_INFO_CONTAINS_SINGLETON = WBEM_PATH_STATUS_FLAG.CONTAINS_SINGLETON;
pub const WBEMPATH_INFO_V1_COMPLIANT = WBEM_PATH_STATUS_FLAG.V1_COMPLIANT;
pub const WBEMPATH_INFO_V2_COMPLIANT = WBEM_PATH_STATUS_FLAG.V2_COMPLIANT;
pub const WBEMPATH_INFO_CIM_COMPLIANT = WBEM_PATH_STATUS_FLAG.CIM_COMPLIANT;
pub const WBEMPATH_INFO_IS_SINGLETON = WBEM_PATH_STATUS_FLAG.IS_SINGLETON;
pub const WBEMPATH_INFO_IS_PARENT = WBEM_PATH_STATUS_FLAG.IS_PARENT;
pub const WBEMPATH_INFO_SERVER_NAMESPACE_ONLY = WBEM_PATH_STATUS_FLAG.SERVER_NAMESPACE_ONLY;
pub const WBEMPATH_INFO_NATIVE_PATH = WBEM_PATH_STATUS_FLAG.NATIVE_PATH;
pub const WBEMPATH_INFO_WMI_PATH = WBEM_PATH_STATUS_FLAG.WMI_PATH;
pub const WBEMPATH_INFO_PATH_HAD_SERVER = WBEM_PATH_STATUS_FLAG.PATH_HAD_SERVER;
pub const WBEM_PATH_CREATE_FLAG = enum(i32) {
CREATE_ACCEPT_RELATIVE = 1,
CREATE_ACCEPT_ABSOLUTE = 2,
CREATE_ACCEPT_ALL = 4,
TREAT_SINGLE_IDENT_AS_NS = 8,
};
pub const WBEMPATH_CREATE_ACCEPT_RELATIVE = WBEM_PATH_CREATE_FLAG.CREATE_ACCEPT_RELATIVE;
pub const WBEMPATH_CREATE_ACCEPT_ABSOLUTE = WBEM_PATH_CREATE_FLAG.CREATE_ACCEPT_ABSOLUTE;
pub const WBEMPATH_CREATE_ACCEPT_ALL = WBEM_PATH_CREATE_FLAG.CREATE_ACCEPT_ALL;
pub const WBEMPATH_TREAT_SINGLE_IDENT_AS_NS = WBEM_PATH_CREATE_FLAG.TREAT_SINGLE_IDENT_AS_NS;
pub const WBEM_GET_TEXT_FLAGS = enum(i32) {
COMPRESSED = 1,
GET_RELATIVE_ONLY = 2,
GET_SERVER_TOO = 4,
GET_SERVER_AND_NAMESPACE_ONLY = 8,
GET_NAMESPACE_ONLY = 16,
GET_ORIGINAL = 32,
};
pub const WBEMPATH_COMPRESSED = WBEM_GET_TEXT_FLAGS.COMPRESSED;
pub const WBEMPATH_GET_RELATIVE_ONLY = WBEM_GET_TEXT_FLAGS.GET_RELATIVE_ONLY;
pub const WBEMPATH_GET_SERVER_TOO = WBEM_GET_TEXT_FLAGS.GET_SERVER_TOO;
pub const WBEMPATH_GET_SERVER_AND_NAMESPACE_ONLY = WBEM_GET_TEXT_FLAGS.GET_SERVER_AND_NAMESPACE_ONLY;
pub const WBEMPATH_GET_NAMESPACE_ONLY = WBEM_GET_TEXT_FLAGS.GET_NAMESPACE_ONLY;
pub const WBEMPATH_GET_ORIGINAL = WBEM_GET_TEXT_FLAGS.GET_ORIGINAL;
pub const WBEM_GET_KEY_FLAGS = enum(i32) {
TEXT = 1,
QUOTEDTEXT = 2,
};
pub const WBEMPATH_TEXT = WBEM_GET_KEY_FLAGS.TEXT;
pub const WBEMPATH_QUOTEDTEXT = WBEM_GET_KEY_FLAGS.QUOTEDTEXT;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemPathKeyList_Value = @import("../zig.zig").Guid.initString("9ae62877-<KEY>");
pub const IID_IWbemPathKeyList = &IID_IWbemPathKeyList_Value;
pub const IWbemPathKeyList = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetCount: fn(
self: *const IWbemPathKeyList,
puKeyCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetKey: fn(
self: *const IWbemPathKeyList,
wszName: ?[*:0]const u16,
uFlags: u32,
uCimType: u32,
pKeyVal: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetKey2: fn(
self: *const IWbemPathKeyList,
wszName: ?[*:0]const u16,
uFlags: u32,
uCimType: u32,
pKeyVal: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetKey: fn(
self: *const IWbemPathKeyList,
uKeyIx: u32,
uFlags: u32,
puNameBufSize: ?*u32,
pszKeyName: ?[*:0]u16,
puKeyValBufSize: ?*u32,
pKeyVal: ?*anyopaque,
puApparentCimType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetKey2: fn(
self: *const IWbemPathKeyList,
uKeyIx: u32,
uFlags: u32,
puNameBufSize: ?*u32,
pszKeyName: ?[*:0]u16,
pKeyValue: ?*VARIANT,
puApparentCimType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveKey: fn(
self: *const IWbemPathKeyList,
wszName: ?[*:0]const u16,
uFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAllKeys: fn(
self: *const IWbemPathKeyList,
uFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
MakeSingleton: fn(
self: *const IWbemPathKeyList,
bSet: u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInfo: fn(
self: *const IWbemPathKeyList,
uRequestedInfo: u32,
puResponse: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetText: fn(
self: *const IWbemPathKeyList,
lFlags: i32,
puBuffLength: ?*u32,
pszText: [*:0]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 IWbemPathKeyList_GetCount(self: *const T, puKeyCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).GetCount(@ptrCast(*const IWbemPathKeyList, self), puKeyCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_SetKey(self: *const T, wszName: ?[*:0]const u16, uFlags: u32, uCimType: u32, pKeyVal: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).SetKey(@ptrCast(*const IWbemPathKeyList, self), wszName, uFlags, uCimType, pKeyVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_SetKey2(self: *const T, wszName: ?[*:0]const u16, uFlags: u32, uCimType: u32, pKeyVal: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).SetKey2(@ptrCast(*const IWbemPathKeyList, self), wszName, uFlags, uCimType, pKeyVal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_GetKey(self: *const T, uKeyIx: u32, uFlags: u32, puNameBufSize: ?*u32, pszKeyName: ?[*:0]u16, puKeyValBufSize: ?*u32, pKeyVal: ?*anyopaque, puApparentCimType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).GetKey(@ptrCast(*const IWbemPathKeyList, self), uKeyIx, uFlags, puNameBufSize, pszKeyName, puKeyValBufSize, pKeyVal, puApparentCimType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_GetKey2(self: *const T, uKeyIx: u32, uFlags: u32, puNameBufSize: ?*u32, pszKeyName: ?[*:0]u16, pKeyValue: ?*VARIANT, puApparentCimType: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).GetKey2(@ptrCast(*const IWbemPathKeyList, self), uKeyIx, uFlags, puNameBufSize, pszKeyName, pKeyValue, puApparentCimType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_RemoveKey(self: *const T, wszName: ?[*:0]const u16, uFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).RemoveKey(@ptrCast(*const IWbemPathKeyList, self), wszName, uFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_RemoveAllKeys(self: *const T, uFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).RemoveAllKeys(@ptrCast(*const IWbemPathKeyList, self), uFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_MakeSingleton(self: *const T, bSet: u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).MakeSingleton(@ptrCast(*const IWbemPathKeyList, self), bSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_GetInfo(self: *const T, uRequestedInfo: u32, puResponse: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).GetInfo(@ptrCast(*const IWbemPathKeyList, self), uRequestedInfo, puResponse);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPathKeyList_GetText(self: *const T, lFlags: i32, puBuffLength: ?*u32, pszText: [*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPathKeyList.VTable, self.vtable).GetText(@ptrCast(*const IWbemPathKeyList, self), lFlags, puBuffLength, pszText);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemPath_Value = @import("../zig.zig").Guid.initString("3bc15af2-736c-477e-9e51-238af8667dcc");
pub const IID_IWbemPath = &IID_IWbemPath_Value;
pub const IWbemPath = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetText: fn(
self: *const IWbemPath,
uMode: u32,
pszPath: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetText: fn(
self: *const IWbemPath,
lFlags: i32,
puBuffLength: ?*u32,
pszText: [*:0]u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetInfo: fn(
self: *const IWbemPath,
uRequestedInfo: u32,
puResponse: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetServer: fn(
self: *const IWbemPath,
Name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetServer: fn(
self: *const IWbemPath,
puNameBufLength: ?*u32,
pName: [*:0]u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNamespaceCount: fn(
self: *const IWbemPath,
puCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetNamespaceAt: fn(
self: *const IWbemPath,
uIndex: u32,
pszName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNamespaceAt: fn(
self: *const IWbemPath,
uIndex: u32,
puNameBufLength: ?*u32,
pName: [*:0]u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveNamespaceAt: fn(
self: *const IWbemPath,
uIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAllNamespaces: fn(
self: *const IWbemPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetScopeCount: fn(
self: *const IWbemPath,
puCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetScope: fn(
self: *const IWbemPath,
uIndex: u32,
pszClass: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetScopeFromText: fn(
self: *const IWbemPath,
uIndex: u32,
pszText: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetScope: fn(
self: *const IWbemPath,
uIndex: u32,
puClassNameBufSize: ?*u32,
pszClass: [*:0]u16,
pKeyList: ?*?*IWbemPathKeyList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetScopeAsText: fn(
self: *const IWbemPath,
uIndex: u32,
puTextBufSize: ?*u32,
pszText: [*:0]u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveScope: fn(
self: *const IWbemPath,
uIndex: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAllScopes: fn(
self: *const IWbemPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetClassName: fn(
self: *const IWbemPath,
Name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetClassName: fn(
self: *const IWbemPath,
puBuffLength: ?*u32,
pszName: ?[*:0]u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetKeyList: fn(
self: *const IWbemPath,
pOut: ?*?*IWbemPathKeyList,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateClassPart: fn(
self: *const IWbemPath,
lFlags: i32,
Name: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteClassPart: fn(
self: *const IWbemPath,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsRelative: fn(
self: *const IWbemPath,
wszMachine: ?PWSTR,
wszNamespace: ?PWSTR,
) callconv(@import("std").os.windows.WINAPI) BOOL,
IsRelativeOrChild: fn(
self: *const IWbemPath,
wszMachine: ?PWSTR,
wszNamespace: ?PWSTR,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) BOOL,
IsLocal: fn(
self: *const IWbemPath,
wszMachine: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL,
IsSameClassName: fn(
self: *const IWbemPath,
wszClass: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) BOOL,
};
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 IWbemPath_SetText(self: *const T, uMode: u32, pszPath: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetText(@ptrCast(*const IWbemPath, self), uMode, pszPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetText(self: *const T, lFlags: i32, puBuffLength: ?*u32, pszText: [*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetText(@ptrCast(*const IWbemPath, self), lFlags, puBuffLength, pszText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetInfo(self: *const T, uRequestedInfo: u32, puResponse: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetInfo(@ptrCast(*const IWbemPath, self), uRequestedInfo, puResponse);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_SetServer(self: *const T, Name: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetServer(@ptrCast(*const IWbemPath, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetServer(self: *const T, puNameBufLength: ?*u32, pName: [*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetServer(@ptrCast(*const IWbemPath, self), puNameBufLength, pName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetNamespaceCount(self: *const T, puCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetNamespaceCount(@ptrCast(*const IWbemPath, self), puCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_SetNamespaceAt(self: *const T, uIndex: u32, pszName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetNamespaceAt(@ptrCast(*const IWbemPath, self), uIndex, pszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetNamespaceAt(self: *const T, uIndex: u32, puNameBufLength: ?*u32, pName: [*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetNamespaceAt(@ptrCast(*const IWbemPath, self), uIndex, puNameBufLength, pName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_RemoveNamespaceAt(self: *const T, uIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).RemoveNamespaceAt(@ptrCast(*const IWbemPath, self), uIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_RemoveAllNamespaces(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).RemoveAllNamespaces(@ptrCast(*const IWbemPath, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetScopeCount(self: *const T, puCount: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetScopeCount(@ptrCast(*const IWbemPath, self), puCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_SetScope(self: *const T, uIndex: u32, pszClass: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetScope(@ptrCast(*const IWbemPath, self), uIndex, pszClass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_SetScopeFromText(self: *const T, uIndex: u32, pszText: ?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetScopeFromText(@ptrCast(*const IWbemPath, self), uIndex, pszText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetScope(self: *const T, uIndex: u32, puClassNameBufSize: ?*u32, pszClass: [*:0]u16, pKeyList: ?*?*IWbemPathKeyList) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetScope(@ptrCast(*const IWbemPath, self), uIndex, puClassNameBufSize, pszClass, pKeyList);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetScopeAsText(self: *const T, uIndex: u32, puTextBufSize: ?*u32, pszText: [*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetScopeAsText(@ptrCast(*const IWbemPath, self), uIndex, puTextBufSize, pszText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_RemoveScope(self: *const T, uIndex: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).RemoveScope(@ptrCast(*const IWbemPath, self), uIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_RemoveAllScopes(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).RemoveAllScopes(@ptrCast(*const IWbemPath, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_SetClassName(self: *const T, Name: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).SetClassName(@ptrCast(*const IWbemPath, self), Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetClassName(self: *const T, puBuffLength: ?*u32, pszName: ?[*:0]u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetClassName(@ptrCast(*const IWbemPath, self), puBuffLength, pszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_GetKeyList(self: *const T, pOut: ?*?*IWbemPathKeyList) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).GetKeyList(@ptrCast(*const IWbemPath, self), pOut);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_CreateClassPart(self: *const T, lFlags: i32, Name: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).CreateClassPart(@ptrCast(*const IWbemPath, self), lFlags, Name);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_DeleteClassPart(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPath.VTable, self.vtable).DeleteClassPart(@ptrCast(*const IWbemPath, self), lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_IsRelative(self: *const T, wszMachine: ?PWSTR, wszNamespace: ?PWSTR) callconv(.Inline) BOOL {
return @ptrCast(*const IWbemPath.VTable, self.vtable).IsRelative(@ptrCast(*const IWbemPath, self), wszMachine, wszNamespace);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_IsRelativeOrChild(self: *const T, wszMachine: ?PWSTR, wszNamespace: ?PWSTR, lFlags: i32) callconv(.Inline) BOOL {
return @ptrCast(*const IWbemPath.VTable, self.vtable).IsRelativeOrChild(@ptrCast(*const IWbemPath, self), wszMachine, wszNamespace, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_IsLocal(self: *const T, wszMachine: ?[*:0]const u16) callconv(.Inline) BOOL {
return @ptrCast(*const IWbemPath.VTable, self.vtable).IsLocal(@ptrCast(*const IWbemPath, self), wszMachine);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPath_IsSameClassName(self: *const T, wszClass: ?[*:0]const u16) callconv(.Inline) BOOL {
return @ptrCast(*const IWbemPath.VTable, self.vtable).IsSameClassName(@ptrCast(*const IWbemPath, self), wszClass);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemQuery_Value = @import("../zig.zig").Guid.initString("81166f58-dd98-11d3-a120-00105a1f515a");
pub const IID_IWbemQuery = &IID_IWbemQuery_Value;
pub const IWbemQuery = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Empty: fn(
self: *const IWbemQuery,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetLanguageFeatures: fn(
self: *const IWbemQuery,
uFlags: u32,
uArraySize: u32,
puFeatures: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
TestLanguageFeatures: fn(
self: *const IWbemQuery,
uFlags: u32,
uArraySize: ?*u32,
puFeatures: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Parse: fn(
self: *const IWbemQuery,
pszLang: ?[*:0]const u16,
pszQuery: ?[*:0]const u16,
uFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAnalysis: fn(
self: *const IWbemQuery,
uAnalysisType: u32,
uFlags: u32,
pAnalysis: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
FreeMemory: fn(
self: *const IWbemQuery,
pMem: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetQueryInfo: fn(
self: *const IWbemQuery,
uAnalysisType: u32,
uInfoId: u32,
uBufSize: u32,
pDestBuf: ?*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 IWbemQuery_Empty(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).Empty(@ptrCast(*const IWbemQuery, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_SetLanguageFeatures(self: *const T, uFlags: u32, uArraySize: u32, puFeatures: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).SetLanguageFeatures(@ptrCast(*const IWbemQuery, self), uFlags, uArraySize, puFeatures);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_TestLanguageFeatures(self: *const T, uFlags: u32, uArraySize: ?*u32, puFeatures: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).TestLanguageFeatures(@ptrCast(*const IWbemQuery, self), uFlags, uArraySize, puFeatures);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_Parse(self: *const T, pszLang: ?[*:0]const u16, pszQuery: ?[*:0]const u16, uFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).Parse(@ptrCast(*const IWbemQuery, self), pszLang, pszQuery, uFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_GetAnalysis(self: *const T, uAnalysisType: u32, uFlags: u32, pAnalysis: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).GetAnalysis(@ptrCast(*const IWbemQuery, self), uAnalysisType, uFlags, pAnalysis);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_FreeMemory(self: *const T, pMem: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).FreeMemory(@ptrCast(*const IWbemQuery, self), pMem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQuery_GetQueryInfo(self: *const T, uAnalysisType: u32, uInfoId: u32, uBufSize: u32, pDestBuf: ?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQuery.VTable, self.vtable).GetQueryInfo(@ptrCast(*const IWbemQuery, self), uAnalysisType, uInfoId, uBufSize, pDestBuf);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WMIQ_ANALYSIS_TYPE = enum(i32) {
RPN_SEQUENCE = 1,
ASSOC_QUERY = 2,
PROP_ANALYSIS_MATRIX = 3,
QUERY_TEXT = 4,
RESERVED = 134217728,
};
pub const WMIQ_ANALYSIS_RPN_SEQUENCE = WMIQ_ANALYSIS_TYPE.RPN_SEQUENCE;
pub const WMIQ_ANALYSIS_ASSOC_QUERY = WMIQ_ANALYSIS_TYPE.ASSOC_QUERY;
pub const WMIQ_ANALYSIS_PROP_ANALYSIS_MATRIX = WMIQ_ANALYSIS_TYPE.PROP_ANALYSIS_MATRIX;
pub const WMIQ_ANALYSIS_QUERY_TEXT = WMIQ_ANALYSIS_TYPE.QUERY_TEXT;
pub const WMIQ_ANALYSIS_RESERVED = WMIQ_ANALYSIS_TYPE.RESERVED;
pub const WMIQ_RPN_TOKEN_FLAGS = enum(i32) {
TOKEN_EXPRESSION = 1,
TOKEN_AND = 2,
TOKEN_OR = 3,
TOKEN_NOT = 4,
OP_UNDEFINED = 0,
// OP_EQ = 1, this enum value conflicts with TOKEN_EXPRESSION
// OP_NE = 2, this enum value conflicts with TOKEN_AND
// OP_GE = 3, this enum value conflicts with TOKEN_OR
// OP_LE = 4, this enum value conflicts with TOKEN_NOT
OP_LT = 5,
OP_GT = 6,
OP_LIKE = 7,
OP_ISA = 8,
OP_ISNOTA = 9,
OP_ISNULL = 10,
OP_ISNOTNULL = 11,
// LEFT_PROPERTY_NAME = 1, this enum value conflicts with TOKEN_EXPRESSION
// RIGHT_PROPERTY_NAME = 2, this enum value conflicts with TOKEN_AND
// CONST2 = 4, this enum value conflicts with TOKEN_NOT
// CONST = 8, this enum value conflicts with OP_ISA
RELOP = 16,
LEFT_FUNCTION = 32,
RIGHT_FUNCTION = 64,
// GET_TOKEN_TYPE = 1, this enum value conflicts with TOKEN_EXPRESSION
// GET_EXPR_SHAPE = 2, this enum value conflicts with TOKEN_AND
// GET_LEFT_FUNCTION = 3, this enum value conflicts with TOKEN_OR
// GET_RIGHT_FUNCTION = 4, this enum value conflicts with TOKEN_NOT
// GET_RELOP = 5, this enum value conflicts with OP_LT
// NEXT_TOKEN = 1, this enum value conflicts with TOKEN_EXPRESSION
// FROM_UNARY = 1, this enum value conflicts with TOKEN_EXPRESSION
// FROM_PATH = 2, this enum value conflicts with TOKEN_AND
// FROM_CLASS_LIST = 4, this enum value conflicts with TOKEN_NOT
// FROM_MULTIPLE = 8, this enum value conflicts with OP_ISA
};
pub const WMIQ_RPN_TOKEN_EXPRESSION = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_TOKEN_AND = WMIQ_RPN_TOKEN_FLAGS.TOKEN_AND;
pub const WMIQ_RPN_TOKEN_OR = WMIQ_RPN_TOKEN_FLAGS.TOKEN_OR;
pub const WMIQ_RPN_TOKEN_NOT = WMIQ_RPN_TOKEN_FLAGS.TOKEN_NOT;
pub const WMIQ_RPN_OP_UNDEFINED = WMIQ_RPN_TOKEN_FLAGS.OP_UNDEFINED;
pub const WMIQ_RPN_OP_EQ = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_OP_NE = WMIQ_RPN_TOKEN_FLAGS.TOKEN_AND;
pub const WMIQ_RPN_OP_GE = WMIQ_RPN_TOKEN_FLAGS.TOKEN_OR;
pub const WMIQ_RPN_OP_LE = WMIQ_RPN_TOKEN_FLAGS.TOKEN_NOT;
pub const WMIQ_RPN_OP_LT = WMIQ_RPN_TOKEN_FLAGS.OP_LT;
pub const WMIQ_RPN_OP_GT = WMIQ_RPN_TOKEN_FLAGS.OP_GT;
pub const WMIQ_RPN_OP_LIKE = WMIQ_RPN_TOKEN_FLAGS.OP_LIKE;
pub const WMIQ_RPN_OP_ISA = WMIQ_RPN_TOKEN_FLAGS.OP_ISA;
pub const WMIQ_RPN_OP_ISNOTA = WMIQ_RPN_TOKEN_FLAGS.OP_ISNOTA;
pub const WMIQ_RPN_OP_ISNULL = WMIQ_RPN_TOKEN_FLAGS.OP_ISNULL;
pub const WMIQ_RPN_OP_ISNOTNULL = WMIQ_RPN_TOKEN_FLAGS.OP_ISNOTNULL;
pub const WMIQ_RPN_LEFT_PROPERTY_NAME = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_RIGHT_PROPERTY_NAME = WMIQ_RPN_TOKEN_FLAGS.TOKEN_AND;
pub const WMIQ_RPN_CONST2 = WMIQ_RPN_TOKEN_FLAGS.TOKEN_NOT;
pub const WMIQ_RPN_CONST = WMIQ_RPN_TOKEN_FLAGS.OP_ISA;
pub const WMIQ_RPN_RELOP = WMIQ_RPN_TOKEN_FLAGS.RELOP;
pub const WMIQ_RPN_LEFT_FUNCTION = WMIQ_RPN_TOKEN_FLAGS.LEFT_FUNCTION;
pub const WMIQ_RPN_RIGHT_FUNCTION = WMIQ_RPN_TOKEN_FLAGS.RIGHT_FUNCTION;
pub const WMIQ_RPN_GET_TOKEN_TYPE = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_GET_EXPR_SHAPE = WMIQ_RPN_TOKEN_FLAGS.TOKEN_AND;
pub const WMIQ_RPN_GET_LEFT_FUNCTION = WMIQ_RPN_TOKEN_FLAGS.TOKEN_OR;
pub const WMIQ_RPN_GET_RIGHT_FUNCTION = WMIQ_RPN_TOKEN_FLAGS.TOKEN_NOT;
pub const WMIQ_RPN_GET_RELOP = WMIQ_RPN_TOKEN_FLAGS.OP_LT;
pub const WMIQ_RPN_NEXT_TOKEN = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_FROM_UNARY = WMIQ_RPN_TOKEN_FLAGS.TOKEN_EXPRESSION;
pub const WMIQ_RPN_FROM_PATH = WMIQ_RPN_TOKEN_FLAGS.TOKEN_AND;
pub const WMIQ_RPN_FROM_CLASS_LIST = WMIQ_RPN_TOKEN_FLAGS.TOKEN_NOT;
pub const WMIQ_RPN_FROM_MULTIPLE = WMIQ_RPN_TOKEN_FLAGS.OP_ISA;
pub const WMIQ_ASSOCQ_FLAGS = enum(i32) {
ASSOCIATORS = 1,
REFERENCES = 2,
RESULTCLASS = 4,
ASSOCCLASS = 8,
ROLE = 16,
RESULTROLE = 32,
REQUIREDQUALIFIER = 64,
REQUIREDASSOCQUALIFIER = 128,
CLASSDEFSONLY = 256,
KEYSONLY = 512,
SCHEMAONLY = 1024,
CLASSREFSONLY = 2048,
};
pub const WMIQ_ASSOCQ_ASSOCIATORS = WMIQ_ASSOCQ_FLAGS.ASSOCIATORS;
pub const WMIQ_ASSOCQ_REFERENCES = WMIQ_ASSOCQ_FLAGS.REFERENCES;
pub const WMIQ_ASSOCQ_RESULTCLASS = WMIQ_ASSOCQ_FLAGS.RESULTCLASS;
pub const WMIQ_ASSOCQ_ASSOCCLASS = WMIQ_ASSOCQ_FLAGS.ASSOCCLASS;
pub const WMIQ_ASSOCQ_ROLE = WMIQ_ASSOCQ_FLAGS.ROLE;
pub const WMIQ_ASSOCQ_RESULTROLE = WMIQ_ASSOCQ_FLAGS.RESULTROLE;
pub const WMIQ_ASSOCQ_REQUIREDQUALIFIER = WMIQ_ASSOCQ_FLAGS.REQUIREDQUALIFIER;
pub const WMIQ_ASSOCQ_REQUIREDASSOCQUALIFIER = WMIQ_ASSOCQ_FLAGS.REQUIREDASSOCQUALIFIER;
pub const WMIQ_ASSOCQ_CLASSDEFSONLY = WMIQ_ASSOCQ_FLAGS.CLASSDEFSONLY;
pub const WMIQ_ASSOCQ_KEYSONLY = WMIQ_ASSOCQ_FLAGS.KEYSONLY;
pub const WMIQ_ASSOCQ_SCHEMAONLY = WMIQ_ASSOCQ_FLAGS.SCHEMAONLY;
pub const WMIQ_ASSOCQ_CLASSREFSONLY = WMIQ_ASSOCQ_FLAGS.CLASSREFSONLY;
pub const SWbemQueryQualifiedName = extern struct {
m_uVersion: u32,
m_uTokenType: u32,
m_uNameListSize: u32,
m_ppszNameList: ?*?PWSTR,
m_bArraysUsed: BOOL,
m_pbArrayElUsed: ?*BOOL,
m_puArrayIndex: ?*u32,
};
pub const SWbemRpnConst = extern union {
m_pszStrVal: ?[*:0]const u16,
m_bBoolVal: BOOL,
m_lLongVal: i32,
m_uLongVal: u32,
m_dblVal: f64,
m_lVal64: i64,
m_uVal64: i64,
};
pub const SWbemRpnQueryToken = extern struct {
m_uVersion: u32,
m_uTokenType: u32,
m_uSubexpressionShape: u32,
m_uOperator: u32,
m_pRightIdent: ?*SWbemQueryQualifiedName,
m_pLeftIdent: ?*SWbemQueryQualifiedName,
m_uConstApparentType: u32,
m_Const: SWbemRpnConst,
m_uConst2ApparentType: u32,
m_Const2: SWbemRpnConst,
m_pszRightFunc: ?[*:0]const u16,
m_pszLeftFunc: ?[*:0]const u16,
};
pub const SWbemRpnTokenList = extern struct {
m_uVersion: u32,
m_uTokenType: u32,
m_uNumTokens: u32,
};
pub const WMIQ_LANGUAGE_FEATURES = enum(i32) {
@"1_BASIC_SELECT" = 1,
@"2_CLASS_NAME_IN_QUERY" = 2,
@"3_STRING_CASE_FUNCTIONS" = 3,
@"4_PROP_TO_PROP_TESTS" = 4,
@"5_COUNT_STAR" = 5,
@"6_ORDER_BY" = 6,
@"7_DISTINCT" = 7,
@"8_ISA" = 8,
@"9_THIS" = 9,
@"10_COMPEX_SUBEXPRESSIONS" = 10,
@"11_ALIASING" = 11,
@"12_GROUP_BY_HAVING" = 12,
@"13_WMI_WITHIN" = 13,
@"14_SQL_WRITE_OPERATIONS" = 14,
@"15_GO" = 15,
@"16_SINGLE_LEVEL_TRANSACTIONS" = 16,
@"17_QUALIFIED_NAMES" = 17,
@"18_ASSOCIATONS" = 18,
@"19_SYSTEM_PROPERTIES" = 19,
@"20_EXTENDED_SYSTEM_PROPERTIES" = 20,
@"21_SQL89_JOINS" = 21,
@"22_SQL92_JOINS" = 22,
@"23_SUBSELECTS" = 23,
@"24_UMI_EXTENSIONS" = 24,
@"25_DATEPART" = 25,
@"26_LIKE" = 26,
@"27_CIM_TEMPORAL_CONSTRUCTS" = 27,
@"28_STANDARD_AGGREGATES" = 28,
@"29_MULTI_LEVEL_ORDER_BY" = 29,
@"30_WMI_PRAGMAS" = 30,
@"31_QUALIFIER_TESTS" = 31,
@"32_SP_EXECUTE" = 32,
@"33_ARRAY_ACCESS" = 33,
@"34_UNION" = 34,
@"35_COMPLEX_SELECT_TARGET" = 35,
@"36_REFERENCE_TESTS" = 36,
@"37_SELECT_INTO" = 37,
@"38_BASIC_DATETIME_TESTS" = 38,
@"39_COUNT_COLUMN" = 39,
@"40_BETWEEN" = 40,
// _LAST = 40, this enum value conflicts with @"40_BETWEEN"
};
pub const WMIQ_LF1_BASIC_SELECT = WMIQ_LANGUAGE_FEATURES.@"1_BASIC_SELECT";
pub const WMIQ_LF2_CLASS_NAME_IN_QUERY = WMIQ_LANGUAGE_FEATURES.@"2_CLASS_NAME_IN_QUERY";
pub const WMIQ_LF3_STRING_CASE_FUNCTIONS = WMIQ_LANGUAGE_FEATURES.@"3_STRING_CASE_FUNCTIONS";
pub const WMIQ_LF4_PROP_TO_PROP_TESTS = WMIQ_LANGUAGE_FEATURES.@"4_PROP_TO_PROP_TESTS";
pub const WMIQ_LF5_COUNT_STAR = WMIQ_LANGUAGE_FEATURES.@"5_COUNT_STAR";
pub const WMIQ_LF6_ORDER_BY = WMIQ_LANGUAGE_FEATURES.@"6_ORDER_BY";
pub const WMIQ_LF7_DISTINCT = WMIQ_LANGUAGE_FEATURES.@"7_DISTINCT";
pub const WMIQ_LF8_ISA = WMIQ_LANGUAGE_FEATURES.@"8_ISA";
pub const WMIQ_LF9_THIS = WMIQ_LANGUAGE_FEATURES.@"9_THIS";
pub const WMIQ_LF10_COMPEX_SUBEXPRESSIONS = WMIQ_LANGUAGE_FEATURES.@"10_COMPEX_SUBEXPRESSIONS";
pub const WMIQ_LF11_ALIASING = WMIQ_LANGUAGE_FEATURES.@"11_ALIASING";
pub const WMIQ_LF12_GROUP_BY_HAVING = WMIQ_LANGUAGE_FEATURES.@"12_GROUP_BY_HAVING";
pub const WMIQ_LF13_WMI_WITHIN = WMIQ_LANGUAGE_FEATURES.@"13_WMI_WITHIN";
pub const WMIQ_LF14_SQL_WRITE_OPERATIONS = WMIQ_LANGUAGE_FEATURES.@"14_SQL_WRITE_OPERATIONS";
pub const WMIQ_LF15_GO = WMIQ_LANGUAGE_FEATURES.@"15_GO";
pub const WMIQ_LF16_SINGLE_LEVEL_TRANSACTIONS = WMIQ_LANGUAGE_FEATURES.@"16_SINGLE_LEVEL_TRANSACTIONS";
pub const WMIQ_LF17_QUALIFIED_NAMES = WMIQ_LANGUAGE_FEATURES.@"17_QUALIFIED_NAMES";
pub const WMIQ_LF18_ASSOCIATONS = WMIQ_LANGUAGE_FEATURES.@"18_ASSOCIATONS";
pub const WMIQ_LF19_SYSTEM_PROPERTIES = WMIQ_LANGUAGE_FEATURES.@"19_SYSTEM_PROPERTIES";
pub const WMIQ_LF20_EXTENDED_SYSTEM_PROPERTIES = WMIQ_LANGUAGE_FEATURES.@"20_EXTENDED_SYSTEM_PROPERTIES";
pub const WMIQ_LF21_SQL89_JOINS = WMIQ_LANGUAGE_FEATURES.@"21_SQL89_JOINS";
pub const WMIQ_LF22_SQL92_JOINS = WMIQ_LANGUAGE_FEATURES.@"22_SQL92_JOINS";
pub const WMIQ_LF23_SUBSELECTS = WMIQ_LANGUAGE_FEATURES.@"23_SUBSELECTS";
pub const WMIQ_LF24_UMI_EXTENSIONS = WMIQ_LANGUAGE_FEATURES.@"24_UMI_EXTENSIONS";
pub const WMIQ_LF25_DATEPART = WMIQ_LANGUAGE_FEATURES.@"25_DATEPART";
pub const WMIQ_LF26_LIKE = WMIQ_LANGUAGE_FEATURES.@"26_LIKE";
pub const WMIQ_LF27_CIM_TEMPORAL_CONSTRUCTS = WMIQ_LANGUAGE_FEATURES.@"27_CIM_TEMPORAL_CONSTRUCTS";
pub const WMIQ_LF28_STANDARD_AGGREGATES = WMIQ_LANGUAGE_FEATURES.@"28_STANDARD_AGGREGATES";
pub const WMIQ_LF29_MULTI_LEVEL_ORDER_BY = WMIQ_LANGUAGE_FEATURES.@"29_MULTI_LEVEL_ORDER_BY";
pub const WMIQ_LF30_WMI_PRAGMAS = WMIQ_LANGUAGE_FEATURES.@"30_WMI_PRAGMAS";
pub const WMIQ_LF31_QUALIFIER_TESTS = WMIQ_LANGUAGE_FEATURES.@"31_QUALIFIER_TESTS";
pub const WMIQ_LF32_SP_EXECUTE = WMIQ_LANGUAGE_FEATURES.@"32_SP_EXECUTE";
pub const WMIQ_LF33_ARRAY_ACCESS = WMIQ_LANGUAGE_FEATURES.@"33_ARRAY_ACCESS";
pub const WMIQ_LF34_UNION = WMIQ_LANGUAGE_FEATURES.@"34_UNION";
pub const WMIQ_LF35_COMPLEX_SELECT_TARGET = WMIQ_LANGUAGE_FEATURES.@"35_COMPLEX_SELECT_TARGET";
pub const WMIQ_LF36_REFERENCE_TESTS = WMIQ_LANGUAGE_FEATURES.@"36_REFERENCE_TESTS";
pub const WMIQ_LF37_SELECT_INTO = WMIQ_LANGUAGE_FEATURES.@"37_SELECT_INTO";
pub const WMIQ_LF38_BASIC_DATETIME_TESTS = WMIQ_LANGUAGE_FEATURES.@"38_BASIC_DATETIME_TESTS";
pub const WMIQ_LF39_COUNT_COLUMN = WMIQ_LANGUAGE_FEATURES.@"39_COUNT_COLUMN";
pub const WMIQ_LF40_BETWEEN = WMIQ_LANGUAGE_FEATURES.@"40_BETWEEN";
pub const WMIQ_LF_LAST = WMIQ_LANGUAGE_FEATURES.@"40_BETWEEN";
pub const WMIQ_RPNQ_FEATURE = enum(i32) {
WHERE_CLAUSE_PRESENT = 1,
QUERY_IS_CONJUNCTIVE = 2,
QUERY_IS_DISJUNCTIVE = 4,
PROJECTION = 8,
FEATURE_SELECT_STAR = 16,
EQUALITY_TESTS_ONLY = 32,
COUNT_STAR = 64,
QUALIFIED_NAMES_USED = 128,
SYSPROP_CLASS_USED = 256,
PROP_TO_PROP_TESTS = 512,
ORDER_BY = 1024,
ISA_USED = 2048,
GROUP_BY_HAVING = 4096,
ARRAY_ACCESS_USED = 8192,
};
pub const WMIQ_RPNF_WHERE_CLAUSE_PRESENT = WMIQ_RPNQ_FEATURE.WHERE_CLAUSE_PRESENT;
pub const WMIQ_RPNF_QUERY_IS_CONJUNCTIVE = WMIQ_RPNQ_FEATURE.QUERY_IS_CONJUNCTIVE;
pub const WMIQ_RPNF_QUERY_IS_DISJUNCTIVE = WMIQ_RPNQ_FEATURE.QUERY_IS_DISJUNCTIVE;
pub const WMIQ_RPNF_PROJECTION = WMIQ_RPNQ_FEATURE.PROJECTION;
pub const WMIQ_RPNF_FEATURE_SELECT_STAR = WMIQ_RPNQ_FEATURE.FEATURE_SELECT_STAR;
pub const WMIQ_RPNF_EQUALITY_TESTS_ONLY = WMIQ_RPNQ_FEATURE.EQUALITY_TESTS_ONLY;
pub const WMIQ_RPNF_COUNT_STAR = WMIQ_RPNQ_FEATURE.COUNT_STAR;
pub const WMIQ_RPNF_QUALIFIED_NAMES_USED = WMIQ_RPNQ_FEATURE.QUALIFIED_NAMES_USED;
pub const WMIQ_RPNF_SYSPROP_CLASS_USED = WMIQ_RPNQ_FEATURE.SYSPROP_CLASS_USED;
pub const WMIQ_RPNF_PROP_TO_PROP_TESTS = WMIQ_RPNQ_FEATURE.PROP_TO_PROP_TESTS;
pub const WMIQ_RPNF_ORDER_BY = WMIQ_RPNQ_FEATURE.ORDER_BY;
pub const WMIQ_RPNF_ISA_USED = WMIQ_RPNQ_FEATURE.ISA_USED;
pub const WMIQ_RPNF_GROUP_BY_HAVING = WMIQ_RPNQ_FEATURE.GROUP_BY_HAVING;
pub const WMIQ_RPNF_ARRAY_ACCESS_USED = WMIQ_RPNQ_FEATURE.ARRAY_ACCESS_USED;
pub const SWbemRpnEncodedQuery = extern struct {
m_uVersion: u32,
m_uTokenType: u32,
m_uParsedFeatureMask: u64,
m_uDetectedArraySize: u32,
m_puDetectedFeatures: ?*u32,
m_uSelectListSize: u32,
m_ppSelectList: ?*?*SWbemQueryQualifiedName,
m_uFromTargetType: u32,
m_pszOptionalFromPath: ?[*:0]const u16,
m_uFromListSize: u32,
m_ppszFromList: ?*?PWSTR,
m_uWhereClauseSize: u32,
m_ppRpnWhereClause: ?*?*SWbemRpnQueryToken,
m_dblWithinPolling: f64,
m_dblWithinWindow: f64,
m_uOrderByListSize: u32,
m_ppszOrderByList: ?*?PWSTR,
m_uOrderDirectionEl: ?*u32,
};
pub const SWbemAnalysisMatrix = extern struct {
m_uVersion: u32,
m_uMatrixType: u32,
m_pszProperty: ?[*:0]const u16,
m_uPropertyType: u32,
m_uEntries: u32,
m_pValues: ?*?*anyopaque,
m_pbTruthTable: ?*BOOL,
};
pub const SWbemAnalysisMatrixList = extern struct {
m_uVersion: u32,
m_uMatrixType: u32,
m_uNumMatrices: u32,
m_pMatrices: ?*SWbemAnalysisMatrix,
};
pub const SWbemAssocQueryInf = extern struct {
m_uVersion: u32,
m_uAnalysisType: u32,
m_uFeatureMask: u32,
m_pPath: ?*IWbemPath,
m_pszPath: ?PWSTR,
m_pszQueryText: ?PWSTR,
m_pszResultClass: ?PWSTR,
m_pszAssocClass: ?PWSTR,
m_pszRole: ?PWSTR,
m_pszResultRole: ?PWSTR,
m_pszRequiredQualifier: ?PWSTR,
m_pszRequiredAssocQualifier: ?PWSTR,
};
const CLSID_WbemLocator_Value = @import("../zig.zig").Guid.initString("4590f811-1d3a-11d0-891f-00aa004b2e24");
pub const CLSID_WbemLocator = &CLSID_WbemLocator_Value;
const CLSID_WbemContext_Value = @import("../zig.zig").Guid.initString("674b6698-ee92-11d0-ad71-00c04fd8fdff");
pub const CLSID_WbemContext = &CLSID_WbemContext_Value;
const CLSID_UnsecuredApartment_Value = @import("../zig.zig").Guid.initString("49bd2028-1523-11d1-ad79-00c04fd8fdff");
pub const CLSID_UnsecuredApartment = &CLSID_UnsecuredApartment_Value;
const CLSID_WbemClassObject_Value = @import("../zig.zig").Guid.initString("9a653086-174f-11d2-b5f9-00104b703efd");
pub const CLSID_WbemClassObject = &CLSID_WbemClassObject_Value;
const CLSID_MofCompiler_Value = @import("../zig.zig").Guid.initString("6daf9757-2e37-11d2-aec9-00c04fb68820");
pub const CLSID_MofCompiler = &CLSID_MofCompiler_Value;
const CLSID_WbemStatusCodeText_Value = @import("../zig.zig").Guid.initString("eb87e1bd-3233-11d2-aec9-00c04fb68820");
pub const CLSID_WbemStatusCodeText = &CLSID_WbemStatusCodeText_Value;
const CLSID_WbemBackupRestore_Value = @import("../zig.zig").Guid.initString("c49e32c6-bc8b-11d2-85d4-00105a1f8304");
pub const CLSID_WbemBackupRestore = &CLSID_WbemBackupRestore_Value;
const CLSID_WbemRefresher_Value = @import("../zig.zig").Guid.initString("c71566f2-561e-11d1-ad87-00c04fd8fdff");
pub const CLSID_WbemRefresher = &CLSID_WbemRefresher_Value;
const CLSID_WbemObjectTextSrc_Value = @import("../zig.zig").Guid.initString("8d1c559d-84f0-4bb3-a7d5-56a7435a9ba6");
pub const CLSID_WbemObjectTextSrc = &CLSID_WbemObjectTextSrc_Value;
pub const WBEM_GENUS_TYPE = enum(i32) {
CLASS = 1,
INSTANCE = 2,
};
pub const WBEM_GENUS_CLASS = WBEM_GENUS_TYPE.CLASS;
pub const WBEM_GENUS_INSTANCE = WBEM_GENUS_TYPE.INSTANCE;
pub const WBEM_CHANGE_FLAG_TYPE = enum(i32) {
FLAG_CREATE_OR_UPDATE = 0,
FLAG_UPDATE_ONLY = 1,
FLAG_CREATE_ONLY = 2,
// FLAG_UPDATE_COMPATIBLE = 0, this enum value conflicts with FLAG_CREATE_OR_UPDATE
FLAG_UPDATE_SAFE_MODE = 32,
FLAG_UPDATE_FORCE_MODE = 64,
MASK_UPDATE_MODE = 96,
FLAG_ADVISORY = 65536,
};
pub const WBEM_FLAG_CREATE_OR_UPDATE = WBEM_CHANGE_FLAG_TYPE.FLAG_CREATE_OR_UPDATE;
pub const WBEM_FLAG_UPDATE_ONLY = WBEM_CHANGE_FLAG_TYPE.FLAG_UPDATE_ONLY;
pub const WBEM_FLAG_CREATE_ONLY = WBEM_CHANGE_FLAG_TYPE.FLAG_CREATE_ONLY;
pub const WBEM_FLAG_UPDATE_COMPATIBLE = WBEM_CHANGE_FLAG_TYPE.FLAG_CREATE_OR_UPDATE;
pub const WBEM_FLAG_UPDATE_SAFE_MODE = WBEM_CHANGE_FLAG_TYPE.FLAG_UPDATE_SAFE_MODE;
pub const WBEM_FLAG_UPDATE_FORCE_MODE = WBEM_CHANGE_FLAG_TYPE.FLAG_UPDATE_FORCE_MODE;
pub const WBEM_MASK_UPDATE_MODE = WBEM_CHANGE_FLAG_TYPE.MASK_UPDATE_MODE;
pub const WBEM_FLAG_ADVISORY = WBEM_CHANGE_FLAG_TYPE.FLAG_ADVISORY;
pub const WBEM_GENERIC_FLAG_TYPE = enum(i32) {
FLAG_RETURN_IMMEDIATELY = 16,
FLAG_RETURN_WBEM_COMPLETE = 0,
// FLAG_BIDIRECTIONAL = 0, this enum value conflicts with FLAG_RETURN_WBEM_COMPLETE
FLAG_FORWARD_ONLY = 32,
FLAG_NO_ERROR_OBJECT = 64,
// FLAG_RETURN_ERROR_OBJECT = 0, this enum value conflicts with FLAG_RETURN_WBEM_COMPLETE
FLAG_SEND_STATUS = 128,
// FLAG_DONT_SEND_STATUS = 0, this enum value conflicts with FLAG_RETURN_WBEM_COMPLETE
FLAG_ENSURE_LOCATABLE = 256,
FLAG_DIRECT_READ = 512,
// FLAG_SEND_ONLY_SELECTED = 0, this enum value conflicts with FLAG_RETURN_WBEM_COMPLETE
// RETURN_WHEN_COMPLETE = 0, this enum value conflicts with FLAG_RETURN_WBEM_COMPLETE
// RETURN_IMMEDIATELY = 16, this enum value conflicts with FLAG_RETURN_IMMEDIATELY
MASK_RESERVED_FLAGS = 126976,
FLAG_USE_AMENDED_QUALIFIERS = 131072,
FLAG_STRONG_VALIDATION = 1048576,
};
pub const WBEM_FLAG_RETURN_IMMEDIATELY = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_IMMEDIATELY;
pub const WBEM_FLAG_RETURN_WBEM_COMPLETE = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_FLAG_BIDIRECTIONAL = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_FLAG_FORWARD_ONLY = WBEM_GENERIC_FLAG_TYPE.FLAG_FORWARD_ONLY;
pub const WBEM_FLAG_NO_ERROR_OBJECT = WBEM_GENERIC_FLAG_TYPE.FLAG_NO_ERROR_OBJECT;
pub const WBEM_FLAG_RETURN_ERROR_OBJECT = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_FLAG_SEND_STATUS = WBEM_GENERIC_FLAG_TYPE.FLAG_SEND_STATUS;
pub const WBEM_FLAG_DONT_SEND_STATUS = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_FLAG_ENSURE_LOCATABLE = WBEM_GENERIC_FLAG_TYPE.FLAG_ENSURE_LOCATABLE;
pub const WBEM_FLAG_DIRECT_READ = WBEM_GENERIC_FLAG_TYPE.FLAG_DIRECT_READ;
pub const WBEM_FLAG_SEND_ONLY_SELECTED = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_RETURN_WHEN_COMPLETE = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_WBEM_COMPLETE;
pub const WBEM_RETURN_IMMEDIATELY = WBEM_GENERIC_FLAG_TYPE.FLAG_RETURN_IMMEDIATELY;
pub const WBEM_MASK_RESERVED_FLAGS = WBEM_GENERIC_FLAG_TYPE.MASK_RESERVED_FLAGS;
pub const WBEM_FLAG_USE_AMENDED_QUALIFIERS = WBEM_GENERIC_FLAG_TYPE.FLAG_USE_AMENDED_QUALIFIERS;
pub const WBEM_FLAG_STRONG_VALIDATION = WBEM_GENERIC_FLAG_TYPE.FLAG_STRONG_VALIDATION;
pub const WBEM_STATUS_TYPE = enum(i32) {
COMPLETE = 0,
REQUIREMENTS = 1,
PROGRESS = 2,
LOGGING_INFORMATION = 256,
LOGGING_INFORMATION_PROVIDER = 512,
LOGGING_INFORMATION_HOST = 1024,
LOGGING_INFORMATION_REPOSITORY = 2048,
LOGGING_INFORMATION_ESS = 4096,
};
pub const WBEM_STATUS_COMPLETE = WBEM_STATUS_TYPE.COMPLETE;
pub const WBEM_STATUS_REQUIREMENTS = WBEM_STATUS_TYPE.REQUIREMENTS;
pub const WBEM_STATUS_PROGRESS = WBEM_STATUS_TYPE.PROGRESS;
pub const WBEM_STATUS_LOGGING_INFORMATION = WBEM_STATUS_TYPE.LOGGING_INFORMATION;
pub const WBEM_STATUS_LOGGING_INFORMATION_PROVIDER = WBEM_STATUS_TYPE.LOGGING_INFORMATION_PROVIDER;
pub const WBEM_STATUS_LOGGING_INFORMATION_HOST = WBEM_STATUS_TYPE.LOGGING_INFORMATION_HOST;
pub const WBEM_STATUS_LOGGING_INFORMATION_REPOSITORY = WBEM_STATUS_TYPE.LOGGING_INFORMATION_REPOSITORY;
pub const WBEM_STATUS_LOGGING_INFORMATION_ESS = WBEM_STATUS_TYPE.LOGGING_INFORMATION_ESS;
pub const WBEM_TIMEOUT_TYPE = enum(i32) {
NO_WAIT = 0,
INFINITE = -1,
};
pub const WBEM_NO_WAIT = WBEM_TIMEOUT_TYPE.NO_WAIT;
pub const WBEM_INFINITE = WBEM_TIMEOUT_TYPE.INFINITE;
pub const WBEM_CONDITION_FLAG_TYPE = enum(i32) {
FLAG_ALWAYS = 0,
FLAG_ONLY_IF_TRUE = 1,
FLAG_ONLY_IF_FALSE = 2,
FLAG_ONLY_IF_IDENTICAL = 3,
// MASK_PRIMARY_CONDITION = 3, this enum value conflicts with FLAG_ONLY_IF_IDENTICAL
FLAG_KEYS_ONLY = 4,
FLAG_REFS_ONLY = 8,
FLAG_LOCAL_ONLY = 16,
FLAG_PROPAGATED_ONLY = 32,
FLAG_SYSTEM_ONLY = 48,
FLAG_NONSYSTEM_ONLY = 64,
MASK_CONDITION_ORIGIN = 112,
FLAG_CLASS_OVERRIDES_ONLY = 256,
FLAG_CLASS_LOCAL_AND_OVERRIDES = 512,
MASK_CLASS_CONDITION = 768,
};
pub const WBEM_FLAG_ALWAYS = WBEM_CONDITION_FLAG_TYPE.FLAG_ALWAYS;
pub const WBEM_FLAG_ONLY_IF_TRUE = WBEM_CONDITION_FLAG_TYPE.FLAG_ONLY_IF_TRUE;
pub const WBEM_FLAG_ONLY_IF_FALSE = WBEM_CONDITION_FLAG_TYPE.FLAG_ONLY_IF_FALSE;
pub const WBEM_FLAG_ONLY_IF_IDENTICAL = WBEM_CONDITION_FLAG_TYPE.FLAG_ONLY_IF_IDENTICAL;
pub const WBEM_MASK_PRIMARY_CONDITION = WBEM_CONDITION_FLAG_TYPE.FLAG_ONLY_IF_IDENTICAL;
pub const WBEM_FLAG_KEYS_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_KEYS_ONLY;
pub const WBEM_FLAG_REFS_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_REFS_ONLY;
pub const WBEM_FLAG_LOCAL_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_LOCAL_ONLY;
pub const WBEM_FLAG_PROPAGATED_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_PROPAGATED_ONLY;
pub const WBEM_FLAG_SYSTEM_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_SYSTEM_ONLY;
pub const WBEM_FLAG_NONSYSTEM_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_NONSYSTEM_ONLY;
pub const WBEM_MASK_CONDITION_ORIGIN = WBEM_CONDITION_FLAG_TYPE.MASK_CONDITION_ORIGIN;
pub const WBEM_FLAG_CLASS_OVERRIDES_ONLY = WBEM_CONDITION_FLAG_TYPE.FLAG_CLASS_OVERRIDES_ONLY;
pub const WBEM_FLAG_CLASS_LOCAL_AND_OVERRIDES = WBEM_CONDITION_FLAG_TYPE.FLAG_CLASS_LOCAL_AND_OVERRIDES;
pub const WBEM_MASK_CLASS_CONDITION = WBEM_CONDITION_FLAG_TYPE.MASK_CLASS_CONDITION;
pub const WBEM_FLAVOR_TYPE = enum(i32) {
DONT_PROPAGATE = 0,
FLAG_PROPAGATE_TO_INSTANCE = 1,
FLAG_PROPAGATE_TO_DERIVED_CLASS = 2,
MASK_PROPAGATION = 15,
// OVERRIDABLE = 0, this enum value conflicts with DONT_PROPAGATE
NOT_OVERRIDABLE = 16,
// MASK_PERMISSIONS = 16, this enum value conflicts with NOT_OVERRIDABLE
// ORIGIN_LOCAL = 0, this enum value conflicts with DONT_PROPAGATE
ORIGIN_PROPAGATED = 32,
ORIGIN_SYSTEM = 64,
MASK_ORIGIN = 96,
// NOT_AMENDED = 0, this enum value conflicts with DONT_PROPAGATE
AMENDED = 128,
// MASK_AMENDED = 128, this enum value conflicts with AMENDED
};
pub const WBEM_FLAVOR_DONT_PROPAGATE = WBEM_FLAVOR_TYPE.DONT_PROPAGATE;
pub const WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE = WBEM_FLAVOR_TYPE.FLAG_PROPAGATE_TO_INSTANCE;
pub const WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS = WBEM_FLAVOR_TYPE.FLAG_PROPAGATE_TO_DERIVED_CLASS;
pub const WBEM_FLAVOR_MASK_PROPAGATION = WBEM_FLAVOR_TYPE.MASK_PROPAGATION;
pub const WBEM_FLAVOR_OVERRIDABLE = WBEM_FLAVOR_TYPE.DONT_PROPAGATE;
pub const WBEM_FLAVOR_NOT_OVERRIDABLE = WBEM_FLAVOR_TYPE.NOT_OVERRIDABLE;
pub const WBEM_FLAVOR_MASK_PERMISSIONS = WBEM_FLAVOR_TYPE.NOT_OVERRIDABLE;
pub const WBEM_FLAVOR_ORIGIN_LOCAL = WBEM_FLAVOR_TYPE.DONT_PROPAGATE;
pub const WBEM_FLAVOR_ORIGIN_PROPAGATED = WBEM_FLAVOR_TYPE.ORIGIN_PROPAGATED;
pub const WBEM_FLAVOR_ORIGIN_SYSTEM = WBEM_FLAVOR_TYPE.ORIGIN_SYSTEM;
pub const WBEM_FLAVOR_MASK_ORIGIN = WBEM_FLAVOR_TYPE.MASK_ORIGIN;
pub const WBEM_FLAVOR_NOT_AMENDED = WBEM_FLAVOR_TYPE.DONT_PROPAGATE;
pub const WBEM_FLAVOR_AMENDED = WBEM_FLAVOR_TYPE.AMENDED;
pub const WBEM_FLAVOR_MASK_AMENDED = WBEM_FLAVOR_TYPE.AMENDED;
pub const WBEM_QUERY_FLAG_TYPE = enum(i32) {
DEEP = 0,
SHALLOW = 1,
PROTOTYPE = 2,
};
pub const WBEM_FLAG_DEEP = WBEM_QUERY_FLAG_TYPE.DEEP;
pub const WBEM_FLAG_SHALLOW = WBEM_QUERY_FLAG_TYPE.SHALLOW;
pub const WBEM_FLAG_PROTOTYPE = WBEM_QUERY_FLAG_TYPE.PROTOTYPE;
pub const WBEM_SECURITY_FLAGS = enum(i32) {
ENABLE = 1,
METHOD_EXECUTE = 2,
FULL_WRITE_REP = 4,
PARTIAL_WRITE_REP = 8,
WRITE_PROVIDER = 16,
REMOTE_ACCESS = 32,
RIGHT_SUBSCRIBE = 64,
RIGHT_PUBLISH = 128,
};
pub const WBEM_ENABLE = WBEM_SECURITY_FLAGS.ENABLE;
pub const WBEM_METHOD_EXECUTE = WBEM_SECURITY_FLAGS.METHOD_EXECUTE;
pub const WBEM_FULL_WRITE_REP = WBEM_SECURITY_FLAGS.FULL_WRITE_REP;
pub const WBEM_PARTIAL_WRITE_REP = WBEM_SECURITY_FLAGS.PARTIAL_WRITE_REP;
pub const WBEM_WRITE_PROVIDER = WBEM_SECURITY_FLAGS.WRITE_PROVIDER;
pub const WBEM_REMOTE_ACCESS = WBEM_SECURITY_FLAGS.REMOTE_ACCESS;
pub const WBEM_RIGHT_SUBSCRIBE = WBEM_SECURITY_FLAGS.RIGHT_SUBSCRIBE;
pub const WBEM_RIGHT_PUBLISH = WBEM_SECURITY_FLAGS.RIGHT_PUBLISH;
pub const WBEM_LIMITATION_FLAG_TYPE = enum(i32) {
OBJECT_QUALIFIERS = 16,
PROPERTY_QUALIFIERS = 32,
};
pub const WBEM_FLAG_EXCLUDE_OBJECT_QUALIFIERS = WBEM_LIMITATION_FLAG_TYPE.OBJECT_QUALIFIERS;
pub const WBEM_FLAG_EXCLUDE_PROPERTY_QUALIFIERS = WBEM_LIMITATION_FLAG_TYPE.PROPERTY_QUALIFIERS;
pub const WBEM_TEXT_FLAG_TYPE = enum(i32) {
S = 1,
};
pub const WBEM_FLAG_NO_FLAVORS = WBEM_TEXT_FLAG_TYPE.S;
pub const WBEM_COMPARISON_FLAG = enum(i32) {
COMPARISON_INCLUDE_ALL = 0,
FLAG_IGNORE_QUALIFIERS = 1,
FLAG_IGNORE_OBJECT_SOURCE = 2,
FLAG_IGNORE_DEFAULT_VALUES = 4,
FLAG_IGNORE_CLASS = 8,
FLAG_IGNORE_CASE = 16,
FLAG_IGNORE_FLAVOR = 32,
};
pub const WBEM_COMPARISON_INCLUDE_ALL = WBEM_COMPARISON_FLAG.COMPARISON_INCLUDE_ALL;
pub const WBEM_FLAG_IGNORE_QUALIFIERS = WBEM_COMPARISON_FLAG.FLAG_IGNORE_QUALIFIERS;
pub const WBEM_FLAG_IGNORE_OBJECT_SOURCE = WBEM_COMPARISON_FLAG.FLAG_IGNORE_OBJECT_SOURCE;
pub const WBEM_FLAG_IGNORE_DEFAULT_VALUES = WBEM_COMPARISON_FLAG.FLAG_IGNORE_DEFAULT_VALUES;
pub const WBEM_FLAG_IGNORE_CLASS = WBEM_COMPARISON_FLAG.FLAG_IGNORE_CLASS;
pub const WBEM_FLAG_IGNORE_CASE = WBEM_COMPARISON_FLAG.FLAG_IGNORE_CASE;
pub const WBEM_FLAG_IGNORE_FLAVOR = WBEM_COMPARISON_FLAG.FLAG_IGNORE_FLAVOR;
pub const WBEM_LOCKING = enum(i32) {
D = 1,
};
pub const WBEM_FLAG_ALLOW_READ = WBEM_LOCKING.D;
pub const CIMTYPE_ENUMERATION = enum(i32) {
ILLEGAL = 4095,
EMPTY = 0,
SINT8 = 16,
UINT8 = 17,
SINT16 = 2,
UINT16 = 18,
SINT32 = 3,
UINT32 = 19,
SINT64 = 20,
UINT64 = 21,
REAL32 = 4,
REAL64 = 5,
BOOLEAN = 11,
STRING = 8,
DATETIME = 101,
REFERENCE = 102,
CHAR16 = 103,
OBJECT = 13,
FLAG_ARRAY = 8192,
};
pub const CIM_ILLEGAL = CIMTYPE_ENUMERATION.ILLEGAL;
pub const CIM_EMPTY = CIMTYPE_ENUMERATION.EMPTY;
pub const CIM_SINT8 = CIMTYPE_ENUMERATION.SINT8;
pub const CIM_UINT8 = CIMTYPE_ENUMERATION.UINT8;
pub const CIM_SINT16 = CIMTYPE_ENUMERATION.SINT16;
pub const CIM_UINT16 = CIMTYPE_ENUMERATION.UINT16;
pub const CIM_SINT32 = CIMTYPE_ENUMERATION.SINT32;
pub const CIM_UINT32 = CIMTYPE_ENUMERATION.UINT32;
pub const CIM_SINT64 = CIMTYPE_ENUMERATION.SINT64;
pub const CIM_UINT64 = CIMTYPE_ENUMERATION.UINT64;
pub const CIM_REAL32 = CIMTYPE_ENUMERATION.REAL32;
pub const CIM_REAL64 = CIMTYPE_ENUMERATION.REAL64;
pub const CIM_BOOLEAN = CIMTYPE_ENUMERATION.BOOLEAN;
pub const CIM_STRING = CIMTYPE_ENUMERATION.STRING;
pub const CIM_DATETIME = CIMTYPE_ENUMERATION.DATETIME;
pub const CIM_REFERENCE = CIMTYPE_ENUMERATION.REFERENCE;
pub const CIM_CHAR16 = CIMTYPE_ENUMERATION.CHAR16;
pub const CIM_OBJECT = CIMTYPE_ENUMERATION.OBJECT;
pub const CIM_FLAG_ARRAY = CIMTYPE_ENUMERATION.FLAG_ARRAY;
pub const WBEM_BACKUP_RESTORE_FLAGS = enum(i32) {
DEFAULT = 0,
FORCE_SHUTDOWN = 1,
};
pub const WBEM_FLAG_BACKUP_RESTORE_DEFAULT = WBEM_BACKUP_RESTORE_FLAGS.DEFAULT;
pub const WBEM_FLAG_BACKUP_RESTORE_FORCE_SHUTDOWN = WBEM_BACKUP_RESTORE_FLAGS.FORCE_SHUTDOWN;
pub const WBEM_REFRESHER_FLAGS = enum(i32) {
AUTO_RECONNECT = 0,
NO_AUTO_RECONNECT = 1,
};
pub const WBEM_FLAG_REFRESH_AUTO_RECONNECT = WBEM_REFRESHER_FLAGS.AUTO_RECONNECT;
pub const WBEM_FLAG_REFRESH_NO_AUTO_RECONNECT = WBEM_REFRESHER_FLAGS.NO_AUTO_RECONNECT;
pub const WBEM_SHUTDOWN_FLAGS = enum(i32) {
UNLOAD_COMPONENT = 1,
WMI = 2,
OS = 3,
};
pub const WBEM_SHUTDOWN_UNLOAD_COMPONENT = WBEM_SHUTDOWN_FLAGS.UNLOAD_COMPONENT;
pub const WBEM_SHUTDOWN_WMI = WBEM_SHUTDOWN_FLAGS.WMI;
pub const WBEM_SHUTDOWN_OS = WBEM_SHUTDOWN_FLAGS.OS;
pub const WBEMSTATUS_FORMAT = enum(i32) {
EWLINE = 0,
O_NEWLINE = 1,
};
pub const WBEMSTATUS_FORMAT_NEWLINE = WBEMSTATUS_FORMAT.EWLINE;
pub const WBEMSTATUS_FORMAT_NO_NEWLINE = WBEMSTATUS_FORMAT.O_NEWLINE;
pub const WBEM_LIMITS = enum(i32) {
IDENTIFIER = 4096,
QUERY = 16384,
PATH = 8192,
OBJECT_NESTING = 64,
USER_PROPERTIES = 1024,
};
pub const WBEM_MAX_IDENTIFIER = WBEM_LIMITS.IDENTIFIER;
pub const WBEM_MAX_QUERY = WBEM_LIMITS.QUERY;
pub const WBEM_MAX_PATH = WBEM_LIMITS.PATH;
pub const WBEM_MAX_OBJECT_NESTING = WBEM_LIMITS.OBJECT_NESTING;
pub const WBEM_MAX_USER_PROPERTIES = WBEM_LIMITS.USER_PROPERTIES;
pub const WBEMSTATUS = enum(i32) {
_NO_ERROR = 0,
// _S_NO_ERROR = 0, this enum value conflicts with _NO_ERROR
// _S_SAME = 0, this enum value conflicts with _NO_ERROR
_S_FALSE = 1,
_S_ALREADY_EXISTS = 262145,
_S_RESET_TO_DEFAULT = 262146,
_S_DIFFERENT = 262147,
_S_TIMEDOUT = 262148,
_S_NO_MORE_DATA = 262149,
_S_OPERATION_CANCELLED = 262150,
_S_PENDING = 262151,
_S_DUPLICATE_OBJECTS = 262152,
_S_ACCESS_DENIED = 262153,
_S_PARTIAL_RESULTS = 262160,
_S_SOURCE_NOT_AVAILABLE = 262167,
_E_FAILED = -2147217407,
_E_NOT_FOUND = -2147217406,
_E_ACCESS_DENIED = -2147217405,
_E_PROVIDER_FAILURE = -2147217404,
_E_TYPE_MISMATCH = -2147217403,
_E_OUT_OF_MEMORY = -2147217402,
_E_INVALID_CONTEXT = -2147217401,
_E_INVALID_PARAMETER = -2147217400,
_E_NOT_AVAILABLE = -2147217399,
_E_CRITICAL_ERROR = -2147217398,
_E_INVALID_STREAM = -2147217397,
_E_NOT_SUPPORTED = -2147217396,
_E_INVALID_SUPERCLASS = -2147217395,
_E_INVALID_NAMESPACE = -2147217394,
_E_INVALID_OBJECT = -2147217393,
_E_INVALID_CLASS = -2147217392,
_E_PROVIDER_NOT_FOUND = -2147217391,
_E_INVALID_PROVIDER_REGISTRATION = -2147217390,
_E_PROVIDER_LOAD_FAILURE = -2147217389,
_E_INITIALIZATION_FAILURE = -2147217388,
_E_TRANSPORT_FAILURE = -2147217387,
_E_INVALID_OPERATION = -2147217386,
_E_INVALID_QUERY = -2147217385,
_E_INVALID_QUERY_TYPE = -2147217384,
_E_ALREADY_EXISTS = -2147217383,
_E_OVERRIDE_NOT_ALLOWED = -2147217382,
_E_PROPAGATED_QUALIFIER = -2147217381,
_E_PROPAGATED_PROPERTY = -2147217380,
_E_UNEXPECTED = -2147217379,
_E_ILLEGAL_OPERATION = -2147217378,
_E_CANNOT_BE_KEY = -2147217377,
_E_INCOMPLETE_CLASS = -2147217376,
_E_INVALID_SYNTAX = -2147217375,
_E_NONDECORATED_OBJECT = -2147217374,
_E_READ_ONLY = -2147217373,
_E_PROVIDER_NOT_CAPABLE = -2147217372,
_E_CLASS_HAS_CHILDREN = -2147217371,
_E_CLASS_HAS_INSTANCES = -2147217370,
_E_QUERY_NOT_IMPLEMENTED = -2147217369,
_E_ILLEGAL_NULL = -2147217368,
_E_INVALID_QUALIFIER_TYPE = -2147217367,
_E_INVALID_PROPERTY_TYPE = -2147217366,
_E_VALUE_OUT_OF_RANGE = -2147217365,
_E_CANNOT_BE_SINGLETON = -2147217364,
_E_INVALID_CIM_TYPE = -2147217363,
_E_INVALID_METHOD = -2147217362,
_E_INVALID_METHOD_PARAMETERS = -2147217361,
_E_SYSTEM_PROPERTY = -2147217360,
_E_INVALID_PROPERTY = -2147217359,
_E_CALL_CANCELLED = -2147217358,
_E_SHUTTING_DOWN = -2147217357,
_E_PROPAGATED_METHOD = -2147217356,
_E_UNSUPPORTED_PARAMETER = -2147217355,
_E_MISSING_PARAMETER_ID = -2147217354,
_E_INVALID_PARAMETER_ID = -2147217353,
_E_NONCONSECUTIVE_PARAMETER_IDS = -2147217352,
_E_PARAMETER_ID_ON_RETVAL = -2147217351,
_E_INVALID_OBJECT_PATH = -2147217350,
_E_OUT_OF_DISK_SPACE = -2147217349,
_E_BUFFER_TOO_SMALL = -2147217348,
_E_UNSUPPORTED_PUT_EXTENSION = -2147217347,
_E_UNKNOWN_OBJECT_TYPE = -2147217346,
_E_UNKNOWN_PACKET_TYPE = -2147217345,
_E_MARSHAL_VERSION_MISMATCH = -2147217344,
_E_MARSHAL_INVALID_SIGNATURE = -2147217343,
_E_INVALID_QUALIFIER = -2147217342,
_E_INVALID_DUPLICATE_PARAMETER = -2147217341,
_E_TOO_MUCH_DATA = -2147217340,
_E_SERVER_TOO_BUSY = -2147217339,
_E_INVALID_FLAVOR = -2147217338,
_E_CIRCULAR_REFERENCE = -2147217337,
_E_UNSUPPORTED_CLASS_UPDATE = -2147217336,
_E_CANNOT_CHANGE_KEY_INHERITANCE = -2147217335,
_E_CANNOT_CHANGE_INDEX_INHERITANCE = -2147217328,
_E_TOO_MANY_PROPERTIES = -2147217327,
_E_UPDATE_TYPE_MISMATCH = -2147217326,
_E_UPDATE_OVERRIDE_NOT_ALLOWED = -2147217325,
_E_UPDATE_PROPAGATED_METHOD = -2147217324,
_E_METHOD_NOT_IMPLEMENTED = -2147217323,
_E_METHOD_DISABLED = -2147217322,
_E_REFRESHER_BUSY = -2147217321,
_E_UNPARSABLE_QUERY = -2147217320,
_E_NOT_EVENT_CLASS = -2147217319,
_E_MISSING_GROUP_WITHIN = -2147217318,
_E_MISSING_AGGREGATION_LIST = -2147217317,
_E_PROPERTY_NOT_AN_OBJECT = -2147217316,
_E_AGGREGATING_BY_OBJECT = -2147217315,
_E_UNINTERPRETABLE_PROVIDER_QUERY = -2147217313,
_E_BACKUP_RESTORE_WINMGMT_RUNNING = -2147217312,
_E_QUEUE_OVERFLOW = -2147217311,
_E_PRIVILEGE_NOT_HELD = -2147217310,
_E_INVALID_OPERATOR = -2147217309,
_E_LOCAL_CREDENTIALS = -2147217308,
_E_CANNOT_BE_ABSTRACT = -2147217307,
_E_AMENDED_OBJECT = -2147217306,
_E_CLIENT_TOO_SLOW = -2147217305,
_E_NULL_SECURITY_DESCRIPTOR = -2147217304,
_E_TIMED_OUT = -2147217303,
_E_INVALID_ASSOCIATION = -2147217302,
_E_AMBIGUOUS_OPERATION = -2147217301,
_E_QUOTA_VIOLATION = -2147217300,
_E_RESERVED_001 = -2147217299,
_E_RESERVED_002 = -2147217298,
_E_UNSUPPORTED_LOCALE = -2147217297,
_E_HANDLE_OUT_OF_DATE = -2147217296,
_E_CONNECTION_FAILED = -2147217295,
_E_INVALID_HANDLE_REQUEST = -2147217294,
_E_PROPERTY_NAME_TOO_WIDE = -2147217293,
_E_CLASS_NAME_TOO_WIDE = -2147217292,
_E_METHOD_NAME_TOO_WIDE = -2147217291,
_E_QUALIFIER_NAME_TOO_WIDE = -2147217290,
_E_RERUN_COMMAND = -2147217289,
_E_DATABASE_VER_MISMATCH = -2147217288,
_E_VETO_DELETE = -2147217287,
_E_VETO_PUT = -2147217286,
_E_INVALID_LOCALE = -2147217280,
_E_PROVIDER_SUSPENDED = -2147217279,
_E_SYNCHRONIZATION_REQUIRED = -2147217278,
_E_NO_SCHEMA = -2147217277,
_E_PROVIDER_ALREADY_REGISTERED = -2147217276,
_E_PROVIDER_NOT_REGISTERED = -2147217275,
_E_FATAL_TRANSPORT_ERROR = -2147217274,
_E_ENCRYPTED_CONNECTION_REQUIRED = -2147217273,
_E_PROVIDER_TIMED_OUT = -2147217272,
_E_NO_KEY = -2147217271,
_E_PROVIDER_DISABLED = -2147217270,
ESS_E_REGISTRATION_TOO_BROAD = -2147213311,
ESS_E_REGISTRATION_TOO_PRECISE = -2147213310,
ESS_E_AUTHZ_NOT_PRIVILEGED = -2147213309,
MOF_E_EXPECTED_QUALIFIER_NAME = -2147205119,
MOF_E_EXPECTED_SEMI = -2147205118,
MOF_E_EXPECTED_OPEN_BRACE = -2147205117,
MOF_E_EXPECTED_CLOSE_BRACE = -2147205116,
MOF_E_EXPECTED_CLOSE_BRACKET = -2147205115,
MOF_E_EXPECTED_CLOSE_PAREN = -2147205114,
MOF_E_ILLEGAL_CONSTANT_VALUE = -2147205113,
MOF_E_EXPECTED_TYPE_IDENTIFIER = -2147205112,
MOF_E_EXPECTED_OPEN_PAREN = -2147205111,
MOF_E_UNRECOGNIZED_TOKEN = -2147205110,
MOF_E_UNRECOGNIZED_TYPE = -2147205109,
MOF_E_EXPECTED_PROPERTY_NAME = -2147205108,
MOF_E_TYPEDEF_NOT_SUPPORTED = -2147205107,
MOF_E_UNEXPECTED_ALIAS = -2147205106,
MOF_E_UNEXPECTED_ARRAY_INIT = -2147205105,
MOF_E_INVALID_AMENDMENT_SYNTAX = -2147205104,
MOF_E_INVALID_DUPLICATE_AMENDMENT = -2147205103,
MOF_E_INVALID_PRAGMA = -2147205102,
MOF_E_INVALID_NAMESPACE_SYNTAX = -2147205101,
MOF_E_EXPECTED_CLASS_NAME = -2147205100,
MOF_E_TYPE_MISMATCH = -2147205099,
MOF_E_EXPECTED_ALIAS_NAME = -2147205098,
MOF_E_INVALID_CLASS_DECLARATION = -2147205097,
MOF_E_INVALID_INSTANCE_DECLARATION = -2147205096,
MOF_E_EXPECTED_DOLLAR = -2147205095,
MOF_E_CIMTYPE_QUALIFIER = -2147205094,
MOF_E_DUPLICATE_PROPERTY = -2147205093,
MOF_E_INVALID_NAMESPACE_SPECIFICATION = -2147205092,
MOF_E_OUT_OF_RANGE = -2147205091,
MOF_E_INVALID_FILE = -2147205090,
MOF_E_ALIASES_IN_EMBEDDED = -2147205089,
MOF_E_NULL_ARRAY_ELEM = -2147205088,
MOF_E_DUPLICATE_QUALIFIER = -2147205087,
MOF_E_EXPECTED_FLAVOR_TYPE = -2147205086,
MOF_E_INCOMPATIBLE_FLAVOR_TYPES = -2147205085,
MOF_E_MULTIPLE_ALIASES = -2147205084,
MOF_E_INCOMPATIBLE_FLAVOR_TYPES2 = -2147205083,
MOF_E_NO_ARRAYS_RETURNED = -2147205082,
MOF_E_MUST_BE_IN_OR_OUT = -2147205081,
MOF_E_INVALID_FLAGS_SYNTAX = -2147205080,
MOF_E_EXPECTED_BRACE_OR_BAD_TYPE = -2147205079,
MOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE = -2147205078,
MOF_E_UNSUPPORTED_CIMV22_DATA_TYPE = -2147205077,
MOF_E_INVALID_DELETEINSTANCE_SYNTAX = -2147205076,
MOF_E_INVALID_QUALIFIER_SYNTAX = -2147205075,
MOF_E_QUALIFIER_USED_OUTSIDE_SCOPE = -2147205074,
MOF_E_ERROR_CREATING_TEMP_FILE = -2147205073,
MOF_E_ERROR_INVALID_INCLUDE_FILE = -2147205072,
MOF_E_INVALID_DELETECLASS_SYNTAX = -2147205071,
};
pub const WBEM_NO_ERROR = WBEMSTATUS._NO_ERROR;
pub const WBEM_S_NO_ERROR = WBEMSTATUS._NO_ERROR;
pub const WBEM_S_SAME = WBEMSTATUS._NO_ERROR;
pub const WBEM_S_FALSE = WBEMSTATUS._S_FALSE;
pub const WBEM_S_ALREADY_EXISTS = WBEMSTATUS._S_ALREADY_EXISTS;
pub const WBEM_S_RESET_TO_DEFAULT = WBEMSTATUS._S_RESET_TO_DEFAULT;
pub const WBEM_S_DIFFERENT = WBEMSTATUS._S_DIFFERENT;
pub const WBEM_S_TIMEDOUT = WBEMSTATUS._S_TIMEDOUT;
pub const WBEM_S_NO_MORE_DATA = WBEMSTATUS._S_NO_MORE_DATA;
pub const WBEM_S_OPERATION_CANCELLED = WBEMSTATUS._S_OPERATION_CANCELLED;
pub const WBEM_S_PENDING = WBEMSTATUS._S_PENDING;
pub const WBEM_S_DUPLICATE_OBJECTS = WBEMSTATUS._S_DUPLICATE_OBJECTS;
pub const WBEM_S_ACCESS_DENIED = WBEMSTATUS._S_ACCESS_DENIED;
pub const WBEM_S_PARTIAL_RESULTS = WBEMSTATUS._S_PARTIAL_RESULTS;
pub const WBEM_S_SOURCE_NOT_AVAILABLE = WBEMSTATUS._S_SOURCE_NOT_AVAILABLE;
pub const WBEM_E_FAILED = WBEMSTATUS._E_FAILED;
pub const WBEM_E_NOT_FOUND = WBEMSTATUS._E_NOT_FOUND;
pub const WBEM_E_ACCESS_DENIED = WBEMSTATUS._E_ACCESS_DENIED;
pub const WBEM_E_PROVIDER_FAILURE = WBEMSTATUS._E_PROVIDER_FAILURE;
pub const WBEM_E_TYPE_MISMATCH = WBEMSTATUS._E_TYPE_MISMATCH;
pub const WBEM_E_OUT_OF_MEMORY = WBEMSTATUS._E_OUT_OF_MEMORY;
pub const WBEM_E_INVALID_CONTEXT = WBEMSTATUS._E_INVALID_CONTEXT;
pub const WBEM_E_INVALID_PARAMETER = WBEMSTATUS._E_INVALID_PARAMETER;
pub const WBEM_E_NOT_AVAILABLE = WBEMSTATUS._E_NOT_AVAILABLE;
pub const WBEM_E_CRITICAL_ERROR = WBEMSTATUS._E_CRITICAL_ERROR;
pub const WBEM_E_INVALID_STREAM = WBEMSTATUS._E_INVALID_STREAM;
pub const WBEM_E_NOT_SUPPORTED = WBEMSTATUS._E_NOT_SUPPORTED;
pub const WBEM_E_INVALID_SUPERCLASS = WBEMSTATUS._E_INVALID_SUPERCLASS;
pub const WBEM_E_INVALID_NAMESPACE = WBEMSTATUS._E_INVALID_NAMESPACE;
pub const WBEM_E_INVALID_OBJECT = WBEMSTATUS._E_INVALID_OBJECT;
pub const WBEM_E_INVALID_CLASS = WBEMSTATUS._E_INVALID_CLASS;
pub const WBEM_E_PROVIDER_NOT_FOUND = WBEMSTATUS._E_PROVIDER_NOT_FOUND;
pub const WBEM_E_INVALID_PROVIDER_REGISTRATION = WBEMSTATUS._E_INVALID_PROVIDER_REGISTRATION;
pub const WBEM_E_PROVIDER_LOAD_FAILURE = WBEMSTATUS._E_PROVIDER_LOAD_FAILURE;
pub const WBEM_E_INITIALIZATION_FAILURE = WBEMSTATUS._E_INITIALIZATION_FAILURE;
pub const WBEM_E_TRANSPORT_FAILURE = WBEMSTATUS._E_TRANSPORT_FAILURE;
pub const WBEM_E_INVALID_OPERATION = WBEMSTATUS._E_INVALID_OPERATION;
pub const WBEM_E_INVALID_QUERY = WBEMSTATUS._E_INVALID_QUERY;
pub const WBEM_E_INVALID_QUERY_TYPE = WBEMSTATUS._E_INVALID_QUERY_TYPE;
pub const WBEM_E_ALREADY_EXISTS = WBEMSTATUS._E_ALREADY_EXISTS;
pub const WBEM_E_OVERRIDE_NOT_ALLOWED = WBEMSTATUS._E_OVERRIDE_NOT_ALLOWED;
pub const WBEM_E_PROPAGATED_QUALIFIER = WBEMSTATUS._E_PROPAGATED_QUALIFIER;
pub const WBEM_E_PROPAGATED_PROPERTY = WBEMSTATUS._E_PROPAGATED_PROPERTY;
pub const WBEM_E_UNEXPECTED = WBEMSTATUS._E_UNEXPECTED;
pub const WBEM_E_ILLEGAL_OPERATION = WBEMSTATUS._E_ILLEGAL_OPERATION;
pub const WBEM_E_CANNOT_BE_KEY = WBEMSTATUS._E_CANNOT_BE_KEY;
pub const WBEM_E_INCOMPLETE_CLASS = WBEMSTATUS._E_INCOMPLETE_CLASS;
pub const WBEM_E_INVALID_SYNTAX = WBEMSTATUS._E_INVALID_SYNTAX;
pub const WBEM_E_NONDECORATED_OBJECT = WBEMSTATUS._E_NONDECORATED_OBJECT;
pub const WBEM_E_READ_ONLY = WBEMSTATUS._E_READ_ONLY;
pub const WBEM_E_PROVIDER_NOT_CAPABLE = WBEMSTATUS._E_PROVIDER_NOT_CAPABLE;
pub const WBEM_E_CLASS_HAS_CHILDREN = WBEMSTATUS._E_CLASS_HAS_CHILDREN;
pub const WBEM_E_CLASS_HAS_INSTANCES = WBEMSTATUS._E_CLASS_HAS_INSTANCES;
pub const WBEM_E_QUERY_NOT_IMPLEMENTED = WBEMSTATUS._E_QUERY_NOT_IMPLEMENTED;
pub const WBEM_E_ILLEGAL_NULL = WBEMSTATUS._E_ILLEGAL_NULL;
pub const WBEM_E_INVALID_QUALIFIER_TYPE = WBEMSTATUS._E_INVALID_QUALIFIER_TYPE;
pub const WBEM_E_INVALID_PROPERTY_TYPE = WBEMSTATUS._E_INVALID_PROPERTY_TYPE;
pub const WBEM_E_VALUE_OUT_OF_RANGE = WBEMSTATUS._E_VALUE_OUT_OF_RANGE;
pub const WBEM_E_CANNOT_BE_SINGLETON = WBEMSTATUS._E_CANNOT_BE_SINGLETON;
pub const WBEM_E_INVALID_CIM_TYPE = WBEMSTATUS._E_INVALID_CIM_TYPE;
pub const WBEM_E_INVALID_METHOD = WBEMSTATUS._E_INVALID_METHOD;
pub const WBEM_E_INVALID_METHOD_PARAMETERS = WBEMSTATUS._E_INVALID_METHOD_PARAMETERS;
pub const WBEM_E_SYSTEM_PROPERTY = WBEMSTATUS._E_SYSTEM_PROPERTY;
pub const WBEM_E_INVALID_PROPERTY = WBEMSTATUS._E_INVALID_PROPERTY;
pub const WBEM_E_CALL_CANCELLED = WBEMSTATUS._E_CALL_CANCELLED;
pub const WBEM_E_SHUTTING_DOWN = WBEMSTATUS._E_SHUTTING_DOWN;
pub const WBEM_E_PROPAGATED_METHOD = WBEMSTATUS._E_PROPAGATED_METHOD;
pub const WBEM_E_UNSUPPORTED_PARAMETER = WBEMSTATUS._E_UNSUPPORTED_PARAMETER;
pub const WBEM_E_MISSING_PARAMETER_ID = WBEMSTATUS._E_MISSING_PARAMETER_ID;
pub const WBEM_E_INVALID_PARAMETER_ID = WBEMSTATUS._E_INVALID_PARAMETER_ID;
pub const WBEM_E_NONCONSECUTIVE_PARAMETER_IDS = WBEMSTATUS._E_NONCONSECUTIVE_PARAMETER_IDS;
pub const WBEM_E_PARAMETER_ID_ON_RETVAL = WBEMSTATUS._E_PARAMETER_ID_ON_RETVAL;
pub const WBEM_E_INVALID_OBJECT_PATH = WBEMSTATUS._E_INVALID_OBJECT_PATH;
pub const WBEM_E_OUT_OF_DISK_SPACE = WBEMSTATUS._E_OUT_OF_DISK_SPACE;
pub const WBEM_E_BUFFER_TOO_SMALL = WBEMSTATUS._E_BUFFER_TOO_SMALL;
pub const WBEM_E_UNSUPPORTED_PUT_EXTENSION = WBEMSTATUS._E_UNSUPPORTED_PUT_EXTENSION;
pub const WBEM_E_UNKNOWN_OBJECT_TYPE = WBEMSTATUS._E_UNKNOWN_OBJECT_TYPE;
pub const WBEM_E_UNKNOWN_PACKET_TYPE = WBEMSTATUS._E_UNKNOWN_PACKET_TYPE;
pub const WBEM_E_MARSHAL_VERSION_MISMATCH = WBEMSTATUS._E_MARSHAL_VERSION_MISMATCH;
pub const WBEM_E_MARSHAL_INVALID_SIGNATURE = WBEMSTATUS._E_MARSHAL_INVALID_SIGNATURE;
pub const WBEM_E_INVALID_QUALIFIER = WBEMSTATUS._E_INVALID_QUALIFIER;
pub const WBEM_E_INVALID_DUPLICATE_PARAMETER = WBEMSTATUS._E_INVALID_DUPLICATE_PARAMETER;
pub const WBEM_E_TOO_MUCH_DATA = WBEMSTATUS._E_TOO_MUCH_DATA;
pub const WBEM_E_SERVER_TOO_BUSY = WBEMSTATUS._E_SERVER_TOO_BUSY;
pub const WBEM_E_INVALID_FLAVOR = WBEMSTATUS._E_INVALID_FLAVOR;
pub const WBEM_E_CIRCULAR_REFERENCE = WBEMSTATUS._E_CIRCULAR_REFERENCE;
pub const WBEM_E_UNSUPPORTED_CLASS_UPDATE = WBEMSTATUS._E_UNSUPPORTED_CLASS_UPDATE;
pub const WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE = WBEMSTATUS._E_CANNOT_CHANGE_KEY_INHERITANCE;
pub const WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE = WBEMSTATUS._E_CANNOT_CHANGE_INDEX_INHERITANCE;
pub const WBEM_E_TOO_MANY_PROPERTIES = WBEMSTATUS._E_TOO_MANY_PROPERTIES;
pub const WBEM_E_UPDATE_TYPE_MISMATCH = WBEMSTATUS._E_UPDATE_TYPE_MISMATCH;
pub const WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED = WBEMSTATUS._E_UPDATE_OVERRIDE_NOT_ALLOWED;
pub const WBEM_E_UPDATE_PROPAGATED_METHOD = WBEMSTATUS._E_UPDATE_PROPAGATED_METHOD;
pub const WBEM_E_METHOD_NOT_IMPLEMENTED = WBEMSTATUS._E_METHOD_NOT_IMPLEMENTED;
pub const WBEM_E_METHOD_DISABLED = WBEMSTATUS._E_METHOD_DISABLED;
pub const WBEM_E_REFRESHER_BUSY = WBEMSTATUS._E_REFRESHER_BUSY;
pub const WBEM_E_UNPARSABLE_QUERY = WBEMSTATUS._E_UNPARSABLE_QUERY;
pub const WBEM_E_NOT_EVENT_CLASS = WBEMSTATUS._E_NOT_EVENT_CLASS;
pub const WBEM_E_MISSING_GROUP_WITHIN = WBEMSTATUS._E_MISSING_GROUP_WITHIN;
pub const WBEM_E_MISSING_AGGREGATION_LIST = WBEMSTATUS._E_MISSING_AGGREGATION_LIST;
pub const WBEM_E_PROPERTY_NOT_AN_OBJECT = WBEMSTATUS._E_PROPERTY_NOT_AN_OBJECT;
pub const WBEM_E_AGGREGATING_BY_OBJECT = WBEMSTATUS._E_AGGREGATING_BY_OBJECT;
pub const WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY = WBEMSTATUS._E_UNINTERPRETABLE_PROVIDER_QUERY;
pub const WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING = WBEMSTATUS._E_BACKUP_RESTORE_WINMGMT_RUNNING;
pub const WBEM_E_QUEUE_OVERFLOW = WBEMSTATUS._E_QUEUE_OVERFLOW;
pub const WBEM_E_PRIVILEGE_NOT_HELD = WBEMSTATUS._E_PRIVILEGE_NOT_HELD;
pub const WBEM_E_INVALID_OPERATOR = WBEMSTATUS._E_INVALID_OPERATOR;
pub const WBEM_E_LOCAL_CREDENTIALS = WBEMSTATUS._E_LOCAL_CREDENTIALS;
pub const WBEM_E_CANNOT_BE_ABSTRACT = WBEMSTATUS._E_CANNOT_BE_ABSTRACT;
pub const WBEM_E_AMENDED_OBJECT = WBEMSTATUS._E_AMENDED_OBJECT;
pub const WBEM_E_CLIENT_TOO_SLOW = WBEMSTATUS._E_CLIENT_TOO_SLOW;
pub const WBEM_E_NULL_SECURITY_DESCRIPTOR = WBEMSTATUS._E_NULL_SECURITY_DESCRIPTOR;
pub const WBEM_E_TIMED_OUT = WBEMSTATUS._E_TIMED_OUT;
pub const WBEM_E_INVALID_ASSOCIATION = WBEMSTATUS._E_INVALID_ASSOCIATION;
pub const WBEM_E_AMBIGUOUS_OPERATION = WBEMSTATUS._E_AMBIGUOUS_OPERATION;
pub const WBEM_E_QUOTA_VIOLATION = WBEMSTATUS._E_QUOTA_VIOLATION;
pub const WBEM_E_RESERVED_001 = WBEMSTATUS._E_RESERVED_001;
pub const WBEM_E_RESERVED_002 = WBEMSTATUS._E_RESERVED_002;
pub const WBEM_E_UNSUPPORTED_LOCALE = WBEMSTATUS._E_UNSUPPORTED_LOCALE;
pub const WBEM_E_HANDLE_OUT_OF_DATE = WBEMSTATUS._E_HANDLE_OUT_OF_DATE;
pub const WBEM_E_CONNECTION_FAILED = WBEMSTATUS._E_CONNECTION_FAILED;
pub const WBEM_E_INVALID_HANDLE_REQUEST = WBEMSTATUS._E_INVALID_HANDLE_REQUEST;
pub const WBEM_E_PROPERTY_NAME_TOO_WIDE = WBEMSTATUS._E_PROPERTY_NAME_TOO_WIDE;
pub const WBEM_E_CLASS_NAME_TOO_WIDE = WBEMSTATUS._E_CLASS_NAME_TOO_WIDE;
pub const WBEM_E_METHOD_NAME_TOO_WIDE = WBEMSTATUS._E_METHOD_NAME_TOO_WIDE;
pub const WBEM_E_QUALIFIER_NAME_TOO_WIDE = WBEMSTATUS._E_QUALIFIER_NAME_TOO_WIDE;
pub const WBEM_E_RERUN_COMMAND = WBEMSTATUS._E_RERUN_COMMAND;
pub const WBEM_E_DATABASE_VER_MISMATCH = WBEMSTATUS._E_DATABASE_VER_MISMATCH;
pub const WBEM_E_VETO_DELETE = WBEMSTATUS._E_VETO_DELETE;
pub const WBEM_E_VETO_PUT = WBEMSTATUS._E_VETO_PUT;
pub const WBEM_E_INVALID_LOCALE = WBEMSTATUS._E_INVALID_LOCALE;
pub const WBEM_E_PROVIDER_SUSPENDED = WBEMSTATUS._E_PROVIDER_SUSPENDED;
pub const WBEM_E_SYNCHRONIZATION_REQUIRED = WBEMSTATUS._E_SYNCHRONIZATION_REQUIRED;
pub const WBEM_E_NO_SCHEMA = WBEMSTATUS._E_NO_SCHEMA;
pub const WBEM_E_PROVIDER_ALREADY_REGISTERED = WBEMSTATUS._E_PROVIDER_ALREADY_REGISTERED;
pub const WBEM_E_PROVIDER_NOT_REGISTERED = WBEMSTATUS._E_PROVIDER_NOT_REGISTERED;
pub const WBEM_E_FATAL_TRANSPORT_ERROR = WBEMSTATUS._E_FATAL_TRANSPORT_ERROR;
pub const WBEM_E_ENCRYPTED_CONNECTION_REQUIRED = WBEMSTATUS._E_ENCRYPTED_CONNECTION_REQUIRED;
pub const WBEM_E_PROVIDER_TIMED_OUT = WBEMSTATUS._E_PROVIDER_TIMED_OUT;
pub const WBEM_E_NO_KEY = WBEMSTATUS._E_NO_KEY;
pub const WBEM_E_PROVIDER_DISABLED = WBEMSTATUS._E_PROVIDER_DISABLED;
pub const WBEMESS_E_REGISTRATION_TOO_BROAD = WBEMSTATUS.ESS_E_REGISTRATION_TOO_BROAD;
pub const WBEMESS_E_REGISTRATION_TOO_PRECISE = WBEMSTATUS.ESS_E_REGISTRATION_TOO_PRECISE;
pub const WBEMESS_E_AUTHZ_NOT_PRIVILEGED = WBEMSTATUS.ESS_E_AUTHZ_NOT_PRIVILEGED;
pub const WBEMMOF_E_EXPECTED_QUALIFIER_NAME = WBEMSTATUS.MOF_E_EXPECTED_QUALIFIER_NAME;
pub const WBEMMOF_E_EXPECTED_SEMI = WBEMSTATUS.MOF_E_EXPECTED_SEMI;
pub const WBEMMOF_E_EXPECTED_OPEN_BRACE = WBEMSTATUS.MOF_E_EXPECTED_OPEN_BRACE;
pub const WBEMMOF_E_EXPECTED_CLOSE_BRACE = WBEMSTATUS.MOF_E_EXPECTED_CLOSE_BRACE;
pub const WBEMMOF_E_EXPECTED_CLOSE_BRACKET = WBEMSTATUS.MOF_E_EXPECTED_CLOSE_BRACKET;
pub const WBEMMOF_E_EXPECTED_CLOSE_PAREN = WBEMSTATUS.MOF_E_EXPECTED_CLOSE_PAREN;
pub const WBEMMOF_E_ILLEGAL_CONSTANT_VALUE = WBEMSTATUS.MOF_E_ILLEGAL_CONSTANT_VALUE;
pub const WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER = WBEMSTATUS.MOF_E_EXPECTED_TYPE_IDENTIFIER;
pub const WBEMMOF_E_EXPECTED_OPEN_PAREN = WBEMSTATUS.MOF_E_EXPECTED_OPEN_PAREN;
pub const WBEMMOF_E_UNRECOGNIZED_TOKEN = WBEMSTATUS.MOF_E_UNRECOGNIZED_TOKEN;
pub const WBEMMOF_E_UNRECOGNIZED_TYPE = WBEMSTATUS.MOF_E_UNRECOGNIZED_TYPE;
pub const WBEMMOF_E_EXPECTED_PROPERTY_NAME = WBEMSTATUS.MOF_E_EXPECTED_PROPERTY_NAME;
pub const WBEMMOF_E_TYPEDEF_NOT_SUPPORTED = WBEMSTATUS.MOF_E_TYPEDEF_NOT_SUPPORTED;
pub const WBEMMOF_E_UNEXPECTED_ALIAS = WBEMSTATUS.MOF_E_UNEXPECTED_ALIAS;
pub const WBEMMOF_E_UNEXPECTED_ARRAY_INIT = WBEMSTATUS.MOF_E_UNEXPECTED_ARRAY_INIT;
pub const WBEMMOF_E_INVALID_AMENDMENT_SYNTAX = WBEMSTATUS.MOF_E_INVALID_AMENDMENT_SYNTAX;
pub const WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT = WBEMSTATUS.MOF_E_INVALID_DUPLICATE_AMENDMENT;
pub const WBEMMOF_E_INVALID_PRAGMA = WBEMSTATUS.MOF_E_INVALID_PRAGMA;
pub const WBEMMOF_E_INVALID_NAMESPACE_SYNTAX = WBEMSTATUS.MOF_E_INVALID_NAMESPACE_SYNTAX;
pub const WBEMMOF_E_EXPECTED_CLASS_NAME = WBEMSTATUS.MOF_E_EXPECTED_CLASS_NAME;
pub const WBEMMOF_E_TYPE_MISMATCH = WBEMSTATUS.MOF_E_TYPE_MISMATCH;
pub const WBEMMOF_E_EXPECTED_ALIAS_NAME = WBEMSTATUS.MOF_E_EXPECTED_ALIAS_NAME;
pub const WBEMMOF_E_INVALID_CLASS_DECLARATION = WBEMSTATUS.MOF_E_INVALID_CLASS_DECLARATION;
pub const WBEMMOF_E_INVALID_INSTANCE_DECLARATION = WBEMSTATUS.MOF_E_INVALID_INSTANCE_DECLARATION;
pub const WBEMMOF_E_EXPECTED_DOLLAR = WBEMSTATUS.MOF_E_EXPECTED_DOLLAR;
pub const WBEMMOF_E_CIMTYPE_QUALIFIER = WBEMSTATUS.MOF_E_CIMTYPE_QUALIFIER;
pub const WBEMMOF_E_DUPLICATE_PROPERTY = WBEMSTATUS.MOF_E_DUPLICATE_PROPERTY;
pub const WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION = WBEMSTATUS.MOF_E_INVALID_NAMESPACE_SPECIFICATION;
pub const WBEMMOF_E_OUT_OF_RANGE = WBEMSTATUS.MOF_E_OUT_OF_RANGE;
pub const WBEMMOF_E_INVALID_FILE = WBEMSTATUS.MOF_E_INVALID_FILE;
pub const WBEMMOF_E_ALIASES_IN_EMBEDDED = WBEMSTATUS.MOF_E_ALIASES_IN_EMBEDDED;
pub const WBEMMOF_E_NULL_ARRAY_ELEM = WBEMSTATUS.MOF_E_NULL_ARRAY_ELEM;
pub const WBEMMOF_E_DUPLICATE_QUALIFIER = WBEMSTATUS.MOF_E_DUPLICATE_QUALIFIER;
pub const WBEMMOF_E_EXPECTED_FLAVOR_TYPE = WBEMSTATUS.MOF_E_EXPECTED_FLAVOR_TYPE;
pub const WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES = WBEMSTATUS.MOF_E_INCOMPATIBLE_FLAVOR_TYPES;
pub const WBEMMOF_E_MULTIPLE_ALIASES = WBEMSTATUS.MOF_E_MULTIPLE_ALIASES;
pub const WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2 = WBEMSTATUS.MOF_E_INCOMPATIBLE_FLAVOR_TYPES2;
pub const WBEMMOF_E_NO_ARRAYS_RETURNED = WBEMSTATUS.MOF_E_NO_ARRAYS_RETURNED;
pub const WBEMMOF_E_MUST_BE_IN_OR_OUT = WBEMSTATUS.MOF_E_MUST_BE_IN_OR_OUT;
pub const WBEMMOF_E_INVALID_FLAGS_SYNTAX = WBEMSTATUS.MOF_E_INVALID_FLAGS_SYNTAX;
pub const WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE = WBEMSTATUS.MOF_E_EXPECTED_BRACE_OR_BAD_TYPE;
pub const WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE = WBEMSTATUS.MOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE;
pub const WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE = WBEMSTATUS.MOF_E_UNSUPPORTED_CIMV22_DATA_TYPE;
pub const WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX = WBEMSTATUS.MOF_E_INVALID_DELETEINSTANCE_SYNTAX;
pub const WBEMMOF_E_INVALID_QUALIFIER_SYNTAX = WBEMSTATUS.MOF_E_INVALID_QUALIFIER_SYNTAX;
pub const WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE = WBEMSTATUS.MOF_E_QUALIFIER_USED_OUTSIDE_SCOPE;
pub const WBEMMOF_E_ERROR_CREATING_TEMP_FILE = WBEMSTATUS.MOF_E_ERROR_CREATING_TEMP_FILE;
pub const WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE = WBEMSTATUS.MOF_E_ERROR_INVALID_INCLUDE_FILE;
pub const WBEMMOF_E_INVALID_DELETECLASS_SYNTAX = WBEMSTATUS.MOF_E_INVALID_DELETECLASS_SYNTAX;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemClassObject_Value = @import("../zig.zig").Guid.initString("dc12a681-737f-11cf-884d-00aa004b2e24");
pub const IID_IWbemClassObject = &IID_IWbemClassObject_Value;
pub const IWbemClassObject = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetQualifierSet: fn(
self: *const IWbemClassObject,
ppQualSet: ?*?*IWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Get: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
lFlags: i32,
pVal: ?*VARIANT,
pType: ?*i32,
plFlavor: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Put: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
lFlags: i32,
pVal: ?*VARIANT,
Type: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNames: fn(
self: *const IWbemClassObject,
wszQualifierName: ?[*:0]const u16,
lFlags: i32,
pQualifierVal: ?*VARIANT,
pNames: ?*?*SAFEARRAY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginEnumeration: fn(
self: *const IWbemClassObject,
lEnumFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IWbemClassObject,
lFlags: i32,
strName: ?*?BSTR,
pVal: ?*VARIANT,
pType: ?*i32,
plFlavor: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndEnumeration: fn(
self: *const IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyQualifierSet: fn(
self: *const IWbemClassObject,
wszProperty: ?[*:0]const u16,
ppQualSet: ?*?*IWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IWbemClassObject,
ppCopy: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectText: fn(
self: *const IWbemClassObject,
lFlags: i32,
pstrObjectText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SpawnDerivedClass: fn(
self: *const IWbemClassObject,
lFlags: i32,
ppNewClass: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SpawnInstance: fn(
self: *const IWbemClassObject,
lFlags: i32,
ppNewInstance: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CompareTo: fn(
self: *const IWbemClassObject,
lFlags: i32,
pCompareTo: ?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyOrigin: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
pstrClassName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InheritsFrom: fn(
self: *const IWbemClassObject,
strAncestor: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMethod: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
lFlags: i32,
ppInSignature: ?*?*IWbemClassObject,
ppOutSignature: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutMethod: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
lFlags: i32,
pInSignature: ?*IWbemClassObject,
pOutSignature: ?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteMethod: fn(
self: *const IWbemClassObject,
wszName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginMethodEnumeration: fn(
self: *const IWbemClassObject,
lEnumFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NextMethod: fn(
self: *const IWbemClassObject,
lFlags: i32,
pstrName: ?*?BSTR,
ppInSignature: ?*?*IWbemClassObject,
ppOutSignature: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndMethodEnumeration: fn(
self: *const IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMethodQualifierSet: fn(
self: *const IWbemClassObject,
wszMethod: ?[*:0]const u16,
ppQualSet: ?*?*IWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetMethodOrigin: fn(
self: *const IWbemClassObject,
wszMethodName: ?[*:0]const u16,
pstrClassName: ?*?BSTR,
) 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 IWbemClassObject_GetQualifierSet(self: *const T, ppQualSet: ?*?*IWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetQualifierSet(@ptrCast(*const IWbemClassObject, self), ppQualSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_Get(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pVal: ?*VARIANT, pType: ?*i32, plFlavor: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).Get(@ptrCast(*const IWbemClassObject, self), wszName, lFlags, pVal, pType, plFlavor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_Put(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pVal: ?*VARIANT, Type: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).Put(@ptrCast(*const IWbemClassObject, self), wszName, lFlags, pVal, Type);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_Delete(self: *const T, wszName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).Delete(@ptrCast(*const IWbemClassObject, self), wszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetNames(self: *const T, wszQualifierName: ?[*:0]const u16, lFlags: i32, pQualifierVal: ?*VARIANT, pNames: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetNames(@ptrCast(*const IWbemClassObject, self), wszQualifierName, lFlags, pQualifierVal, pNames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_BeginEnumeration(self: *const T, lEnumFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).BeginEnumeration(@ptrCast(*const IWbemClassObject, self), lEnumFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_Next(self: *const T, lFlags: i32, strName: ?*?BSTR, pVal: ?*VARIANT, pType: ?*i32, plFlavor: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).Next(@ptrCast(*const IWbemClassObject, self), lFlags, strName, pVal, pType, plFlavor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_EndEnumeration(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).EndEnumeration(@ptrCast(*const IWbemClassObject, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetPropertyQualifierSet(self: *const T, wszProperty: ?[*:0]const u16, ppQualSet: ?*?*IWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetPropertyQualifierSet(@ptrCast(*const IWbemClassObject, self), wszProperty, ppQualSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_Clone(self: *const T, ppCopy: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).Clone(@ptrCast(*const IWbemClassObject, self), ppCopy);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetObjectText(self: *const T, lFlags: i32, pstrObjectText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetObjectText(@ptrCast(*const IWbemClassObject, self), lFlags, pstrObjectText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_SpawnDerivedClass(self: *const T, lFlags: i32, ppNewClass: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).SpawnDerivedClass(@ptrCast(*const IWbemClassObject, self), lFlags, ppNewClass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_SpawnInstance(self: *const T, lFlags: i32, ppNewInstance: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).SpawnInstance(@ptrCast(*const IWbemClassObject, self), lFlags, ppNewInstance);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_CompareTo(self: *const T, lFlags: i32, pCompareTo: ?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).CompareTo(@ptrCast(*const IWbemClassObject, self), lFlags, pCompareTo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetPropertyOrigin(self: *const T, wszName: ?[*:0]const u16, pstrClassName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetPropertyOrigin(@ptrCast(*const IWbemClassObject, self), wszName, pstrClassName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_InheritsFrom(self: *const T, strAncestor: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).InheritsFrom(@ptrCast(*const IWbemClassObject, self), strAncestor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetMethod(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, ppInSignature: ?*?*IWbemClassObject, ppOutSignature: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetMethod(@ptrCast(*const IWbemClassObject, self), wszName, lFlags, ppInSignature, ppOutSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_PutMethod(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pInSignature: ?*IWbemClassObject, pOutSignature: ?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).PutMethod(@ptrCast(*const IWbemClassObject, self), wszName, lFlags, pInSignature, pOutSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_DeleteMethod(self: *const T, wszName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).DeleteMethod(@ptrCast(*const IWbemClassObject, self), wszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_BeginMethodEnumeration(self: *const T, lEnumFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).BeginMethodEnumeration(@ptrCast(*const IWbemClassObject, self), lEnumFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_NextMethod(self: *const T, lFlags: i32, pstrName: ?*?BSTR, ppInSignature: ?*?*IWbemClassObject, ppOutSignature: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).NextMethod(@ptrCast(*const IWbemClassObject, self), lFlags, pstrName, ppInSignature, ppOutSignature);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_EndMethodEnumeration(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).EndMethodEnumeration(@ptrCast(*const IWbemClassObject, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetMethodQualifierSet(self: *const T, wszMethod: ?[*:0]const u16, ppQualSet: ?*?*IWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetMethodQualifierSet(@ptrCast(*const IWbemClassObject, self), wszMethod, ppQualSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClassObject_GetMethodOrigin(self: *const T, wszMethodName: ?[*:0]const u16, pstrClassName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClassObject.VTable, self.vtable).GetMethodOrigin(@ptrCast(*const IWbemClassObject, self), wszMethodName, pstrClassName);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemObjectAccess_Value = @import("../zig.zig").Guid.initString("49353c9a-516b-11d1-aea6-00c04fb68820");
pub const IID_IWbemObjectAccess = &IID_IWbemObjectAccess_Value;
pub const IWbemObjectAccess = extern struct {
pub const VTable = extern struct {
base: IWbemClassObject.VTable,
GetPropertyHandle: fn(
self: *const IWbemObjectAccess,
wszPropertyName: ?[*:0]const u16,
pType: ?*i32,
plHandle: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WritePropertyValue: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
lNumBytes: i32,
aData: [*:0]const u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadPropertyValue: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
lBufferSize: i32,
plNumBytes: ?*i32,
aData: [*:0]u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadDWORD: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
pdw: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteDWORD: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
dw: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReadQWORD: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
pqw: ?*u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteQWORD: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
pw: u64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetPropertyInfoByHandle: fn(
self: *const IWbemObjectAccess,
lHandle: i32,
pstrName: ?*?BSTR,
pType: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Lock: fn(
self: *const IWbemObjectAccess,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Unlock: fn(
self: *const IWbemObjectAccess,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWbemClassObject.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_GetPropertyHandle(self: *const T, wszPropertyName: ?[*:0]const u16, pType: ?*i32, plHandle: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).GetPropertyHandle(@ptrCast(*const IWbemObjectAccess, self), wszPropertyName, pType, plHandle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_WritePropertyValue(self: *const T, lHandle: i32, lNumBytes: i32, aData: [*:0]const u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).WritePropertyValue(@ptrCast(*const IWbemObjectAccess, self), lHandle, lNumBytes, aData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_ReadPropertyValue(self: *const T, lHandle: i32, lBufferSize: i32, plNumBytes: ?*i32, aData: [*:0]u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).ReadPropertyValue(@ptrCast(*const IWbemObjectAccess, self), lHandle, lBufferSize, plNumBytes, aData);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_ReadDWORD(self: *const T, lHandle: i32, pdw: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).ReadDWORD(@ptrCast(*const IWbemObjectAccess, self), lHandle, pdw);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_WriteDWORD(self: *const T, lHandle: i32, dw: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).WriteDWORD(@ptrCast(*const IWbemObjectAccess, self), lHandle, dw);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_ReadQWORD(self: *const T, lHandle: i32, pqw: ?*u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).ReadQWORD(@ptrCast(*const IWbemObjectAccess, self), lHandle, pqw);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_WriteQWORD(self: *const T, lHandle: i32, pw: u64) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).WriteQWORD(@ptrCast(*const IWbemObjectAccess, self), lHandle, pw);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_GetPropertyInfoByHandle(self: *const T, lHandle: i32, pstrName: ?*?BSTR, pType: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).GetPropertyInfoByHandle(@ptrCast(*const IWbemObjectAccess, self), lHandle, pstrName, pType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_Lock(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).Lock(@ptrCast(*const IWbemObjectAccess, self), lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectAccess_Unlock(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectAccess.VTable, self.vtable).Unlock(@ptrCast(*const IWbemObjectAccess, self), lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemQualifierSet_Value = @import("../zig.zig").Guid.initString("dc12a680-737f-11cf-884d-00aa004b2e24");
pub const IID_IWbemQualifierSet = &IID_IWbemQualifierSet_Value;
pub const IWbemQualifierSet = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Get: fn(
self: *const IWbemQualifierSet,
wszName: ?[*:0]const u16,
lFlags: i32,
pVal: ?*VARIANT,
plFlavor: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Put: fn(
self: *const IWbemQualifierSet,
wszName: ?[*:0]const u16,
pVal: ?*VARIANT,
lFlavor: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const IWbemQualifierSet,
wszName: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNames: fn(
self: *const IWbemQualifierSet,
lFlags: i32,
pNames: ?*?*SAFEARRAY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginEnumeration: fn(
self: *const IWbemQualifierSet,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IWbemQualifierSet,
lFlags: i32,
pstrName: ?*?BSTR,
pVal: ?*VARIANT,
plFlavor: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndEnumeration: fn(
self: *const IWbemQualifierSet,
) 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 IWbemQualifierSet_Get(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pVal: ?*VARIANT, plFlavor: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).Get(@ptrCast(*const IWbemQualifierSet, self), wszName, lFlags, pVal, plFlavor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_Put(self: *const T, wszName: ?[*:0]const u16, pVal: ?*VARIANT, lFlavor: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).Put(@ptrCast(*const IWbemQualifierSet, self), wszName, pVal, lFlavor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_Delete(self: *const T, wszName: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).Delete(@ptrCast(*const IWbemQualifierSet, self), wszName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_GetNames(self: *const T, lFlags: i32, pNames: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).GetNames(@ptrCast(*const IWbemQualifierSet, self), lFlags, pNames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_BeginEnumeration(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).BeginEnumeration(@ptrCast(*const IWbemQualifierSet, self), lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_Next(self: *const T, lFlags: i32, pstrName: ?*?BSTR, pVal: ?*VARIANT, plFlavor: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).Next(@ptrCast(*const IWbemQualifierSet, self), lFlags, pstrName, pVal, plFlavor);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemQualifierSet_EndEnumeration(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemQualifierSet.VTable, self.vtable).EndEnumeration(@ptrCast(*const IWbemQualifierSet, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemServices_Value = @import("../zig.zig").Guid.initString("9556dc99-828c-11cf-a37e-00aa003240c7");
pub const IID_IWbemServices = &IID_IWbemServices_Value;
pub const IWbemServices = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
OpenNamespace: fn(
self: *const IWbemServices,
strNamespace: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppWorkingNamespace: ?*?*IWbemServices,
ppResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CancelAsyncCall: fn(
self: *const IWbemServices,
pSink: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
QueryObjectSink: fn(
self: *const IWbemServices,
lFlags: i32,
ppResponseHandler: ?*?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObject: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppObject: ?*?*IWbemClassObject,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectAsync: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutClass: fn(
self: *const IWbemServices,
pObject: ?*IWbemClassObject,
lFlags: i32,
pCtx: ?*IWbemContext,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutClassAsync: fn(
self: *const IWbemServices,
pObject: ?*IWbemClassObject,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteClass: fn(
self: *const IWbemServices,
strClass: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteClassAsync: fn(
self: *const IWbemServices,
strClass: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateClassEnum: fn(
self: *const IWbemServices,
strSuperclass: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppEnum: ?*?*IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateClassEnumAsync: fn(
self: *const IWbemServices,
strSuperclass: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutInstance: fn(
self: *const IWbemServices,
pInst: ?*IWbemClassObject,
lFlags: i32,
pCtx: ?*IWbemContext,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutInstanceAsync: fn(
self: *const IWbemServices,
pInst: ?*IWbemClassObject,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteInstance: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteInstanceAsync: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateInstanceEnum: fn(
self: *const IWbemServices,
strFilter: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppEnum: ?*?*IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateInstanceEnumAsync: fn(
self: *const IWbemServices,
strFilter: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecQuery: fn(
self: *const IWbemServices,
strQueryLanguage: ?BSTR,
strQuery: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppEnum: ?*?*IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecQueryAsync: fn(
self: *const IWbemServices,
strQueryLanguage: ?BSTR,
strQuery: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecNotificationQuery: fn(
self: *const IWbemServices,
strQueryLanguage: ?BSTR,
strQuery: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppEnum: ?*?*IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecNotificationQueryAsync: fn(
self: *const IWbemServices,
strQueryLanguage: ?BSTR,
strQuery: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethod: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
strMethodName: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pInParams: ?*IWbemClassObject,
ppOutParams: ?*?*IWbemClassObject,
ppCallResult: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethodAsync: fn(
self: *const IWbemServices,
strObjectPath: ?BSTR,
strMethodName: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pInParams: ?*IWbemClassObject,
pResponseHandler: ?*IWbemObjectSink,
) 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 IWbemServices_OpenNamespace(self: *const T, strNamespace: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppWorkingNamespace: ?*?*IWbemServices, ppResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).OpenNamespace(@ptrCast(*const IWbemServices, self), strNamespace, lFlags, pCtx, ppWorkingNamespace, ppResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_CancelAsyncCall(self: *const T, pSink: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).CancelAsyncCall(@ptrCast(*const IWbemServices, self), pSink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_QueryObjectSink(self: *const T, lFlags: i32, ppResponseHandler: ?*?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).QueryObjectSink(@ptrCast(*const IWbemServices, self), lFlags, ppResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_GetObject(self: *const T, strObjectPath: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppObject: ?*?*IWbemClassObject, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).GetObject(@ptrCast(*const IWbemServices, self), strObjectPath, lFlags, pCtx, ppObject, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_GetObjectAsync(self: *const T, strObjectPath: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).GetObjectAsync(@ptrCast(*const IWbemServices, self), strObjectPath, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_PutClass(self: *const T, pObject: ?*IWbemClassObject, lFlags: i32, pCtx: ?*IWbemContext, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).PutClass(@ptrCast(*const IWbemServices, self), pObject, lFlags, pCtx, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_PutClassAsync(self: *const T, pObject: ?*IWbemClassObject, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).PutClassAsync(@ptrCast(*const IWbemServices, self), pObject, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_DeleteClass(self: *const T, strClass: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).DeleteClass(@ptrCast(*const IWbemServices, self), strClass, lFlags, pCtx, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_DeleteClassAsync(self: *const T, strClass: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).DeleteClassAsync(@ptrCast(*const IWbemServices, self), strClass, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_CreateClassEnum(self: *const T, strSuperclass: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppEnum: ?*?*IEnumWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).CreateClassEnum(@ptrCast(*const IWbemServices, self), strSuperclass, lFlags, pCtx, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_CreateClassEnumAsync(self: *const T, strSuperclass: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).CreateClassEnumAsync(@ptrCast(*const IWbemServices, self), strSuperclass, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_PutInstance(self: *const T, pInst: ?*IWbemClassObject, lFlags: i32, pCtx: ?*IWbemContext, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).PutInstance(@ptrCast(*const IWbemServices, self), pInst, lFlags, pCtx, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_PutInstanceAsync(self: *const T, pInst: ?*IWbemClassObject, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).PutInstanceAsync(@ptrCast(*const IWbemServices, self), pInst, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_DeleteInstance(self: *const T, strObjectPath: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).DeleteInstance(@ptrCast(*const IWbemServices, self), strObjectPath, lFlags, pCtx, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_DeleteInstanceAsync(self: *const T, strObjectPath: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).DeleteInstanceAsync(@ptrCast(*const IWbemServices, self), strObjectPath, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_CreateInstanceEnum(self: *const T, strFilter: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppEnum: ?*?*IEnumWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).CreateInstanceEnum(@ptrCast(*const IWbemServices, self), strFilter, lFlags, pCtx, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_CreateInstanceEnumAsync(self: *const T, strFilter: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).CreateInstanceEnumAsync(@ptrCast(*const IWbemServices, self), strFilter, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecQuery(self: *const T, strQueryLanguage: ?BSTR, strQuery: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppEnum: ?*?*IEnumWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecQuery(@ptrCast(*const IWbemServices, self), strQueryLanguage, strQuery, lFlags, pCtx, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecQueryAsync(self: *const T, strQueryLanguage: ?BSTR, strQuery: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecQueryAsync(@ptrCast(*const IWbemServices, self), strQueryLanguage, strQuery, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecNotificationQuery(self: *const T, strQueryLanguage: ?BSTR, strQuery: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, ppEnum: ?*?*IEnumWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecNotificationQuery(@ptrCast(*const IWbemServices, self), strQueryLanguage, strQuery, lFlags, pCtx, ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecNotificationQueryAsync(self: *const T, strQueryLanguage: ?BSTR, strQuery: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecNotificationQueryAsync(@ptrCast(*const IWbemServices, self), strQueryLanguage, strQuery, lFlags, pCtx, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecMethod(self: *const T, strObjectPath: ?BSTR, strMethodName: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pInParams: ?*IWbemClassObject, ppOutParams: ?*?*IWbemClassObject, ppCallResult: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecMethod(@ptrCast(*const IWbemServices, self), strObjectPath, strMethodName, lFlags, pCtx, pInParams, ppOutParams, ppCallResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemServices_ExecMethodAsync(self: *const T, strObjectPath: ?BSTR, strMethodName: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, pInParams: ?*IWbemClassObject, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemServices.VTable, self.vtable).ExecMethodAsync(@ptrCast(*const IWbemServices, self), strObjectPath, strMethodName, lFlags, pCtx, pInParams, pResponseHandler);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemLocator_Value = @import("../zig.zig").Guid.initString("dc12a687-737f-11cf-884d-00aa004b2e24");
pub const IID_IWbemLocator = &IID_IWbemLocator_Value;
pub const IWbemLocator = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ConnectServer: fn(
self: *const IWbemLocator,
strNetworkResource: ?BSTR,
strUser: ?BSTR,
strPassword: ?BSTR,
strLocale: ?BSTR,
lSecurityFlags: i32,
strAuthority: ?BSTR,
pCtx: ?*IWbemContext,
ppNamespace: ?*?*IWbemServices,
) 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 IWbemLocator_ConnectServer(self: *const T, strNetworkResource: ?BSTR, strUser: ?BSTR, strPassword: ?BSTR, strLocale: ?BSTR, lSecurityFlags: i32, strAuthority: ?BSTR, pCtx: ?*IWbemContext, ppNamespace: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemLocator.VTable, self.vtable).ConnectServer(@ptrCast(*const IWbemLocator, self), strNetworkResource, strUser, strPassword, strLocale, lSecurityFlags, strAuthority, pCtx, ppNamespace);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemObjectSink_Value = @import("../zig.zig").Guid.initString("7c857801-7381-11cf-884d-00aa004b2e24");
pub const IID_IWbemObjectSink = &IID_IWbemObjectSink_Value;
pub const IWbemObjectSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Indicate: fn(
self: *const IWbemObjectSink,
lObjectCount: i32,
apObjArray: [*]?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetStatus: fn(
self: *const IWbemObjectSink,
lFlags: i32,
hResult: HRESULT,
strParam: ?BSTR,
pObjParam: ?*IWbemClassObject,
) 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 IWbemObjectSink_Indicate(self: *const T, lObjectCount: i32, apObjArray: [*]?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSink.VTable, self.vtable).Indicate(@ptrCast(*const IWbemObjectSink, self), lObjectCount, apObjArray);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSink_SetStatus(self: *const T, lFlags: i32, hResult: HRESULT, strParam: ?BSTR, pObjParam: ?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSink.VTable, self.vtable).SetStatus(@ptrCast(*const IWbemObjectSink, self), lFlags, hResult, strParam, pObjParam);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IEnumWbemClassObject_Value = @import("../zig.zig").Guid.initString("027947e1-d731-11ce-a357-000000000001");
pub const IID_IEnumWbemClassObject = &IID_IEnumWbemClassObject_Value;
pub const IEnumWbemClassObject = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Reset: fn(
self: *const IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IEnumWbemClassObject,
lTimeout: i32,
uCount: u32,
apObjects: [*]?*IWbemClassObject,
puReturned: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NextAsync: fn(
self: *const IEnumWbemClassObject,
uCount: u32,
pSink: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const IEnumWbemClassObject,
ppEnum: ?*?*IEnumWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Skip: fn(
self: *const IEnumWbemClassObject,
lTimeout: i32,
nCount: 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 IEnumWbemClassObject_Reset(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumWbemClassObject.VTable, self.vtable).Reset(@ptrCast(*const IEnumWbemClassObject, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumWbemClassObject_Next(self: *const T, lTimeout: i32, uCount: u32, apObjects: [*]?*IWbemClassObject, puReturned: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumWbemClassObject.VTable, self.vtable).Next(@ptrCast(*const IEnumWbemClassObject, self), lTimeout, uCount, apObjects, puReturned);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumWbemClassObject_NextAsync(self: *const T, uCount: u32, pSink: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumWbemClassObject.VTable, self.vtable).NextAsync(@ptrCast(*const IEnumWbemClassObject, self), uCount, pSink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumWbemClassObject_Clone(self: *const T, ppEnum: ?*?*IEnumWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumWbemClassObject.VTable, self.vtable).Clone(@ptrCast(*const IEnumWbemClassObject, self), ppEnum);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IEnumWbemClassObject_Skip(self: *const T, lTimeout: i32, nCount: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IEnumWbemClassObject.VTable, self.vtable).Skip(@ptrCast(*const IEnumWbemClassObject, self), lTimeout, nCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemCallResult_Value = @import("../zig.zig").Guid.initString("44aca675-e8fc-11d0-a07c-00c04fb68820");
pub const IID_IWbemCallResult = &IID_IWbemCallResult_Value;
pub const IWbemCallResult = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetResultObject: fn(
self: *const IWbemCallResult,
lTimeout: i32,
ppResultObject: ?*?*IWbemClassObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetResultString: fn(
self: *const IWbemCallResult,
lTimeout: i32,
pstrResultString: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetResultServices: fn(
self: *const IWbemCallResult,
lTimeout: i32,
ppServices: ?*?*IWbemServices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetCallStatus: fn(
self: *const IWbemCallResult,
lTimeout: i32,
plStatus: ?*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 IWbemCallResult_GetResultObject(self: *const T, lTimeout: i32, ppResultObject: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemCallResult.VTable, self.vtable).GetResultObject(@ptrCast(*const IWbemCallResult, self), lTimeout, ppResultObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemCallResult_GetResultString(self: *const T, lTimeout: i32, pstrResultString: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemCallResult.VTable, self.vtable).GetResultString(@ptrCast(*const IWbemCallResult, self), lTimeout, pstrResultString);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemCallResult_GetResultServices(self: *const T, lTimeout: i32, ppServices: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemCallResult.VTable, self.vtable).GetResultServices(@ptrCast(*const IWbemCallResult, self), lTimeout, ppServices);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemCallResult_GetCallStatus(self: *const T, lTimeout: i32, plStatus: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemCallResult.VTable, self.vtable).GetCallStatus(@ptrCast(*const IWbemCallResult, self), lTimeout, plStatus);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemContext_Value = @import("../zig.zig").Guid.initString("44aca674-e8fc-11d0-a07c-00c04fb68820");
pub const IID_IWbemContext = &IID_IWbemContext_Value;
pub const IWbemContext = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Clone: fn(
self: *const IWbemContext,
ppNewCopy: ?*?*IWbemContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetNames: fn(
self: *const IWbemContext,
lFlags: i32,
pNames: ?*?*SAFEARRAY,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
BeginEnumeration: fn(
self: *const IWbemContext,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Next: fn(
self: *const IWbemContext,
lFlags: i32,
pstrName: ?*?BSTR,
pValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
EndEnumeration: fn(
self: *const IWbemContext,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetValue: fn(
self: *const IWbemContext,
wszName: ?[*:0]const u16,
lFlags: i32,
pValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetValue: fn(
self: *const IWbemContext,
wszName: ?[*:0]const u16,
lFlags: i32,
pValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteValue: fn(
self: *const IWbemContext,
wszName: ?[*:0]const u16,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAll: fn(
self: *const IWbemContext,
) 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 IWbemContext_Clone(self: *const T, ppNewCopy: ?*?*IWbemContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).Clone(@ptrCast(*const IWbemContext, self), ppNewCopy);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_GetNames(self: *const T, lFlags: i32, pNames: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).GetNames(@ptrCast(*const IWbemContext, self), lFlags, pNames);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_BeginEnumeration(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).BeginEnumeration(@ptrCast(*const IWbemContext, self), lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_Next(self: *const T, lFlags: i32, pstrName: ?*?BSTR, pValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).Next(@ptrCast(*const IWbemContext, self), lFlags, pstrName, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_EndEnumeration(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).EndEnumeration(@ptrCast(*const IWbemContext, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_SetValue(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).SetValue(@ptrCast(*const IWbemContext, self), wszName, lFlags, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_GetValue(self: *const T, wszName: ?[*:0]const u16, lFlags: i32, pValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).GetValue(@ptrCast(*const IWbemContext, self), wszName, lFlags, pValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_DeleteValue(self: *const T, wszName: ?[*:0]const u16, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).DeleteValue(@ptrCast(*const IWbemContext, self), wszName, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemContext_DeleteAll(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemContext.VTable, self.vtable).DeleteAll(@ptrCast(*const IWbemContext, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IUnsecuredApartment_Value = @import("../zig.zig").Guid.initString("1cfaba8c-1523-11d1-ad79-00c04fd8fdff");
pub const IID_IUnsecuredApartment = &IID_IUnsecuredApartment_Value;
pub const IUnsecuredApartment = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreateObjectStub: fn(
self: *const IUnsecuredApartment,
pObject: ?*IUnknown,
ppStub: ?*?*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 IUnsecuredApartment_CreateObjectStub(self: *const T, pObject: ?*IUnknown, ppStub: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IUnsecuredApartment.VTable, self.vtable).CreateObjectStub(@ptrCast(*const IUnsecuredApartment, self), pObject, ppStub);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windowsServer2008'
const IID_IWbemUnsecuredApartment_Value = @import("../zig.zig").Guid.initString("31739d04-3471-4cf4-9a7c-57a44ae71956");
pub const IID_IWbemUnsecuredApartment = &IID_IWbemUnsecuredApartment_Value;
pub const IWbemUnsecuredApartment = extern struct {
pub const VTable = extern struct {
base: IUnsecuredApartment.VTable,
CreateSinkStub: fn(
self: *const IWbemUnsecuredApartment,
pSink: ?*IWbemObjectSink,
dwFlags: u32,
wszReserved: ?[*:0]const u16,
ppStub: ?*?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnsecuredApartment.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemUnsecuredApartment_CreateSinkStub(self: *const T, pSink: ?*IWbemObjectSink, dwFlags: u32, wszReserved: ?[*:0]const u16, ppStub: ?*?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemUnsecuredApartment.VTable, self.vtable).CreateSinkStub(@ptrCast(*const IWbemUnsecuredApartment, self), pSink, dwFlags, wszReserved, ppStub);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemStatusCodeText_Value = @import("../zig.zig").Guid.initString("eb87e1bc-3233-11d2-aec9-00c04fb68820");
pub const IID_IWbemStatusCodeText = &IID_IWbemStatusCodeText_Value;
pub const IWbemStatusCodeText = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetErrorCodeText: fn(
self: *const IWbemStatusCodeText,
hRes: HRESULT,
LocaleId: u32,
lFlags: i32,
MessageText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFacilityCodeText: fn(
self: *const IWbemStatusCodeText,
hRes: HRESULT,
LocaleId: u32,
lFlags: i32,
MessageText: ?*?BSTR,
) 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 IWbemStatusCodeText_GetErrorCodeText(self: *const T, hRes: HRESULT, LocaleId: u32, lFlags: i32, MessageText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemStatusCodeText.VTable, self.vtable).GetErrorCodeText(@ptrCast(*const IWbemStatusCodeText, self), hRes, LocaleId, lFlags, MessageText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemStatusCodeText_GetFacilityCodeText(self: *const T, hRes: HRESULT, LocaleId: u32, lFlags: i32, MessageText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemStatusCodeText.VTable, self.vtable).GetFacilityCodeText(@ptrCast(*const IWbemStatusCodeText, self), hRes, LocaleId, lFlags, MessageText);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemBackupRestore_Value = @import("../zig.zig").Guid.initString("c49e32c7-bc8b-11d2-85d4-00105a1f8304");
pub const IID_IWbemBackupRestore = &IID_IWbemBackupRestore_Value;
pub const IWbemBackupRestore = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Backup: fn(
self: *const IWbemBackupRestore,
strBackupToFile: ?[*:0]const u16,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Restore: fn(
self: *const IWbemBackupRestore,
strRestoreFromFile: ?[*:0]const u16,
lFlags: 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 IWbemBackupRestore_Backup(self: *const T, strBackupToFile: ?[*:0]const u16, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemBackupRestore.VTable, self.vtable).Backup(@ptrCast(*const IWbemBackupRestore, self), strBackupToFile, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemBackupRestore_Restore(self: *const T, strRestoreFromFile: ?[*:0]const u16, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemBackupRestore.VTable, self.vtable).Restore(@ptrCast(*const IWbemBackupRestore, self), strRestoreFromFile, lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemBackupRestoreEx_Value = @import("../zig.zig").Guid.initString("a359dec5-e813-4834-8a2a-ba7f1d777d76");
pub const IID_IWbemBackupRestoreEx = &IID_IWbemBackupRestoreEx_Value;
pub const IWbemBackupRestoreEx = extern struct {
pub const VTable = extern struct {
base: IWbemBackupRestore.VTable,
Pause: fn(
self: *const IWbemBackupRestoreEx,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Resume: fn(
self: *const IWbemBackupRestoreEx,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWbemBackupRestore.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemBackupRestoreEx_Pause(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemBackupRestoreEx.VTable, self.vtable).Pause(@ptrCast(*const IWbemBackupRestoreEx, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemBackupRestoreEx_Resume(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemBackupRestoreEx.VTable, self.vtable).Resume(@ptrCast(*const IWbemBackupRestoreEx, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemRefresher_Value = @import("../zig.zig").Guid.initString("49353c99-516b-11d1-aea6-00c04fb68820");
pub const IID_IWbemRefresher = &IID_IWbemRefresher_Value;
pub const IWbemRefresher = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Refresh: fn(
self: *const IWbemRefresher,
lFlags: 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 IWbemRefresher_Refresh(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemRefresher.VTable, self.vtable).Refresh(@ptrCast(*const IWbemRefresher, self), lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemHiPerfEnum_Value = @import("../zig.zig").Guid.initString("2705c288-79ae-11d2-b348-00105a1f8177");
pub const IID_IWbemHiPerfEnum = &IID_IWbemHiPerfEnum_Value;
pub const IWbemHiPerfEnum = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddObjects: fn(
self: *const IWbemHiPerfEnum,
lFlags: i32,
uNumObjects: u32,
apIds: [*]i32,
apObj: [*]?*IWbemObjectAccess,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveObjects: fn(
self: *const IWbemHiPerfEnum,
lFlags: i32,
uNumObjects: u32,
apIds: [*]i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjects: fn(
self: *const IWbemHiPerfEnum,
lFlags: i32,
uNumObjects: u32,
apObj: [*]?*IWbemObjectAccess,
puReturned: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RemoveAll: fn(
self: *const IWbemHiPerfEnum,
lFlags: 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 IWbemHiPerfEnum_AddObjects(self: *const T, lFlags: i32, uNumObjects: u32, apIds: [*]i32, apObj: [*]?*IWbemObjectAccess) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfEnum.VTable, self.vtable).AddObjects(@ptrCast(*const IWbemHiPerfEnum, self), lFlags, uNumObjects, apIds, apObj);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfEnum_RemoveObjects(self: *const T, lFlags: i32, uNumObjects: u32, apIds: [*]i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfEnum.VTable, self.vtable).RemoveObjects(@ptrCast(*const IWbemHiPerfEnum, self), lFlags, uNumObjects, apIds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfEnum_GetObjects(self: *const T, lFlags: i32, uNumObjects: u32, apObj: [*]?*IWbemObjectAccess, puReturned: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfEnum.VTable, self.vtable).GetObjects(@ptrCast(*const IWbemHiPerfEnum, self), lFlags, uNumObjects, apObj, puReturned);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfEnum_RemoveAll(self: *const T, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfEnum.VTable, self.vtable).RemoveAll(@ptrCast(*const IWbemHiPerfEnum, self), lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemConfigureRefresher_Value = @import("../zig.zig").Guid.initString("49353c92-516b-11d1-aea6-00c04fb68820");
pub const IID_IWbemConfigureRefresher = &IID_IWbemConfigureRefresher_Value;
pub const IWbemConfigureRefresher = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AddObjectByPath: fn(
self: *const IWbemConfigureRefresher,
pNamespace: ?*IWbemServices,
wszPath: ?[*:0]const u16,
lFlags: i32,
pContext: ?*IWbemContext,
ppRefreshable: ?*?*IWbemClassObject,
plId: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddObjectByTemplate: fn(
self: *const IWbemConfigureRefresher,
pNamespace: ?*IWbemServices,
pTemplate: ?*IWbemClassObject,
lFlags: i32,
pContext: ?*IWbemContext,
ppRefreshable: ?*?*IWbemClassObject,
plId: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddRefresher: fn(
self: *const IWbemConfigureRefresher,
pRefresher: ?*IWbemRefresher,
lFlags: i32,
plId: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const IWbemConfigureRefresher,
lId: i32,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddEnum: fn(
self: *const IWbemConfigureRefresher,
pNamespace: ?*IWbemServices,
wszClassName: ?[*:0]const u16,
lFlags: i32,
pContext: ?*IWbemContext,
ppEnum: ?*?*IWbemHiPerfEnum,
plId: ?*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 IWbemConfigureRefresher_AddObjectByPath(self: *const T, pNamespace: ?*IWbemServices, wszPath: ?[*:0]const u16, lFlags: i32, pContext: ?*IWbemContext, ppRefreshable: ?*?*IWbemClassObject, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConfigureRefresher.VTable, self.vtable).AddObjectByPath(@ptrCast(*const IWbemConfigureRefresher, self), pNamespace, wszPath, lFlags, pContext, ppRefreshable, plId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConfigureRefresher_AddObjectByTemplate(self: *const T, pNamespace: ?*IWbemServices, pTemplate: ?*IWbemClassObject, lFlags: i32, pContext: ?*IWbemContext, ppRefreshable: ?*?*IWbemClassObject, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConfigureRefresher.VTable, self.vtable).AddObjectByTemplate(@ptrCast(*const IWbemConfigureRefresher, self), pNamespace, pTemplate, lFlags, pContext, ppRefreshable, plId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConfigureRefresher_AddRefresher(self: *const T, pRefresher: ?*IWbemRefresher, lFlags: i32, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConfigureRefresher.VTable, self.vtable).AddRefresher(@ptrCast(*const IWbemConfigureRefresher, self), pRefresher, lFlags, plId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConfigureRefresher_Remove(self: *const T, lId: i32, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConfigureRefresher.VTable, self.vtable).Remove(@ptrCast(*const IWbemConfigureRefresher, self), lId, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConfigureRefresher_AddEnum(self: *const T, pNamespace: ?*IWbemServices, wszClassName: ?[*:0]const u16, lFlags: i32, pContext: ?*IWbemContext, ppEnum: ?*?*IWbemHiPerfEnum, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConfigureRefresher.VTable, self.vtable).AddEnum(@ptrCast(*const IWbemConfigureRefresher, self), pNamespace, wszClassName, lFlags, pContext, ppEnum, plId);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemObjectSinkEx_Value = @import("../zig.zig").Guid.initString("e7d35cfa-348b-485e-b524-252725d697ca");
pub const IID_IWbemObjectSinkEx = &IID_IWbemObjectSinkEx_Value;
pub const IWbemObjectSinkEx = extern struct {
pub const VTable = extern struct {
base: IWbemObjectSink.VTable,
WriteMessage: fn(
self: *const IWbemObjectSinkEx,
uChannel: u32,
strMessage: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteError: fn(
self: *const IWbemObjectSinkEx,
pObjError: ?*IWbemClassObject,
puReturned: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PromptUser: fn(
self: *const IWbemObjectSinkEx,
strMessage: ?BSTR,
uPromptType: u8,
puReturned: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteProgress: fn(
self: *const IWbemObjectSinkEx,
strActivity: ?BSTR,
strCurrentOperation: ?BSTR,
strStatusDescription: ?BSTR,
uPercentComplete: u32,
uSecondsRemaining: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WriteStreamParameter: fn(
self: *const IWbemObjectSinkEx,
strName: ?BSTR,
vtValue: ?*VARIANT,
ulType: u32,
ulFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWbemObjectSink.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSinkEx_WriteMessage(self: *const T, uChannel: u32, strMessage: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSinkEx.VTable, self.vtable).WriteMessage(@ptrCast(*const IWbemObjectSinkEx, self), uChannel, strMessage);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSinkEx_WriteError(self: *const T, pObjError: ?*IWbemClassObject, puReturned: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSinkEx.VTable, self.vtable).WriteError(@ptrCast(*const IWbemObjectSinkEx, self), pObjError, puReturned);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSinkEx_PromptUser(self: *const T, strMessage: ?BSTR, uPromptType: u8, puReturned: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSinkEx.VTable, self.vtable).PromptUser(@ptrCast(*const IWbemObjectSinkEx, self), strMessage, uPromptType, puReturned);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSinkEx_WriteProgress(self: *const T, strActivity: ?BSTR, strCurrentOperation: ?BSTR, strStatusDescription: ?BSTR, uPercentComplete: u32, uSecondsRemaining: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSinkEx.VTable, self.vtable).WriteProgress(@ptrCast(*const IWbemObjectSinkEx, self), strActivity, strCurrentOperation, strStatusDescription, uPercentComplete, uSecondsRemaining);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectSinkEx_WriteStreamParameter(self: *const T, strName: ?BSTR, vtValue: ?*VARIANT, ulType: u32, ulFlags: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectSinkEx.VTable, self.vtable).WriteStreamParameter(@ptrCast(*const IWbemObjectSinkEx, self), strName, vtValue, ulType, ulFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemShutdown_Value = @import("../zig.zig").Guid.initString("b7b31df9-d515-11d3-a11c-00105a1f515a");
pub const IID_IWbemShutdown = &IID_IWbemShutdown_Value;
pub const IWbemShutdown = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Shutdown: fn(
self: *const IWbemShutdown,
uReason: i32,
uMaxMilliseconds: u32,
pCtx: ?*IWbemContext,
) 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 IWbemShutdown_Shutdown(self: *const T, uReason: i32, uMaxMilliseconds: u32, pCtx: ?*IWbemContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemShutdown.VTable, self.vtable).Shutdown(@ptrCast(*const IWbemShutdown, self), uReason, uMaxMilliseconds, pCtx);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WMI_OBJ_TEXT = enum(i32) {
CIM_DTD_2_0 = 1,
WMI_DTD_2_0 = 2,
WMI_EXT1 = 3,
WMI_EXT2 = 4,
WMI_EXT3 = 5,
WMI_EXT4 = 6,
WMI_EXT5 = 7,
WMI_EXT6 = 8,
WMI_EXT7 = 9,
WMI_EXT8 = 10,
WMI_EXT9 = 11,
WMI_EXT10 = 12,
LAST = 13,
};
pub const WMI_OBJ_TEXT_CIM_DTD_2_0 = WMI_OBJ_TEXT.CIM_DTD_2_0;
pub const WMI_OBJ_TEXT_WMI_DTD_2_0 = WMI_OBJ_TEXT.WMI_DTD_2_0;
pub const WMI_OBJ_TEXT_WMI_EXT1 = WMI_OBJ_TEXT.WMI_EXT1;
pub const WMI_OBJ_TEXT_WMI_EXT2 = WMI_OBJ_TEXT.WMI_EXT2;
pub const WMI_OBJ_TEXT_WMI_EXT3 = WMI_OBJ_TEXT.WMI_EXT3;
pub const WMI_OBJ_TEXT_WMI_EXT4 = WMI_OBJ_TEXT.WMI_EXT4;
pub const WMI_OBJ_TEXT_WMI_EXT5 = WMI_OBJ_TEXT.WMI_EXT5;
pub const WMI_OBJ_TEXT_WMI_EXT6 = WMI_OBJ_TEXT.WMI_EXT6;
pub const WMI_OBJ_TEXT_WMI_EXT7 = WMI_OBJ_TEXT.WMI_EXT7;
pub const WMI_OBJ_TEXT_WMI_EXT8 = WMI_OBJ_TEXT.WMI_EXT8;
pub const WMI_OBJ_TEXT_WMI_EXT9 = WMI_OBJ_TEXT.WMI_EXT9;
pub const WMI_OBJ_TEXT_WMI_EXT10 = WMI_OBJ_TEXT.WMI_EXT10;
pub const WMI_OBJ_TEXT_LAST = WMI_OBJ_TEXT.LAST;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemObjectTextSrc_Value = @import("../zig.zig").Guid.initString("bfbf883a-cad7-11d3-a11b-00105a1f515a");
pub const IID_IWbemObjectTextSrc = &IID_IWbemObjectTextSrc_Value;
pub const IWbemObjectTextSrc = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetText: fn(
self: *const IWbemObjectTextSrc,
lFlags: i32,
pObj: ?*IWbemClassObject,
uObjTextFormat: u32,
pCtx: ?*IWbemContext,
strText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateFromText: fn(
self: *const IWbemObjectTextSrc,
lFlags: i32,
strText: ?BSTR,
uObjTextFormat: u32,
pCtx: ?*IWbemContext,
pNewObj: ?*?*IWbemClassObject,
) 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 IWbemObjectTextSrc_GetText(self: *const T, lFlags: i32, pObj: ?*IWbemClassObject, uObjTextFormat: u32, pCtx: ?*IWbemContext, strText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectTextSrc.VTable, self.vtable).GetText(@ptrCast(*const IWbemObjectTextSrc, self), lFlags, pObj, uObjTextFormat, pCtx, strText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemObjectTextSrc_CreateFromText(self: *const T, lFlags: i32, strText: ?BSTR, uObjTextFormat: u32, pCtx: ?*IWbemContext, pNewObj: ?*?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemObjectTextSrc.VTable, self.vtable).CreateFromText(@ptrCast(*const IWbemObjectTextSrc, self), lFlags, strText, uObjTextFormat, pCtx, pNewObj);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WBEM_COMPILE_STATUS_INFO = extern struct {
lPhaseError: i32,
hRes: HRESULT,
ObjectNum: i32,
FirstLine: i32,
LastLine: i32,
dwOutFlags: u32,
};
pub const WBEM_COMPILER_OPTIONS = enum(i32) {
CHECK_ONLY = 1,
AUTORECOVER = 2,
WMI_CHECK = 4,
CONSOLE_PRINT = 8,
DONT_ADD_TO_LIST = 16,
SPLIT_FILES = 32,
STORE_FILE = 256,
};
pub const WBEM_FLAG_CHECK_ONLY = WBEM_COMPILER_OPTIONS.CHECK_ONLY;
pub const WBEM_FLAG_AUTORECOVER = WBEM_COMPILER_OPTIONS.AUTORECOVER;
pub const WBEM_FLAG_WMI_CHECK = WBEM_COMPILER_OPTIONS.WMI_CHECK;
pub const WBEM_FLAG_CONSOLE_PRINT = WBEM_COMPILER_OPTIONS.CONSOLE_PRINT;
pub const WBEM_FLAG_DONT_ADD_TO_LIST = WBEM_COMPILER_OPTIONS.DONT_ADD_TO_LIST;
pub const WBEM_FLAG_SPLIT_FILES = WBEM_COMPILER_OPTIONS.SPLIT_FILES;
pub const WBEM_FLAG_STORE_FILE = WBEM_COMPILER_OPTIONS.STORE_FILE;
pub const WBEM_CONNECT_OPTIONS = enum(i32) {
REPOSITORY_ONLY = 64,
USE_MAX_WAIT = 128,
PROVIDERS = 256,
};
pub const WBEM_FLAG_CONNECT_REPOSITORY_ONLY = WBEM_CONNECT_OPTIONS.REPOSITORY_ONLY;
pub const WBEM_FLAG_CONNECT_USE_MAX_WAIT = WBEM_CONNECT_OPTIONS.USE_MAX_WAIT;
pub const WBEM_FLAG_CONNECT_PROVIDERS = WBEM_CONNECT_OPTIONS.PROVIDERS;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IMofCompiler_Value = @import("../zig.zig").Guid.initString("6daf974e-2e37-11d2-aec9-00c04fb68820");
pub const IID_IMofCompiler = &IID_IMofCompiler_Value;
pub const IMofCompiler = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CompileFile: fn(
self: *const IMofCompiler,
FileName: ?PWSTR,
ServerAndNamespace: ?PWSTR,
User: ?PWSTR,
Authority: ?PWSTR,
Password: <PASSWORD>,
lOptionFlags: i32,
lClassFlags: i32,
lInstanceFlags: i32,
pInfo: ?*WBEM_COMPILE_STATUS_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CompileBuffer: fn(
self: *const IMofCompiler,
BuffSize: i32,
// TODO: what to do with BytesParamIndex 0?
pBuffer: ?*u8,
ServerAndNamespace: ?PWSTR,
User: ?PWSTR,
Authority: ?PWSTR,
Password: ?<PASSWORD>,
lOptionFlags: i32,
lClassFlags: i32,
lInstanceFlags: i32,
pInfo: ?*WBEM_COMPILE_STATUS_INFO,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateBMOF: fn(
self: *const IMofCompiler,
TextFileName: ?PWSTR,
BMOFFileName: ?PWSTR,
ServerAndNamespace: ?PWSTR,
lOptionFlags: i32,
lClassFlags: i32,
lInstanceFlags: i32,
pInfo: ?*WBEM_COMPILE_STATUS_INFO,
) 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 IMofCompiler_CompileFile(self: *const T, FileName: ?PWSTR, ServerAndNamespace: ?PWSTR, User: ?PWSTR, Authority: ?PWSTR, Password: ?<PASSWORD>, lOptionFlags: i32, lClassFlags: i32, lInstanceFlags: i32, pInfo: ?*WBEM_COMPILE_STATUS_INFO) callconv(.Inline) HRESULT {
return @ptrCast(*const IMofCompiler.VTable, self.vtable).CompileFile(@ptrCast(*const IMofCompiler, self), FileName, ServerAndNamespace, User, Authority, Password, lOptionFlags, lClassFlags, lInstanceFlags, pInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMofCompiler_CompileBuffer(self: *const T, BuffSize: i32, pBuffer: ?*u8, ServerAndNamespace: ?PWSTR, User: ?PWSTR, Authority: ?PWSTR, Password: ?<PASSWORD>, lOptionFlags: i32, lClassFlags: i32, lInstanceFlags: i32, pInfo: ?*WBEM_COMPILE_STATUS_INFO) callconv(.Inline) HRESULT {
return @ptrCast(*const IMofCompiler.VTable, self.vtable).CompileBuffer(@ptrCast(*const IMofCompiler, self), BuffSize, pBuffer, ServerAndNamespace, User, Authority, Password, lOptionFlags, lClassFlags, lInstanceFlags, pInfo);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IMofCompiler_CreateBMOF(self: *const T, TextFileName: ?PWSTR, BMOFFileName: ?PWSTR, ServerAndNamespace: ?PWSTR, lOptionFlags: i32, lClassFlags: i32, lInstanceFlags: i32, pInfo: ?*WBEM_COMPILE_STATUS_INFO) callconv(.Inline) HRESULT {
return @ptrCast(*const IMofCompiler.VTable, self.vtable).CreateBMOF(@ptrCast(*const IMofCompiler, self), TextFileName, BMOFFileName, ServerAndNamespace, lOptionFlags, lClassFlags, lInstanceFlags, pInfo);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WBEM_UNSECAPP_FLAG_TYPE = enum(i32) {
DEFAULT_CHECK_ACCESS = 0,
CHECK_ACCESS = 1,
DONT_CHECK_ACCESS = 2,
};
pub const WBEM_FLAG_UNSECAPP_DEFAULT_CHECK_ACCESS = WBEM_UNSECAPP_FLAG_TYPE.DEFAULT_CHECK_ACCESS;
pub const WBEM_FLAG_UNSECAPP_CHECK_ACCESS = WBEM_UNSECAPP_FLAG_TYPE.CHECK_ACCESS;
pub const WBEM_FLAG_UNSECAPP_DONT_CHECK_ACCESS = WBEM_UNSECAPP_FLAG_TYPE.DONT_CHECK_ACCESS;
pub const WBEM_INFORMATION_FLAG_TYPE = enum(i32) {
SHORT_NAME = 1,
LONG_NAME = 2,
};
pub const WBEM_FLAG_SHORT_NAME = WBEM_INFORMATION_FLAG_TYPE.SHORT_NAME;
pub const WBEM_FLAG_LONG_NAME = WBEM_INFORMATION_FLAG_TYPE.LONG_NAME;
const CLSID_WbemAdministrativeLocator_Value = @import("../zig.zig").Guid.initString("cb8555cc-9128-11d1-ad9b-00c04fd8fdff");
pub const CLSID_WbemAdministrativeLocator = &CLSID_WbemAdministrativeLocator_Value;
const CLSID_WbemAuthenticatedLocator_Value = @import("../zig.zig").Guid.initString("cd184336-9128-11d1-ad9b-00c04fd8fdff");
pub const CLSID_WbemAuthenticatedLocator = &CLSID_WbemAuthenticatedLocator_Value;
const CLSID_WbemUnauthenticatedLocator_Value = @import("../zig.zig").Guid.initString("443e7b79-de31-11d2-b340-00104bcc4b4a");
pub const CLSID_WbemUnauthenticatedLocator = &CLSID_WbemUnauthenticatedLocator_Value;
const CLSID_WbemDecoupledRegistrar_Value = @import("../zig.zig").Guid.initString("4cfc7932-0f9d-4bef-9c32-8ea2a6b56fcb");
pub const CLSID_WbemDecoupledRegistrar = &CLSID_WbemDecoupledRegistrar_Value;
const CLSID_WbemDecoupledBasicEventProvider_Value = @import("../zig.zig").Guid.initString("f5f75737-2843-4f22-933d-c76a97cda62f");
pub const CLSID_WbemDecoupledBasicEventProvider = &CLSID_WbemDecoupledBasicEventProvider_Value;
pub const WBEM_PROVIDER_REQUIREMENTS_TYPE = enum(i32) {
START_POSTFILTER = 0,
STOP_POSTFILTER = 1,
RECHECK_SUBSCRIPTIONS = 2,
};
pub const WBEM_REQUIREMENTS_START_POSTFILTER = WBEM_PROVIDER_REQUIREMENTS_TYPE.START_POSTFILTER;
pub const WBEM_REQUIREMENTS_STOP_POSTFILTER = WBEM_PROVIDER_REQUIREMENTS_TYPE.STOP_POSTFILTER;
pub const WBEM_REQUIREMENTS_RECHECK_SUBSCRIPTIONS = WBEM_PROVIDER_REQUIREMENTS_TYPE.RECHECK_SUBSCRIPTIONS;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemPropertyProvider_Value = @import("../zig.zig").Guid.initString("ce61e841-65bc-11d0-b6bd-00aa003240c7");
pub const IID_IWbemPropertyProvider = &IID_IWbemPropertyProvider_Value;
pub const IWbemPropertyProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetProperty: fn(
self: *const IWbemPropertyProvider,
lFlags: i32,
strLocale: ?BSTR,
strClassMapping: ?BSTR,
strInstMapping: ?BSTR,
strPropMapping: ?BSTR,
pvValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutProperty: fn(
self: *const IWbemPropertyProvider,
lFlags: i32,
strLocale: ?BSTR,
strClassMapping: ?BSTR,
strInstMapping: ?BSTR,
strPropMapping: ?BSTR,
pvValue: ?*const VARIANT,
) 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 IWbemPropertyProvider_GetProperty(self: *const T, lFlags: i32, strLocale: ?BSTR, strClassMapping: ?BSTR, strInstMapping: ?BSTR, strPropMapping: ?BSTR, pvValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPropertyProvider.VTable, self.vtable).GetProperty(@ptrCast(*const IWbemPropertyProvider, self), lFlags, strLocale, strClassMapping, strInstMapping, strPropMapping, pvValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemPropertyProvider_PutProperty(self: *const T, lFlags: i32, strLocale: ?BSTR, strClassMapping: ?BSTR, strInstMapping: ?BSTR, strPropMapping: ?BSTR, pvValue: ?*const VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemPropertyProvider.VTable, self.vtable).PutProperty(@ptrCast(*const IWbemPropertyProvider, self), lFlags, strLocale, strClassMapping, strInstMapping, strPropMapping, pvValue);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemUnboundObjectSink_Value = @import("../zig.zig").Guid.initString("e246107b-b06e-11d0-ad61-00c04fd8fdff");
pub const IID_IWbemUnboundObjectSink = &IID_IWbemUnboundObjectSink_Value;
pub const IWbemUnboundObjectSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
IndicateToConsumer: fn(
self: *const IWbemUnboundObjectSink,
pLogicalConsumer: ?*IWbemClassObject,
lNumObjects: i32,
apObjects: [*]?*IWbemClassObject,
) 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 IWbemUnboundObjectSink_IndicateToConsumer(self: *const T, pLogicalConsumer: ?*IWbemClassObject, lNumObjects: i32, apObjects: [*]?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemUnboundObjectSink.VTable, self.vtable).IndicateToConsumer(@ptrCast(*const IWbemUnboundObjectSink, self), pLogicalConsumer, lNumObjects, apObjects);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemEventProvider_Value = @import("../zig.zig").Guid.initString("e245105b-b06e-11d0-ad61-00c04fd8fdff");
pub const IID_IWbemEventProvider = &IID_IWbemEventProvider_Value;
pub const IWbemEventProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ProvideEvents: fn(
self: *const IWbemEventProvider,
pSink: ?*IWbemObjectSink,
lFlags: 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 IWbemEventProvider_ProvideEvents(self: *const T, pSink: ?*IWbemObjectSink, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventProvider.VTable, self.vtable).ProvideEvents(@ptrCast(*const IWbemEventProvider, self), pSink, lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemEventProviderQuerySink_Value = @import("../zig.zig").Guid.initString("580acaf8-fa1c-11d0-ad72-00c04fd8fdff");
pub const IID_IWbemEventProviderQuerySink = &IID_IWbemEventProviderQuerySink_Value;
pub const IWbemEventProviderQuerySink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
NewQuery: fn(
self: *const IWbemEventProviderQuerySink,
dwId: u32,
wszQueryLanguage: ?*u16,
wszQuery: ?*u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CancelQuery: fn(
self: *const IWbemEventProviderQuerySink,
dwId: 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 IWbemEventProviderQuerySink_NewQuery(self: *const T, dwId: u32, wszQueryLanguage: ?*u16, wszQuery: ?*u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventProviderQuerySink.VTable, self.vtable).NewQuery(@ptrCast(*const IWbemEventProviderQuerySink, self), dwId, wszQueryLanguage, wszQuery);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemEventProviderQuerySink_CancelQuery(self: *const T, dwId: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventProviderQuerySink.VTable, self.vtable).CancelQuery(@ptrCast(*const IWbemEventProviderQuerySink, self), dwId);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemEventProviderSecurity_Value = @import("../zig.zig").Guid.initString("631f7d96-d993-11d2-b339-00105a1f4aaf");
pub const IID_IWbemEventProviderSecurity = &IID_IWbemEventProviderSecurity_Value;
pub const IWbemEventProviderSecurity = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
AccessCheck: fn(
self: *const IWbemEventProviderSecurity,
wszQueryLanguage: ?*u16,
wszQuery: ?*u16,
lSidLength: i32,
pSid: [*:0]const 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 IWbemEventProviderSecurity_AccessCheck(self: *const T, wszQueryLanguage: ?*u16, wszQuery: ?*u16, lSidLength: i32, pSid: [*:0]const u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventProviderSecurity.VTable, self.vtable).AccessCheck(@ptrCast(*const IWbemEventProviderSecurity, self), wszQueryLanguage, wszQuery, lSidLength, pSid);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemEventConsumerProvider_Value = @import("../zig.zig").Guid.initString("e246107a-b06e-11d0-ad61-00c04fd8fdff");
pub const IID_IWbemEventConsumerProvider = &IID_IWbemEventConsumerProvider_Value;
pub const IWbemEventConsumerProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
FindConsumer: fn(
self: *const IWbemEventConsumerProvider,
pLogicalConsumer: ?*IWbemClassObject,
ppConsumer: ?*?*IWbemUnboundObjectSink,
) 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 IWbemEventConsumerProvider_FindConsumer(self: *const T, pLogicalConsumer: ?*IWbemClassObject, ppConsumer: ?*?*IWbemUnboundObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventConsumerProvider.VTable, self.vtable).FindConsumer(@ptrCast(*const IWbemEventConsumerProvider, self), pLogicalConsumer, ppConsumer);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemProviderInitSink_Value = @import("../zig.zig").Guid.initString("1be41571-91dd-11d1-aeb2-00c04fb68820");
pub const IID_IWbemProviderInitSink = &IID_IWbemProviderInitSink_Value;
pub const IWbemProviderInitSink = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetStatus: fn(
self: *const IWbemProviderInitSink,
lStatus: i32,
lFlags: 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 IWbemProviderInitSink_SetStatus(self: *const T, lStatus: i32, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemProviderInitSink.VTable, self.vtable).SetStatus(@ptrCast(*const IWbemProviderInitSink, self), lStatus, lFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemProviderInit_Value = @import("../zig.zig").Guid.initString("1be41572-91dd-11d1-aeb2-00c04fb68820");
pub const IID_IWbemProviderInit = &IID_IWbemProviderInit_Value;
pub const IWbemProviderInit = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const IWbemProviderInit,
wszUser: ?PWSTR,
lFlags: i32,
wszNamespace: ?PWSTR,
wszLocale: ?PWSTR,
pNamespace: ?*IWbemServices,
pCtx: ?*IWbemContext,
pInitSink: ?*IWbemProviderInitSink,
) 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 IWbemProviderInit_Initialize(self: *const T, wszUser: ?PWSTR, lFlags: i32, wszNamespace: ?PWSTR, wszLocale: ?PWSTR, pNamespace: ?*IWbemServices, pCtx: ?*IWbemContext, pInitSink: ?*IWbemProviderInitSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemProviderInit.VTable, self.vtable).Initialize(@ptrCast(*const IWbemProviderInit, self), wszUser, lFlags, wszNamespace, wszLocale, pNamespace, pCtx, pInitSink);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemHiPerfProvider_Value = @import("../zig.zig").Guid.initString("49353c93-516b-11d1-aea6-00c04fb68820");
pub const IID_IWbemHiPerfProvider = &IID_IWbemHiPerfProvider_Value;
pub const IWbemHiPerfProvider = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
QueryInstances: fn(
self: *const IWbemHiPerfProvider,
pNamespace: ?*IWbemServices,
wszClass: ?PWSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
pSink: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateRefresher: fn(
self: *const IWbemHiPerfProvider,
pNamespace: ?*IWbemServices,
lFlags: i32,
ppRefresher: ?*?*IWbemRefresher,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateRefreshableObject: fn(
self: *const IWbemHiPerfProvider,
pNamespace: ?*IWbemServices,
pTemplate: ?*IWbemObjectAccess,
pRefresher: ?*IWbemRefresher,
lFlags: i32,
pContext: ?*IWbemContext,
ppRefreshable: ?*?*IWbemObjectAccess,
plId: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
StopRefreshing: fn(
self: *const IWbemHiPerfProvider,
pRefresher: ?*IWbemRefresher,
lId: i32,
lFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CreateRefreshableEnum: fn(
self: *const IWbemHiPerfProvider,
pNamespace: ?*IWbemServices,
wszClass: ?[*:0]const u16,
pRefresher: ?*IWbemRefresher,
lFlags: i32,
pContext: ?*IWbemContext,
pHiPerfEnum: ?*IWbemHiPerfEnum,
plId: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjects: fn(
self: *const IWbemHiPerfProvider,
pNamespace: ?*IWbemServices,
lNumObjects: i32,
apObj: [*]?*IWbemObjectAccess,
lFlags: i32,
pContext: ?*IWbemContext,
) 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 IWbemHiPerfProvider_QueryInstances(self: *const T, pNamespace: ?*IWbemServices, wszClass: ?PWSTR, lFlags: i32, pCtx: ?*IWbemContext, pSink: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).QueryInstances(@ptrCast(*const IWbemHiPerfProvider, self), pNamespace, wszClass, lFlags, pCtx, pSink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfProvider_CreateRefresher(self: *const T, pNamespace: ?*IWbemServices, lFlags: i32, ppRefresher: ?*?*IWbemRefresher) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).CreateRefresher(@ptrCast(*const IWbemHiPerfProvider, self), pNamespace, lFlags, ppRefresher);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfProvider_CreateRefreshableObject(self: *const T, pNamespace: ?*IWbemServices, pTemplate: ?*IWbemObjectAccess, pRefresher: ?*IWbemRefresher, lFlags: i32, pContext: ?*IWbemContext, ppRefreshable: ?*?*IWbemObjectAccess, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).CreateRefreshableObject(@ptrCast(*const IWbemHiPerfProvider, self), pNamespace, pTemplate, pRefresher, lFlags, pContext, ppRefreshable, plId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfProvider_StopRefreshing(self: *const T, pRefresher: ?*IWbemRefresher, lId: i32, lFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).StopRefreshing(@ptrCast(*const IWbemHiPerfProvider, self), pRefresher, lId, lFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfProvider_CreateRefreshableEnum(self: *const T, pNamespace: ?*IWbemServices, wszClass: ?[*:0]const u16, pRefresher: ?*IWbemRefresher, lFlags: i32, pContext: ?*IWbemContext, pHiPerfEnum: ?*IWbemHiPerfEnum, plId: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).CreateRefreshableEnum(@ptrCast(*const IWbemHiPerfProvider, self), pNamespace, wszClass, pRefresher, lFlags, pContext, pHiPerfEnum, plId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemHiPerfProvider_GetObjects(self: *const T, pNamespace: ?*IWbemServices, lNumObjects: i32, apObj: [*]?*IWbemObjectAccess, lFlags: i32, pContext: ?*IWbemContext) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemHiPerfProvider.VTable, self.vtable).GetObjects(@ptrCast(*const IWbemHiPerfProvider, self), pNamespace, lNumObjects, apObj, lFlags, pContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemDecoupledRegistrar_Value = @import("../zig.zig").Guid.initString("1005cbcf-e64f-4646-bcd3-3a089d8a84b4");
pub const IID_IWbemDecoupledRegistrar = &IID_IWbemDecoupledRegistrar_Value;
pub const IWbemDecoupledRegistrar = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Register: fn(
self: *const IWbemDecoupledRegistrar,
a_Flags: i32,
a_Context: ?*IWbemContext,
a_User: ?[*:0]const u16,
a_Locale: ?[*:0]const u16,
a_Scope: ?[*:0]const u16,
a_Registration: ?[*:0]const u16,
pIUnknown: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
UnRegister: fn(
self: *const IWbemDecoupledRegistrar,
) 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 IWbemDecoupledRegistrar_Register(self: *const T, a_Flags: i32, a_Context: ?*IWbemContext, a_User: ?[*:0]const u16, a_Locale: ?[*:0]const u16, a_Scope: ?[*:0]const u16, a_Registration: ?[*:0]const u16, pIUnknown: ?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemDecoupledRegistrar.VTable, self.vtable).Register(@ptrCast(*const IWbemDecoupledRegistrar, self), a_Flags, a_Context, a_User, a_Locale, a_Scope, a_Registration, pIUnknown);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemDecoupledRegistrar_UnRegister(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemDecoupledRegistrar.VTable, self.vtable).UnRegister(@ptrCast(*const IWbemDecoupledRegistrar, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemProviderIdentity_Value = @import("../zig.zig").Guid.initString("631f7d97-d993-11d2-b339-00105a1f4aaf");
pub const IID_IWbemProviderIdentity = &IID_IWbemProviderIdentity_Value;
pub const IWbemProviderIdentity = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetRegistrationObject: fn(
self: *const IWbemProviderIdentity,
lFlags: i32,
pProvReg: ?*IWbemClassObject,
) 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 IWbemProviderIdentity_SetRegistrationObject(self: *const T, lFlags: i32, pProvReg: ?*IWbemClassObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemProviderIdentity.VTable, self.vtable).SetRegistrationObject(@ptrCast(*const IWbemProviderIdentity, self), lFlags, pProvReg);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WBEM_EXTRA_RETURN_CODES = enum(i32) {
S_INITIALIZED = 0,
S_LIMITED_SERVICE = 274433,
S_INDIRECTLY_UPDATED = 274434,
S_SUBJECT_TO_SDS = 274435,
E_RETRY_LATER = -2147209215,
E_RESOURCE_CONTENTION = -2147209214,
};
pub const WBEM_S_INITIALIZED = WBEM_EXTRA_RETURN_CODES.S_INITIALIZED;
pub const WBEM_S_LIMITED_SERVICE = WBEM_EXTRA_RETURN_CODES.S_LIMITED_SERVICE;
pub const WBEM_S_INDIRECTLY_UPDATED = WBEM_EXTRA_RETURN_CODES.S_INDIRECTLY_UPDATED;
pub const WBEM_S_SUBJECT_TO_SDS = WBEM_EXTRA_RETURN_CODES.S_SUBJECT_TO_SDS;
pub const WBEM_E_RETRY_LATER = WBEM_EXTRA_RETURN_CODES.E_RETRY_LATER;
pub const WBEM_E_RESOURCE_CONTENTION = WBEM_EXTRA_RETURN_CODES.E_RESOURCE_CONTENTION;
pub const WBEM_PROVIDER_FLAGS = enum(i32) {
E = 65536,
};
pub const WBEM_FLAG_OWNER_UPDATE = WBEM_PROVIDER_FLAGS.E;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemDecoupledBasicEventProvider_Value = @import("../zig.zig").Guid.initString("86336d20-ca11-4786-9ef1-bc8a946b42fc");
pub const IID_IWbemDecoupledBasicEventProvider = &IID_IWbemDecoupledBasicEventProvider_Value;
pub const IWbemDecoupledBasicEventProvider = extern struct {
pub const VTable = extern struct {
base: IWbemDecoupledRegistrar.VTable,
GetSink: fn(
self: *const IWbemDecoupledBasicEventProvider,
a_Flags: i32,
a_Context: ?*IWbemContext,
a_Sink: ?*?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetService: fn(
self: *const IWbemDecoupledBasicEventProvider,
a_Flags: i32,
a_Context: ?*IWbemContext,
a_Service: ?*?*IWbemServices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWbemDecoupledRegistrar.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemDecoupledBasicEventProvider_GetSink(self: *const T, a_Flags: i32, a_Context: ?*IWbemContext, a_Sink: ?*?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemDecoupledBasicEventProvider.VTable, self.vtable).GetSink(@ptrCast(*const IWbemDecoupledBasicEventProvider, self), a_Flags, a_Context, a_Sink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemDecoupledBasicEventProvider_GetService(self: *const T, a_Flags: i32, a_Context: ?*IWbemContext, a_Service: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemDecoupledBasicEventProvider.VTable, self.vtable).GetService(@ptrCast(*const IWbemDecoupledBasicEventProvider, self), a_Flags, a_Context, a_Service);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const WBEM_BATCH_TYPE = enum(i32) {
BATCH_IF_NEEDED = 0,
MUST_BATCH = 1,
MUST_NOT_BATCH = 2,
};
pub const WBEM_FLAG_BATCH_IF_NEEDED = WBEM_BATCH_TYPE.BATCH_IF_NEEDED;
pub const WBEM_FLAG_MUST_BATCH = WBEM_BATCH_TYPE.MUST_BATCH;
pub const WBEM_FLAG_MUST_NOT_BATCH = WBEM_BATCH_TYPE.MUST_NOT_BATCH;
// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IWbemEventSink_Value = @import("../zig.zig").Guid.initString("3ae0080a-7e3a-4366-bf89-0feedc931659");
pub const IID_IWbemEventSink = &IID_IWbemEventSink_Value;
pub const IWbemEventSink = extern struct {
pub const VTable = extern struct {
base: IWbemObjectSink.VTable,
SetSinkSecurity: fn(
self: *const IWbemEventSink,
lSDLength: i32,
pSD: [*:0]u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
IsActive: fn(
self: *const IWbemEventSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetRestrictedSink: fn(
self: *const IWbemEventSink,
lNumQueries: i32,
awszQueries: [*]const ?[*:0]const u16,
pCallback: ?*IUnknown,
ppSink: ?*?*IWbemEventSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetBatchingParameters: fn(
self: *const IWbemEventSink,
lFlags: i32,
dwMaxBufferSize: u32,
dwMaxSendLatency: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IWbemObjectSink.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemEventSink_SetSinkSecurity(self: *const T, lSDLength: i32, pSD: [*:0]u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventSink.VTable, self.vtable).SetSinkSecurity(@ptrCast(*const IWbemEventSink, self), lSDLength, pSD);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemEventSink_IsActive(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventSink.VTable, self.vtable).IsActive(@ptrCast(*const IWbemEventSink, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemEventSink_GetRestrictedSink(self: *const T, lNumQueries: i32, awszQueries: [*]const ?[*:0]const u16, pCallback: ?*IUnknown, ppSink: ?*?*IWbemEventSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventSink.VTable, self.vtable).GetRestrictedSink(@ptrCast(*const IWbemEventSink, self), lNumQueries, awszQueries, pCallback, ppSink);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemEventSink_SetBatchingParameters(self: *const T, lFlags: i32, dwMaxBufferSize: u32, dwMaxSendLatency: u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemEventSink.VTable, self.vtable).SetBatchingParameters(@ptrCast(*const IWbemEventSink, self), lFlags, dwMaxBufferSize, dwMaxSendLatency);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_SWbemLocator_Value = @import("../zig.zig").Guid.initString("76a64158-cb41-11d1-8b02-00600806d9b6");
pub const CLSID_SWbemLocator = &CLSID_SWbemLocator_Value;
const CLSID_SWbemNamedValueSet_Value = @import("../zig.zig").Guid.initString("9aed384e-ce8b-11d1-8b05-00600806d9b6");
pub const CLSID_SWbemNamedValueSet = &CLSID_SWbemNamedValueSet_Value;
const CLSID_SWbemObjectPath_Value = @import("../zig.zig").Guid.initString("5791bc26-ce9c-11d1-97bf-0000f81e849c");
pub const CLSID_SWbemObjectPath = &CLSID_SWbemObjectPath_Value;
const CLSID_SWbemLastError_Value = @import("../zig.zig").Guid.initString("c2feeeac-cfcd-11d1-8b05-00600806d9b6");
pub const CLSID_SWbemLastError = &CLSID_SWbemLastError_Value;
const CLSID_SWbemSink_Value = @import("../zig.zig").Guid.initString("75718c9a-f029-11d1-a1ac-00c04fb6c223");
pub const CLSID_SWbemSink = &CLSID_SWbemSink_Value;
const CLSID_SWbemDateTime_Value = @import("../zig.zig").Guid.initString("47dfbe54-cf76-11d3-b38f-00105a1f473a");
pub const CLSID_SWbemDateTime = &CLSID_SWbemDateTime_Value;
const CLSID_SWbemRefresher_Value = @import("../zig.zig").Guid.initString("d269bf5c-d9c1-11d3-b38f-00105a1f473a");
pub const CLSID_SWbemRefresher = &CLSID_SWbemRefresher_Value;
const CLSID_SWbemServices_Value = @import("../zig.zig").Guid.initString("04b83d63-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemServices = &CLSID_SWbemServices_Value;
const CLSID_SWbemServicesEx_Value = @import("../zig.zig").Guid.initString("62e522dc-8cf3-40a8-8b2e-37d595651e40");
pub const CLSID_SWbemServicesEx = &CLSID_SWbemServicesEx_Value;
const CLSID_SWbemObject_Value = @import("../zig.zig").Guid.initString("04b83d62-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemObject = &CLSID_SWbemObject_Value;
const CLSID_SWbemObjectEx_Value = @import("../zig.zig").Guid.initString("d6bdafb2-9435-491f-bb87-6aa0f0bc31a2");
pub const CLSID_SWbemObjectEx = &CLSID_SWbemObjectEx_Value;
const CLSID_SWbemObjectSet_Value = @import("../zig.zig").Guid.initString("04b83d61-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemObjectSet = &CLSID_SWbemObjectSet_Value;
const CLSID_SWbemNamedValue_Value = @import("../zig.zig").Guid.initString("04b83d60-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemNamedValue = &CLSID_SWbemNamedValue_Value;
const CLSID_SWbemQualifier_Value = @import("../zig.zig").Guid.initString("04b83d5f-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemQualifier = &CLSID_SWbemQualifier_Value;
const CLSID_SWbemQualifierSet_Value = @import("../zig.zig").Guid.initString("04b83d5e-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemQualifierSet = &CLSID_SWbemQualifierSet_Value;
const CLSID_SWbemProperty_Value = @import("../zig.zig").Guid.initString("04b83d5d-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemProperty = &CLSID_SWbemProperty_Value;
const CLSID_SWbemPropertySet_Value = @import("../zig.zig").Guid.initString("04b83d5c-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemPropertySet = &CLSID_SWbemPropertySet_Value;
const CLSID_SWbemMethod_Value = @import("../zig.zig").Guid.initString("04b83d5b-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemMethod = &CLSID_SWbemMethod_Value;
const CLSID_SWbemMethodSet_Value = @import("../zig.zig").Guid.initString("04b83d5a-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemMethodSet = &CLSID_SWbemMethodSet_Value;
const CLSID_SWbemEventSource_Value = @import("../zig.zig").Guid.initString("04b83d58-21ae-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemEventSource = &CLSID_SWbemEventSource_Value;
const CLSID_SWbemSecurity_Value = @import("../zig.zig").Guid.initString("b54d66e9-2287-11d2-8b33-00600806d9b6");
pub const CLSID_SWbemSecurity = &CLSID_SWbemSecurity_Value;
const CLSID_SWbemPrivilege_Value = @import("../zig.zig").Guid.initString("26ee67bc-5804-11d2-8b4a-00600806d9b6");
pub const CLSID_SWbemPrivilege = &CLSID_SWbemPrivilege_Value;
const CLSID_SWbemPrivilegeSet_Value = @import("../zig.zig").Guid.initString("26ee67be-5804-11d2-8b4a-00600806d9b6");
pub const CLSID_SWbemPrivilegeSet = &CLSID_SWbemPrivilegeSet_Value;
const CLSID_SWbemRefreshableItem_Value = @import("../zig.zig").Guid.initString("8c6854bc-de4b-11d3-b390-00105a1f473a");
pub const CLSID_SWbemRefreshableItem = &CLSID_SWbemRefreshableItem_Value;
pub const WbemChangeFlagEnum = enum(i32) {
CreateOrUpdate = 0,
UpdateOnly = 1,
CreateOnly = 2,
// UpdateCompatible = 0, this enum value conflicts with CreateOrUpdate
UpdateSafeMode = 32,
UpdateForceMode = 64,
StrongValidation = 128,
Advisory = 65536,
};
pub const wbemChangeFlagCreateOrUpdate = WbemChangeFlagEnum.CreateOrUpdate;
pub const wbemChangeFlagUpdateOnly = WbemChangeFlagEnum.UpdateOnly;
pub const wbemChangeFlagCreateOnly = WbemChangeFlagEnum.CreateOnly;
pub const wbemChangeFlagUpdateCompatible = WbemChangeFlagEnum.CreateOrUpdate;
pub const wbemChangeFlagUpdateSafeMode = WbemChangeFlagEnum.UpdateSafeMode;
pub const wbemChangeFlagUpdateForceMode = WbemChangeFlagEnum.UpdateForceMode;
pub const wbemChangeFlagStrongValidation = WbemChangeFlagEnum.StrongValidation;
pub const wbemChangeFlagAdvisory = WbemChangeFlagEnum.Advisory;
pub const WbemFlagEnum = enum(i32) {
ReturnImmediately = 16,
ReturnWhenComplete = 0,
// Bidirectional = 0, this enum value conflicts with ReturnWhenComplete
ForwardOnly = 32,
NoErrorObject = 64,
// ReturnErrorObject = 0, this enum value conflicts with ReturnWhenComplete
SendStatus = 128,
// DontSendStatus = 0, this enum value conflicts with ReturnWhenComplete
EnsureLocatable = 256,
DirectRead = 512,
// SendOnlySelected = 0, this enum value conflicts with ReturnWhenComplete
UseAmendedQualifiers = 131072,
// GetDefault = 0, this enum value conflicts with ReturnWhenComplete
SpawnInstance = 1,
// UseCurrentTime = 1, this enum value conflicts with SpawnInstance
};
pub const wbemFlagReturnImmediately = WbemFlagEnum.ReturnImmediately;
pub const wbemFlagReturnWhenComplete = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagBidirectional = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagForwardOnly = WbemFlagEnum.ForwardOnly;
pub const wbemFlagNoErrorObject = WbemFlagEnum.NoErrorObject;
pub const wbemFlagReturnErrorObject = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagSendStatus = WbemFlagEnum.SendStatus;
pub const wbemFlagDontSendStatus = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagEnsureLocatable = WbemFlagEnum.EnsureLocatable;
pub const wbemFlagDirectRead = WbemFlagEnum.DirectRead;
pub const wbemFlagSendOnlySelected = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagUseAmendedQualifiers = WbemFlagEnum.UseAmendedQualifiers;
pub const wbemFlagGetDefault = WbemFlagEnum.ReturnWhenComplete;
pub const wbemFlagSpawnInstance = WbemFlagEnum.SpawnInstance;
pub const wbemFlagUseCurrentTime = WbemFlagEnum.SpawnInstance;
pub const WbemQueryFlagEnum = enum(i32) {
Deep = 0,
Shallow = 1,
Prototype = 2,
};
pub const wbemQueryFlagDeep = WbemQueryFlagEnum.Deep;
pub const wbemQueryFlagShallow = WbemQueryFlagEnum.Shallow;
pub const wbemQueryFlagPrototype = WbemQueryFlagEnum.Prototype;
pub const WbemTextFlagEnum = enum(i32) {
s = 1,
};
pub const wbemTextFlagNoFlavors = WbemTextFlagEnum.s;
pub const WbemTimeout = enum(i32) {
e = -1,
};
pub const wbemTimeoutInfinite = WbemTimeout.e;
pub const WbemComparisonFlagEnum = enum(i32) {
ncludeAll = 0,
gnoreQualifiers = 1,
gnoreObjectSource = 2,
gnoreDefaultValues = 4,
gnoreClass = 8,
gnoreCase = 16,
gnoreFlavor = 32,
};
pub const wbemComparisonFlagIncludeAll = WbemComparisonFlagEnum.ncludeAll;
pub const wbemComparisonFlagIgnoreQualifiers = WbemComparisonFlagEnum.gnoreQualifiers;
pub const wbemComparisonFlagIgnoreObjectSource = WbemComparisonFlagEnum.gnoreObjectSource;
pub const wbemComparisonFlagIgnoreDefaultValues = WbemComparisonFlagEnum.gnoreDefaultValues;
pub const wbemComparisonFlagIgnoreClass = WbemComparisonFlagEnum.gnoreClass;
pub const wbemComparisonFlagIgnoreCase = WbemComparisonFlagEnum.gnoreCase;
pub const wbemComparisonFlagIgnoreFlavor = WbemComparisonFlagEnum.gnoreFlavor;
pub const WbemCimtypeEnum = enum(i32) {
Sint8 = 16,
Uint8 = 17,
Sint16 = 2,
Uint16 = 18,
Sint32 = 3,
Uint32 = 19,
Sint64 = 20,
Uint64 = 21,
Real32 = 4,
Real64 = 5,
Boolean = 11,
String = 8,
Datetime = 101,
Reference = 102,
Char16 = 103,
Object = 13,
};
pub const wbemCimtypeSint8 = WbemCimtypeEnum.Sint8;
pub const wbemCimtypeUint8 = WbemCimtypeEnum.Uint8;
pub const wbemCimtypeSint16 = WbemCimtypeEnum.Sint16;
pub const wbemCimtypeUint16 = WbemCimtypeEnum.Uint16;
pub const wbemCimtypeSint32 = WbemCimtypeEnum.Sint32;
pub const wbemCimtypeUint32 = WbemCimtypeEnum.Uint32;
pub const wbemCimtypeSint64 = WbemCimtypeEnum.Sint64;
pub const wbemCimtypeUint64 = WbemCimtypeEnum.Uint64;
pub const wbemCimtypeReal32 = WbemCimtypeEnum.Real32;
pub const wbemCimtypeReal64 = WbemCimtypeEnum.Real64;
pub const wbemCimtypeBoolean = WbemCimtypeEnum.Boolean;
pub const wbemCimtypeString = WbemCimtypeEnum.String;
pub const wbemCimtypeDatetime = WbemCimtypeEnum.Datetime;
pub const wbemCimtypeReference = WbemCimtypeEnum.Reference;
pub const wbemCimtypeChar16 = WbemCimtypeEnum.Char16;
pub const wbemCimtypeObject = WbemCimtypeEnum.Object;
pub const WbemErrorEnum = enum(i32) {
NoErr = 0,
ErrFailed = -2147217407,
ErrNotFound = -2147217406,
ErrAccessDenied = -2147217405,
ErrProviderFailure = -2147217404,
ErrTypeMismatch = -2147217403,
ErrOutOfMemory = -2147217402,
ErrInvalidContext = -2147217401,
ErrInvalidParameter = -2147217400,
ErrNotAvailable = -2147217399,
ErrCriticalError = -2147217398,
ErrInvalidStream = -2147217397,
ErrNotSupported = -2147217396,
ErrInvalidSuperclass = -2147217395,
ErrInvalidNamespace = -2147217394,
ErrInvalidObject = -2147217393,
ErrInvalidClass = -2147217392,
ErrProviderNotFound = -2147217391,
ErrInvalidProviderRegistration = -2147217390,
ErrProviderLoadFailure = -2147217389,
ErrInitializationFailure = -2147217388,
ErrTransportFailure = -2147217387,
ErrInvalidOperation = -2147217386,
ErrInvalidQuery = -2147217385,
ErrInvalidQueryType = -2147217384,
ErrAlreadyExists = -2147217383,
ErrOverrideNotAllowed = -2147217382,
ErrPropagatedQualifier = -2147217381,
ErrPropagatedProperty = -2147217380,
ErrUnexpected = -2147217379,
ErrIllegalOperation = -2147217378,
ErrCannotBeKey = -2147217377,
ErrIncompleteClass = -2147217376,
ErrInvalidSyntax = -2147217375,
ErrNondecoratedObject = -2147217374,
ErrReadOnly = -2147217373,
ErrProviderNotCapable = -2147217372,
ErrClassHasChildren = -2147217371,
ErrClassHasInstances = -2147217370,
ErrQueryNotImplemented = -2147217369,
ErrIllegalNull = -2147217368,
ErrInvalidQualifierType = -2147217367,
ErrInvalidPropertyType = -2147217366,
ErrValueOutOfRange = -2147217365,
ErrCannotBeSingleton = -2147217364,
ErrInvalidCimType = -2147217363,
ErrInvalidMethod = -2147217362,
ErrInvalidMethodParameters = -2147217361,
ErrSystemProperty = -2147217360,
ErrInvalidProperty = -2147217359,
ErrCallCancelled = -2147217358,
ErrShuttingDown = -2147217357,
ErrPropagatedMethod = -2147217356,
ErrUnsupportedParameter = -2147217355,
ErrMissingParameter = -2147217354,
ErrInvalidParameterId = -2147217353,
ErrNonConsecutiveParameterIds = -2147217352,
ErrParameterIdOnRetval = -2147217351,
ErrInvalidObjectPath = -2147217350,
ErrOutOfDiskSpace = -2147217349,
ErrBufferTooSmall = -2147217348,
ErrUnsupportedPutExtension = -2147217347,
ErrUnknownObjectType = -2147217346,
ErrUnknownPacketType = -2147217345,
ErrMarshalVersionMismatch = -2147217344,
ErrMarshalInvalidSignature = -2147217343,
ErrInvalidQualifier = -2147217342,
ErrInvalidDuplicateParameter = -2147217341,
ErrTooMuchData = -2147217340,
ErrServerTooBusy = -2147217339,
ErrInvalidFlavor = -2147217338,
ErrCircularReference = -2147217337,
ErrUnsupportedClassUpdate = -2147217336,
ErrCannotChangeKeyInheritance = -2147217335,
ErrCannotChangeIndexInheritance = -2147217328,
ErrTooManyProperties = -2147217327,
ErrUpdateTypeMismatch = -2147217326,
ErrUpdateOverrideNotAllowed = -2147217325,
ErrUpdatePropagatedMethod = -2147217324,
ErrMethodNotImplemented = -2147217323,
ErrMethodDisabled = -2147217322,
ErrRefresherBusy = -2147217321,
ErrUnparsableQuery = -2147217320,
ErrNotEventClass = -2147217319,
ErrMissingGroupWithin = -2147217318,
ErrMissingAggregationList = -2147217317,
ErrPropertyNotAnObject = -2147217316,
ErrAggregatingByObject = -2147217315,
ErrUninterpretableProviderQuery = -2147217313,
ErrBackupRestoreWinmgmtRunning = -2147217312,
ErrQueueOverflow = -2147217311,
ErrPrivilegeNotHeld = -2147217310,
ErrInvalidOperator = -2147217309,
ErrLocalCredentials = -2147217308,
ErrCannotBeAbstract = -2147217307,
ErrAmendedObject = -2147217306,
ErrClientTooSlow = -2147217305,
ErrNullSecurityDescriptor = -2147217304,
ErrTimeout = -2147217303,
ErrInvalidAssociation = -2147217302,
ErrAmbiguousOperation = -2147217301,
ErrQuotaViolation = -2147217300,
ErrTransactionConflict = -2147217299,
ErrForcedRollback = -2147217298,
ErrUnsupportedLocale = -2147217297,
ErrHandleOutOfDate = -2147217296,
ErrConnectionFailed = -2147217295,
ErrInvalidHandleRequest = -2147217294,
ErrPropertyNameTooWide = -2147217293,
ErrClassNameTooWide = -2147217292,
ErrMethodNameTooWide = -2147217291,
ErrQualifierNameTooWide = -2147217290,
ErrRerunCommand = -2147217289,
ErrDatabaseVerMismatch = -2147217288,
ErrVetoPut = -2147217287,
ErrVetoDelete = -2147217286,
ErrInvalidLocale = -2147217280,
ErrProviderSuspended = -2147217279,
ErrSynchronizationRequired = -2147217278,
ErrNoSchema = -2147217277,
ErrProviderAlreadyRegistered = -2147217276,
ErrProviderNotRegistered = -2147217275,
ErrFatalTransportError = -2147217274,
ErrEncryptedConnectionRequired = -2147217273,
ErrRegistrationTooBroad = -2147213311,
ErrRegistrationTooPrecise = -2147213310,
ErrTimedout = -2147209215,
ErrResetToDefault = -2147209214,
};
pub const wbemNoErr = WbemErrorEnum.NoErr;
pub const wbemErrFailed = WbemErrorEnum.ErrFailed;
pub const wbemErrNotFound = WbemErrorEnum.ErrNotFound;
pub const wbemErrAccessDenied = WbemErrorEnum.ErrAccessDenied;
pub const wbemErrProviderFailure = WbemErrorEnum.ErrProviderFailure;
pub const wbemErrTypeMismatch = WbemErrorEnum.ErrTypeMismatch;
pub const wbemErrOutOfMemory = WbemErrorEnum.ErrOutOfMemory;
pub const wbemErrInvalidContext = WbemErrorEnum.ErrInvalidContext;
pub const wbemErrInvalidParameter = WbemErrorEnum.ErrInvalidParameter;
pub const wbemErrNotAvailable = WbemErrorEnum.ErrNotAvailable;
pub const wbemErrCriticalError = WbemErrorEnum.ErrCriticalError;
pub const wbemErrInvalidStream = WbemErrorEnum.ErrInvalidStream;
pub const wbemErrNotSupported = WbemErrorEnum.ErrNotSupported;
pub const wbemErrInvalidSuperclass = WbemErrorEnum.ErrInvalidSuperclass;
pub const wbemErrInvalidNamespace = WbemErrorEnum.ErrInvalidNamespace;
pub const wbemErrInvalidObject = WbemErrorEnum.ErrInvalidObject;
pub const wbemErrInvalidClass = WbemErrorEnum.ErrInvalidClass;
pub const wbemErrProviderNotFound = WbemErrorEnum.ErrProviderNotFound;
pub const wbemErrInvalidProviderRegistration = WbemErrorEnum.ErrInvalidProviderRegistration;
pub const wbemErrProviderLoadFailure = WbemErrorEnum.ErrProviderLoadFailure;
pub const wbemErrInitializationFailure = WbemErrorEnum.ErrInitializationFailure;
pub const wbemErrTransportFailure = WbemErrorEnum.ErrTransportFailure;
pub const wbemErrInvalidOperation = WbemErrorEnum.ErrInvalidOperation;
pub const wbemErrInvalidQuery = WbemErrorEnum.ErrInvalidQuery;
pub const wbemErrInvalidQueryType = WbemErrorEnum.ErrInvalidQueryType;
pub const wbemErrAlreadyExists = WbemErrorEnum.ErrAlreadyExists;
pub const wbemErrOverrideNotAllowed = WbemErrorEnum.ErrOverrideNotAllowed;
pub const wbemErrPropagatedQualifier = WbemErrorEnum.ErrPropagatedQualifier;
pub const wbemErrPropagatedProperty = WbemErrorEnum.ErrPropagatedProperty;
pub const wbemErrUnexpected = WbemErrorEnum.ErrUnexpected;
pub const wbemErrIllegalOperation = WbemErrorEnum.ErrIllegalOperation;
pub const wbemErrCannotBeKey = WbemErrorEnum.ErrCannotBeKey;
pub const wbemErrIncompleteClass = WbemErrorEnum.ErrIncompleteClass;
pub const wbemErrInvalidSyntax = WbemErrorEnum.ErrInvalidSyntax;
pub const wbemErrNondecoratedObject = WbemErrorEnum.ErrNondecoratedObject;
pub const wbemErrReadOnly = WbemErrorEnum.ErrReadOnly;
pub const wbemErrProviderNotCapable = WbemErrorEnum.ErrProviderNotCapable;
pub const wbemErrClassHasChildren = WbemErrorEnum.ErrClassHasChildren;
pub const wbemErrClassHasInstances = WbemErrorEnum.ErrClassHasInstances;
pub const wbemErrQueryNotImplemented = WbemErrorEnum.ErrQueryNotImplemented;
pub const wbemErrIllegalNull = WbemErrorEnum.ErrIllegalNull;
pub const wbemErrInvalidQualifierType = WbemErrorEnum.ErrInvalidQualifierType;
pub const wbemErrInvalidPropertyType = WbemErrorEnum.ErrInvalidPropertyType;
pub const wbemErrValueOutOfRange = WbemErrorEnum.ErrValueOutOfRange;
pub const wbemErrCannotBeSingleton = WbemErrorEnum.ErrCannotBeSingleton;
pub const wbemErrInvalidCimType = WbemErrorEnum.ErrInvalidCimType;
pub const wbemErrInvalidMethod = WbemErrorEnum.ErrInvalidMethod;
pub const wbemErrInvalidMethodParameters = WbemErrorEnum.ErrInvalidMethodParameters;
pub const wbemErrSystemProperty = WbemErrorEnum.ErrSystemProperty;
pub const wbemErrInvalidProperty = WbemErrorEnum.ErrInvalidProperty;
pub const wbemErrCallCancelled = WbemErrorEnum.ErrCallCancelled;
pub const wbemErrShuttingDown = WbemErrorEnum.ErrShuttingDown;
pub const wbemErrPropagatedMethod = WbemErrorEnum.ErrPropagatedMethod;
pub const wbemErrUnsupportedParameter = WbemErrorEnum.ErrUnsupportedParameter;
pub const wbemErrMissingParameter = WbemErrorEnum.ErrMissingParameter;
pub const wbemErrInvalidParameterId = WbemErrorEnum.ErrInvalidParameterId;
pub const wbemErrNonConsecutiveParameterIds = WbemErrorEnum.ErrNonConsecutiveParameterIds;
pub const wbemErrParameterIdOnRetval = WbemErrorEnum.ErrParameterIdOnRetval;
pub const wbemErrInvalidObjectPath = WbemErrorEnum.ErrInvalidObjectPath;
pub const wbemErrOutOfDiskSpace = WbemErrorEnum.ErrOutOfDiskSpace;
pub const wbemErrBufferTooSmall = WbemErrorEnum.ErrBufferTooSmall;
pub const wbemErrUnsupportedPutExtension = WbemErrorEnum.ErrUnsupportedPutExtension;
pub const wbemErrUnknownObjectType = WbemErrorEnum.ErrUnknownObjectType;
pub const wbemErrUnknownPacketType = WbemErrorEnum.ErrUnknownPacketType;
pub const wbemErrMarshalVersionMismatch = WbemErrorEnum.ErrMarshalVersionMismatch;
pub const wbemErrMarshalInvalidSignature = WbemErrorEnum.ErrMarshalInvalidSignature;
pub const wbemErrInvalidQualifier = WbemErrorEnum.ErrInvalidQualifier;
pub const wbemErrInvalidDuplicateParameter = WbemErrorEnum.ErrInvalidDuplicateParameter;
pub const wbemErrTooMuchData = WbemErrorEnum.ErrTooMuchData;
pub const wbemErrServerTooBusy = WbemErrorEnum.ErrServerTooBusy;
pub const wbemErrInvalidFlavor = WbemErrorEnum.ErrInvalidFlavor;
pub const wbemErrCircularReference = WbemErrorEnum.ErrCircularReference;
pub const wbemErrUnsupportedClassUpdate = WbemErrorEnum.ErrUnsupportedClassUpdate;
pub const wbemErrCannotChangeKeyInheritance = WbemErrorEnum.ErrCannotChangeKeyInheritance;
pub const wbemErrCannotChangeIndexInheritance = WbemErrorEnum.ErrCannotChangeIndexInheritance;
pub const wbemErrTooManyProperties = WbemErrorEnum.ErrTooManyProperties;
pub const wbemErrUpdateTypeMismatch = WbemErrorEnum.ErrUpdateTypeMismatch;
pub const wbemErrUpdateOverrideNotAllowed = WbemErrorEnum.ErrUpdateOverrideNotAllowed;
pub const wbemErrUpdatePropagatedMethod = WbemErrorEnum.ErrUpdatePropagatedMethod;
pub const wbemErrMethodNotImplemented = WbemErrorEnum.ErrMethodNotImplemented;
pub const wbemErrMethodDisabled = WbemErrorEnum.ErrMethodDisabled;
pub const wbemErrRefresherBusy = WbemErrorEnum.ErrRefresherBusy;
pub const wbemErrUnparsableQuery = WbemErrorEnum.ErrUnparsableQuery;
pub const wbemErrNotEventClass = WbemErrorEnum.ErrNotEventClass;
pub const wbemErrMissingGroupWithin = WbemErrorEnum.ErrMissingGroupWithin;
pub const wbemErrMissingAggregationList = WbemErrorEnum.ErrMissingAggregationList;
pub const wbemErrPropertyNotAnObject = WbemErrorEnum.ErrPropertyNotAnObject;
pub const wbemErrAggregatingByObject = WbemErrorEnum.ErrAggregatingByObject;
pub const wbemErrUninterpretableProviderQuery = WbemErrorEnum.ErrUninterpretableProviderQuery;
pub const wbemErrBackupRestoreWinmgmtRunning = WbemErrorEnum.ErrBackupRestoreWinmgmtRunning;
pub const wbemErrQueueOverflow = WbemErrorEnum.ErrQueueOverflow;
pub const wbemErrPrivilegeNotHeld = WbemErrorEnum.ErrPrivilegeNotHeld;
pub const wbemErrInvalidOperator = WbemErrorEnum.ErrInvalidOperator;
pub const wbemErrLocalCredentials = WbemErrorEnum.ErrLocalCredentials;
pub const wbemErrCannotBeAbstract = WbemErrorEnum.ErrCannotBeAbstract;
pub const wbemErrAmendedObject = WbemErrorEnum.ErrAmendedObject;
pub const wbemErrClientTooSlow = WbemErrorEnum.ErrClientTooSlow;
pub const wbemErrNullSecurityDescriptor = WbemErrorEnum.ErrNullSecurityDescriptor;
pub const wbemErrTimeout = WbemErrorEnum.ErrTimeout;
pub const wbemErrInvalidAssociation = WbemErrorEnum.ErrInvalidAssociation;
pub const wbemErrAmbiguousOperation = WbemErrorEnum.ErrAmbiguousOperation;
pub const wbemErrQuotaViolation = WbemErrorEnum.ErrQuotaViolation;
pub const wbemErrTransactionConflict = WbemErrorEnum.ErrTransactionConflict;
pub const wbemErrForcedRollback = WbemErrorEnum.ErrForcedRollback;
pub const wbemErrUnsupportedLocale = WbemErrorEnum.ErrUnsupportedLocale;
pub const wbemErrHandleOutOfDate = WbemErrorEnum.ErrHandleOutOfDate;
pub const wbemErrConnectionFailed = WbemErrorEnum.ErrConnectionFailed;
pub const wbemErrInvalidHandleRequest = WbemErrorEnum.ErrInvalidHandleRequest;
pub const wbemErrPropertyNameTooWide = WbemErrorEnum.ErrPropertyNameTooWide;
pub const wbemErrClassNameTooWide = WbemErrorEnum.ErrClassNameTooWide;
pub const wbemErrMethodNameTooWide = WbemErrorEnum.ErrMethodNameTooWide;
pub const wbemErrQualifierNameTooWide = WbemErrorEnum.ErrQualifierNameTooWide;
pub const wbemErrRerunCommand = WbemErrorEnum.ErrRerunCommand;
pub const wbemErrDatabaseVerMismatch = WbemErrorEnum.ErrDatabaseVerMismatch;
pub const wbemErrVetoPut = WbemErrorEnum.ErrVetoPut;
pub const wbemErrVetoDelete = WbemErrorEnum.ErrVetoDelete;
pub const wbemErrInvalidLocale = WbemErrorEnum.ErrInvalidLocale;
pub const wbemErrProviderSuspended = WbemErrorEnum.ErrProviderSuspended;
pub const wbemErrSynchronizationRequired = WbemErrorEnum.ErrSynchronizationRequired;
pub const wbemErrNoSchema = WbemErrorEnum.ErrNoSchema;
pub const wbemErrProviderAlreadyRegistered = WbemErrorEnum.ErrProviderAlreadyRegistered;
pub const wbemErrProviderNotRegistered = WbemErrorEnum.ErrProviderNotRegistered;
pub const wbemErrFatalTransportError = WbemErrorEnum.ErrFatalTransportError;
pub const wbemErrEncryptedConnectionRequired = WbemErrorEnum.ErrEncryptedConnectionRequired;
pub const wbemErrRegistrationTooBroad = WbemErrorEnum.ErrRegistrationTooBroad;
pub const wbemErrRegistrationTooPrecise = WbemErrorEnum.ErrRegistrationTooPrecise;
pub const wbemErrTimedout = WbemErrorEnum.ErrTimedout;
pub const wbemErrResetToDefault = WbemErrorEnum.ErrResetToDefault;
pub const WbemAuthenticationLevelEnum = enum(i32) {
Default = 0,
None = 1,
Connect = 2,
Call = 3,
Pkt = 4,
PktIntegrity = 5,
PktPrivacy = 6,
};
pub const wbemAuthenticationLevelDefault = WbemAuthenticationLevelEnum.Default;
pub const wbemAuthenticationLevelNone = WbemAuthenticationLevelEnum.None;
pub const wbemAuthenticationLevelConnect = WbemAuthenticationLevelEnum.Connect;
pub const wbemAuthenticationLevelCall = WbemAuthenticationLevelEnum.Call;
pub const wbemAuthenticationLevelPkt = WbemAuthenticationLevelEnum.Pkt;
pub const wbemAuthenticationLevelPktIntegrity = WbemAuthenticationLevelEnum.PktIntegrity;
pub const wbemAuthenticationLevelPktPrivacy = WbemAuthenticationLevelEnum.PktPrivacy;
pub const WbemImpersonationLevelEnum = enum(i32) {
Anonymous = 1,
Identify = 2,
Impersonate = 3,
Delegate = 4,
};
pub const wbemImpersonationLevelAnonymous = WbemImpersonationLevelEnum.Anonymous;
pub const wbemImpersonationLevelIdentify = WbemImpersonationLevelEnum.Identify;
pub const wbemImpersonationLevelImpersonate = WbemImpersonationLevelEnum.Impersonate;
pub const wbemImpersonationLevelDelegate = WbemImpersonationLevelEnum.Delegate;
pub const WbemPrivilegeEnum = enum(i32) {
CreateToken = 1,
PrimaryToken = 2,
LockMemory = 3,
IncreaseQuota = 4,
MachineAccount = 5,
Tcb = 6,
Security = 7,
TakeOwnership = 8,
LoadDriver = 9,
SystemProfile = 10,
Systemtime = 11,
ProfileSingleProcess = 12,
IncreaseBasePriority = 13,
CreatePagefile = 14,
CreatePermanent = 15,
Backup = 16,
Restore = 17,
Shutdown = 18,
Debug = 19,
Audit = 20,
SystemEnvironment = 21,
ChangeNotify = 22,
RemoteShutdown = 23,
Undock = 24,
SyncAgent = 25,
EnableDelegation = 26,
ManageVolume = 27,
};
pub const wbemPrivilegeCreateToken = WbemPrivilegeEnum.CreateToken;
pub const wbemPrivilegePrimaryToken = WbemPrivilegeEnum.PrimaryToken;
pub const wbemPrivilegeLockMemory = WbemPrivilegeEnum.LockMemory;
pub const wbemPrivilegeIncreaseQuota = WbemPrivilegeEnum.IncreaseQuota;
pub const wbemPrivilegeMachineAccount = WbemPrivilegeEnum.MachineAccount;
pub const wbemPrivilegeTcb = WbemPrivilegeEnum.Tcb;
pub const wbemPrivilegeSecurity = WbemPrivilegeEnum.Security;
pub const wbemPrivilegeTakeOwnership = WbemPrivilegeEnum.TakeOwnership;
pub const wbemPrivilegeLoadDriver = WbemPrivilegeEnum.LoadDriver;
pub const wbemPrivilegeSystemProfile = WbemPrivilegeEnum.SystemProfile;
pub const wbemPrivilegeSystemtime = WbemPrivilegeEnum.Systemtime;
pub const wbemPrivilegeProfileSingleProcess = WbemPrivilegeEnum.ProfileSingleProcess;
pub const wbemPrivilegeIncreaseBasePriority = WbemPrivilegeEnum.IncreaseBasePriority;
pub const wbemPrivilegeCreatePagefile = WbemPrivilegeEnum.CreatePagefile;
pub const wbemPrivilegeCreatePermanent = WbemPrivilegeEnum.CreatePermanent;
pub const wbemPrivilegeBackup = WbemPrivilegeEnum.Backup;
pub const wbemPrivilegeRestore = WbemPrivilegeEnum.Restore;
pub const wbemPrivilegeShutdown = WbemPrivilegeEnum.Shutdown;
pub const wbemPrivilegeDebug = WbemPrivilegeEnum.Debug;
pub const wbemPrivilegeAudit = WbemPrivilegeEnum.Audit;
pub const wbemPrivilegeSystemEnvironment = WbemPrivilegeEnum.SystemEnvironment;
pub const wbemPrivilegeChangeNotify = WbemPrivilegeEnum.ChangeNotify;
pub const wbemPrivilegeRemoteShutdown = WbemPrivilegeEnum.RemoteShutdown;
pub const wbemPrivilegeUndock = WbemPrivilegeEnum.Undock;
pub const wbemPrivilegeSyncAgent = WbemPrivilegeEnum.SyncAgent;
pub const wbemPrivilegeEnableDelegation = WbemPrivilegeEnum.EnableDelegation;
pub const wbemPrivilegeManageVolume = WbemPrivilegeEnum.ManageVolume;
pub const WbemObjectTextFormatEnum = enum(i32) {
CIMDTD20 = 1,
WMIDTD20 = 2,
};
pub const wbemObjectTextFormatCIMDTD20 = WbemObjectTextFormatEnum.CIMDTD20;
pub const wbemObjectTextFormatWMIDTD20 = WbemObjectTextFormatEnum.WMIDTD20;
pub const WbemConnectOptionsEnum = enum(i32) {
t = 128,
};
pub const wbemConnectFlagUseMaxWait = WbemConnectOptionsEnum.t;
const IID_ISWbemServices_Value = @import("../zig.zig").Guid.initString("76a6415c-cb41-11d1-8b02-00600806d9b6");
pub const IID_ISWbemServices = &IID_ISWbemServices_Value;
pub const ISWbemServices = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
Get: fn(
self: *const ISWbemServices,
strObjectPath: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strObjectPath: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete: fn(
self: *const ISWbemServices,
strObjectPath: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strObjectPath: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstancesOf: fn(
self: *const ISWbemServices,
strClass: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstancesOfAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strClass: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SubclassesOf: fn(
self: *const ISWbemServices,
strSuperclass: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SubclassesOfAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strSuperclass: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecQuery: fn(
self: *const ISWbemServices,
strQuery: ?BSTR,
strQueryLanguage: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecQueryAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strQuery: ?BSTR,
strQueryLanguage: ?BSTR,
lFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AssociatorsOf: fn(
self: *const ISWbemServices,
strObjectPath: ?BSTR,
strAssocClass: ?BSTR,
strResultClass: ?BSTR,
strResultRole: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredAssocQualifier: ?BSTR,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AssociatorsOfAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strObjectPath: ?BSTR,
strAssocClass: ?BSTR,
strResultClass: ?BSTR,
strResultRole: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredAssocQualifier: ?BSTR,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReferencesTo: fn(
self: *const ISWbemServices,
strObjectPath: ?BSTR,
strResultClass: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReferencesToAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strObjectPath: ?BSTR,
strResultClass: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecNotificationQuery: fn(
self: *const ISWbemServices,
strQuery: ?BSTR,
strQueryLanguage: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemEventSource: ?*?*ISWbemEventSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecNotificationQueryAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strQuery: ?BSTR,
strQueryLanguage: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethod: fn(
self: *const ISWbemServices,
strObjectPath: ?BSTR,
strMethodName: ?BSTR,
objWbemInParameters: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemOutParameters: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethodAsync: fn(
self: *const ISWbemServices,
objWbemSink: ?*IDispatch,
strObjectPath: ?BSTR,
strMethodName: ?BSTR,
objWbemInParameters: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemServices,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_Get(self: *const T, strObjectPath: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).Get(@ptrCast(*const ISWbemServices, self), strObjectPath, iFlags, objWbemNamedValueSet, objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_GetAsync(self: *const T, objWbemSink: ?*IDispatch, strObjectPath: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).GetAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strObjectPath, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_Delete(self: *const T, strObjectPath: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).Delete(@ptrCast(*const ISWbemServices, self), strObjectPath, iFlags, objWbemNamedValueSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_DeleteAsync(self: *const T, objWbemSink: ?*IDispatch, strObjectPath: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).DeleteAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strObjectPath, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_InstancesOf(self: *const T, strClass: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).InstancesOf(@ptrCast(*const ISWbemServices, self), strClass, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_InstancesOfAsync(self: *const T, objWbemSink: ?*IDispatch, strClass: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).InstancesOfAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strClass, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_SubclassesOf(self: *const T, strSuperclass: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).SubclassesOf(@ptrCast(*const ISWbemServices, self), strSuperclass, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_SubclassesOfAsync(self: *const T, objWbemSink: ?*IDispatch, strSuperclass: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).SubclassesOfAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strSuperclass, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecQuery(self: *const T, strQuery: ?BSTR, strQueryLanguage: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecQuery(@ptrCast(*const ISWbemServices, self), strQuery, strQueryLanguage, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecQueryAsync(self: *const T, objWbemSink: ?*IDispatch, strQuery: ?BSTR, strQueryLanguage: ?BSTR, lFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecQueryAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strQuery, strQueryLanguage, lFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_AssociatorsOf(self: *const T, strObjectPath: ?BSTR, strAssocClass: ?BSTR, strResultClass: ?BSTR, strResultRole: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredAssocQualifier: ?BSTR, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).AssociatorsOf(@ptrCast(*const ISWbemServices, self), strObjectPath, strAssocClass, strResultClass, strResultRole, strRole, bClassesOnly, bSchemaOnly, strRequiredAssocQualifier, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_AssociatorsOfAsync(self: *const T, objWbemSink: ?*IDispatch, strObjectPath: ?BSTR, strAssocClass: ?BSTR, strResultClass: ?BSTR, strResultRole: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredAssocQualifier: ?BSTR, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).AssociatorsOfAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strObjectPath, strAssocClass, strResultClass, strResultRole, strRole, bClassesOnly, bSchemaOnly, strRequiredAssocQualifier, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ReferencesTo(self: *const T, strObjectPath: ?BSTR, strResultClass: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ReferencesTo(@ptrCast(*const ISWbemServices, self), strObjectPath, strResultClass, strRole, bClassesOnly, bSchemaOnly, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ReferencesToAsync(self: *const T, objWbemSink: ?*IDispatch, strObjectPath: ?BSTR, strResultClass: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ReferencesToAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strObjectPath, strResultClass, strRole, bClassesOnly, bSchemaOnly, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecNotificationQuery(self: *const T, strQuery: ?BSTR, strQueryLanguage: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemEventSource: ?*?*ISWbemEventSource) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecNotificationQuery(@ptrCast(*const ISWbemServices, self), strQuery, strQueryLanguage, iFlags, objWbemNamedValueSet, objWbemEventSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecNotificationQueryAsync(self: *const T, objWbemSink: ?*IDispatch, strQuery: ?BSTR, strQueryLanguage: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecNotificationQueryAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strQuery, strQueryLanguage, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecMethod(self: *const T, strObjectPath: ?BSTR, strMethodName: ?BSTR, objWbemInParameters: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemOutParameters: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecMethod(@ptrCast(*const ISWbemServices, self), strObjectPath, strMethodName, objWbemInParameters, iFlags, objWbemNamedValueSet, objWbemOutParameters);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_ExecMethodAsync(self: *const T, objWbemSink: ?*IDispatch, strObjectPath: ?BSTR, strMethodName: ?BSTR, objWbemInParameters: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).ExecMethodAsync(@ptrCast(*const ISWbemServices, self), objWbemSink, strObjectPath, strMethodName, objWbemInParameters, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServices_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServices.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemServices, self), objWbemSecurity);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemLocator_Value = @import("../zig.zig").Guid.initString("76a6415b-cb41-11d1-8b02-00600806d9b6");
pub const IID_ISWbemLocator = &IID_ISWbemLocator_Value;
pub const ISWbemLocator = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
ConnectServer: fn(
self: *const ISWbemLocator,
strServer: ?BSTR,
strNamespace: ?BSTR,
strUser: ?BSTR,
strPassword: ?BSTR,
strLocale: ?BSTR,
strAuthority: ?BSTR,
iSecurityFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemServices: ?*?*ISWbemServices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemLocator,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemLocator_ConnectServer(self: *const T, strServer: ?BSTR, strNamespace: ?BSTR, strUser: ?BSTR, strPassword: ?BSTR, strLocale: ?BSTR, strAuthority: ?BSTR, iSecurityFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemServices: ?*?*ISWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemLocator.VTable, self.vtable).ConnectServer(@ptrCast(*const ISWbemLocator, self), strServer, strNamespace, strUser, strPassword, strLocale, strAuthority, iSecurityFlags, objWbemNamedValueSet, objWbemServices);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemLocator_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemLocator.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemLocator, self), objWbemSecurity);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemObject_Value = @import("../zig.zig").Guid.initString("76a6415a-cb41-11d1-8b02-00600806d9b6");
pub const IID_ISWbemObject = &IID_ISWbemObject_Value;
pub const ISWbemObject = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
Put_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectPath: ?*?*ISWbemObjectPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Delete_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Instances_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
InstancesAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Subclasses_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SubclassesAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Associators_: fn(
self: *const ISWbemObject,
strAssocClass: ?BSTR,
strResultClass: ?BSTR,
strResultRole: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredAssocQualifier: ?BSTR,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AssociatorsAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
strAssocClass: ?BSTR,
strResultClass: ?BSTR,
strResultRole: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredAssocQualifier: ?BSTR,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
References_: fn(
self: *const ISWbemObject,
strResultClass: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ReferencesAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
strResultClass: ?BSTR,
strRole: ?BSTR,
bClassesOnly: i16,
bSchemaOnly: i16,
strRequiredQualifier: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethod_: fn(
self: *const ISWbemObject,
strMethodName: ?BSTR,
objWbemInParameters: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemOutParameters: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ExecMethodAsync_: fn(
self: *const ISWbemObject,
objWbemSink: ?*IDispatch,
strMethodName: ?BSTR,
objWbemInParameters: ?*IDispatch,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone_: fn(
self: *const ISWbemObject,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetObjectText_: fn(
self: *const ISWbemObject,
iFlags: i32,
strObjectText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SpawnDerivedClass_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SpawnInstance_: fn(
self: *const ISWbemObject,
iFlags: i32,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
CompareTo_: fn(
self: *const ISWbemObject,
objWbemObject: ?*IDispatch,
iFlags: i32,
bResult: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Qualifiers_: fn(
self: *const ISWbemObject,
objWbemQualifierSet: ?*?*ISWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Properties_: fn(
self: *const ISWbemObject,
objWbemPropertySet: ?*?*ISWbemPropertySet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Methods_: fn(
self: *const ISWbemObject,
objWbemMethodSet: ?*?*ISWbemMethodSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Derivation_: fn(
self: *const ISWbemObject,
strClassNameArray: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Path_: fn(
self: *const ISWbemObject,
objWbemObjectPath: ?*?*ISWbemObjectPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemObject,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Put_(self: *const T, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectPath: ?*?*ISWbemObjectPath) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Put_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemNamedValueSet, objWbemObjectPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_PutAsync_(self: *const T, objWbemSink: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).PutAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Delete_(self: *const T, iFlags: i32, objWbemNamedValueSet: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Delete_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemNamedValueSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_DeleteAsync_(self: *const T, objWbemSink: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).DeleteAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Instances_(self: *const T, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Instances_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_InstancesAsync_(self: *const T, objWbemSink: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).InstancesAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Subclasses_(self: *const T, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Subclasses_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_SubclassesAsync_(self: *const T, objWbemSink: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).SubclassesAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Associators_(self: *const T, strAssocClass: ?BSTR, strResultClass: ?BSTR, strResultRole: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredAssocQualifier: ?BSTR, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Associators_(@ptrCast(*const ISWbemObject, self), strAssocClass, strResultClass, strResultRole, strRole, bClassesOnly, bSchemaOnly, strRequiredAssocQualifier, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_AssociatorsAsync_(self: *const T, objWbemSink: ?*IDispatch, strAssocClass: ?BSTR, strResultClass: ?BSTR, strResultRole: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredAssocQualifier: ?BSTR, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).AssociatorsAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, strAssocClass, strResultClass, strResultRole, strRole, bClassesOnly, bSchemaOnly, strRequiredAssocQualifier, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_References_(self: *const T, strResultClass: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).References_(@ptrCast(*const ISWbemObject, self), strResultClass, strRole, bClassesOnly, bSchemaOnly, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_ReferencesAsync_(self: *const T, objWbemSink: ?*IDispatch, strResultClass: ?BSTR, strRole: ?BSTR, bClassesOnly: i16, bSchemaOnly: i16, strRequiredQualifier: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).ReferencesAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, strResultClass, strRole, bClassesOnly, bSchemaOnly, strRequiredQualifier, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_ExecMethod_(self: *const T, strMethodName: ?BSTR, objWbemInParameters: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemOutParameters: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).ExecMethod_(@ptrCast(*const ISWbemObject, self), strMethodName, objWbemInParameters, iFlags, objWbemNamedValueSet, objWbemOutParameters);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_ExecMethodAsync_(self: *const T, objWbemSink: ?*IDispatch, strMethodName: ?BSTR, objWbemInParameters: ?*IDispatch, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).ExecMethodAsync_(@ptrCast(*const ISWbemObject, self), objWbemSink, strMethodName, objWbemInParameters, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_Clone_(self: *const T, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).Clone_(@ptrCast(*const ISWbemObject, self), objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_GetObjectText_(self: *const T, iFlags: i32, strObjectText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).GetObjectText_(@ptrCast(*const ISWbemObject, self), iFlags, strObjectText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_SpawnDerivedClass_(self: *const T, iFlags: i32, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).SpawnDerivedClass_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_SpawnInstance_(self: *const T, iFlags: i32, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).SpawnInstance_(@ptrCast(*const ISWbemObject, self), iFlags, objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_CompareTo_(self: *const T, objWbemObject: ?*IDispatch, iFlags: i32, bResult: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).CompareTo_(@ptrCast(*const ISWbemObject, self), objWbemObject, iFlags, bResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Qualifiers_(self: *const T, objWbemQualifierSet: ?*?*ISWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Qualifiers_(@ptrCast(*const ISWbemObject, self), objWbemQualifierSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Properties_(self: *const T, objWbemPropertySet: ?*?*ISWbemPropertySet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Properties_(@ptrCast(*const ISWbemObject, self), objWbemPropertySet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Methods_(self: *const T, objWbemMethodSet: ?*?*ISWbemMethodSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Methods_(@ptrCast(*const ISWbemObject, self), objWbemMethodSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Derivation_(self: *const T, strClassNameArray: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Derivation_(@ptrCast(*const ISWbemObject, self), strClassNameArray);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Path_(self: *const T, objWbemObjectPath: ?*?*ISWbemObjectPath) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Path_(@ptrCast(*const ISWbemObject, self), objWbemObjectPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObject_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObject.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemObject, self), objWbemSecurity);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemObjectSet_Value = @import("../zig.zig").Guid.initString("76a6415f-cb41-11d1-8b02-00600806d9b6");
pub const IID_ISWbemObjectSet = &IID_ISWbemObjectSet_Value;
pub const ISWbemObjectSet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemObjectSet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemObjectSet,
strObjectPath: ?BSTR,
iFlags: i32,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemObjectSet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemObjectSet,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
ItemIndex: fn(
self: *const ISWbemObjectSet,
lIndex: i32,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectSet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectSet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemObjectSet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectSet_Item(self: *const T, strObjectPath: ?BSTR, iFlags: i32, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectSet.VTable, self.vtable).Item(@ptrCast(*const ISWbemObjectSet, self), strObjectPath, iFlags, objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectSet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectSet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemObjectSet, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectSet_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectSet.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemObjectSet, self), objWbemSecurity);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectSet_ItemIndex(self: *const T, lIndex: i32, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectSet.VTable, self.vtable).ItemIndex(@ptrCast(*const ISWbemObjectSet, self), lIndex, objWbemObject);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemNamedValue_Value = @import("../zig.zig").Guid.initString("76a64164-cb41-11d1-8b02-00600806d9b6");
pub const IID_ISWbemNamedValue = &IID_ISWbemNamedValue_Value;
pub const ISWbemNamedValue = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Value: fn(
self: *const ISWbemNamedValue,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Value: fn(
self: *const ISWbemNamedValue,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const ISWbemNamedValue,
strName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValue_get_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValue.VTable, self.vtable).get_Value(@ptrCast(*const ISWbemNamedValue, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValue_put_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValue.VTable, self.vtable).put_Value(@ptrCast(*const ISWbemNamedValue, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValue_get_Name(self: *const T, strName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValue.VTable, self.vtable).get_Name(@ptrCast(*const ISWbemNamedValue, self), strName);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemNamedValueSet_Value = @import("../zig.zig").Guid.initString("cf2376ea-ce8c-11d1-8b05-00600806d9b6");
pub const IID_ISWbemNamedValueSet = &IID_ISWbemNamedValueSet_Value;
pub const ISWbemNamedValueSet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemNamedValueSet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemNamedValueSet,
strName: ?BSTR,
iFlags: i32,
objWbemNamedValue: ?*?*ISWbemNamedValue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemNamedValueSet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const ISWbemNamedValueSet,
strName: ?BSTR,
varValue: ?*VARIANT,
iFlags: i32,
objWbemNamedValue: ?*?*ISWbemNamedValue,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemNamedValueSet,
strName: ?BSTR,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Clone: fn(
self: *const ISWbemNamedValueSet,
objWbemNamedValueSet: ?*?*ISWbemNamedValueSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAll: fn(
self: *const ISWbemNamedValueSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemNamedValueSet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_Item(self: *const T, strName: ?BSTR, iFlags: i32, objWbemNamedValue: ?*?*ISWbemNamedValue) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).Item(@ptrCast(*const ISWbemNamedValueSet, self), strName, iFlags, objWbemNamedValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemNamedValueSet, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_Add(self: *const T, strName: ?BSTR, varValue: ?*VARIANT, iFlags: i32, objWbemNamedValue: ?*?*ISWbemNamedValue) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).Add(@ptrCast(*const ISWbemNamedValueSet, self), strName, varValue, iFlags, objWbemNamedValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_Remove(self: *const T, strName: ?BSTR, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).Remove(@ptrCast(*const ISWbemNamedValueSet, self), strName, iFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_Clone(self: *const T, objWbemNamedValueSet: ?*?*ISWbemNamedValueSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).Clone(@ptrCast(*const ISWbemNamedValueSet, self), objWbemNamedValueSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemNamedValueSet_DeleteAll(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemNamedValueSet.VTable, self.vtable).DeleteAll(@ptrCast(*const ISWbemNamedValueSet, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemQualifier_Value = @import("../zig.zig").Guid.initString("79b05932-d3b7-11d1-8b06-00600806d9b6");
pub const IID_ISWbemQualifier = &IID_ISWbemQualifier_Value;
pub const ISWbemQualifier = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Value: fn(
self: *const ISWbemQualifier,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Value: fn(
self: *const ISWbemQualifier,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const ISWbemQualifier,
strName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsLocal: fn(
self: *const ISWbemQualifier,
bIsLocal: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_PropagatesToSubclass: fn(
self: *const ISWbemQualifier,
bPropagatesToSubclass: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_PropagatesToSubclass: fn(
self: *const ISWbemQualifier,
bPropagatesToSubclass: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_PropagatesToInstance: fn(
self: *const ISWbemQualifier,
bPropagatesToInstance: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_PropagatesToInstance: fn(
self: *const ISWbemQualifier,
bPropagatesToInstance: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsOverridable: fn(
self: *const ISWbemQualifier,
bIsOverridable: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_IsOverridable: fn(
self: *const ISWbemQualifier,
bIsOverridable: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsAmended: fn(
self: *const ISWbemQualifier,
bIsAmended: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_Value(@ptrCast(*const ISWbemQualifier, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_put_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).put_Value(@ptrCast(*const ISWbemQualifier, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_Name(self: *const T, strName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_Name(@ptrCast(*const ISWbemQualifier, self), strName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_IsLocal(self: *const T, bIsLocal: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_IsLocal(@ptrCast(*const ISWbemQualifier, self), bIsLocal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_PropagatesToSubclass(self: *const T, bPropagatesToSubclass: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_PropagatesToSubclass(@ptrCast(*const ISWbemQualifier, self), bPropagatesToSubclass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_put_PropagatesToSubclass(self: *const T, bPropagatesToSubclass: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).put_PropagatesToSubclass(@ptrCast(*const ISWbemQualifier, self), bPropagatesToSubclass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_PropagatesToInstance(self: *const T, bPropagatesToInstance: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_PropagatesToInstance(@ptrCast(*const ISWbemQualifier, self), bPropagatesToInstance);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_put_PropagatesToInstance(self: *const T, bPropagatesToInstance: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).put_PropagatesToInstance(@ptrCast(*const ISWbemQualifier, self), bPropagatesToInstance);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_IsOverridable(self: *const T, bIsOverridable: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_IsOverridable(@ptrCast(*const ISWbemQualifier, self), bIsOverridable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_put_IsOverridable(self: *const T, bIsOverridable: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).put_IsOverridable(@ptrCast(*const ISWbemQualifier, self), bIsOverridable);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifier_get_IsAmended(self: *const T, bIsAmended: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifier.VTable, self.vtable).get_IsAmended(@ptrCast(*const ISWbemQualifier, self), bIsAmended);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemQualifierSet_Value = @import("../zig.zig").Guid.initString("9b16ed16-d3df-11d1-8b08-00600806d9b6");
pub const IID_ISWbemQualifierSet = &IID_ISWbemQualifierSet_Value;
pub const ISWbemQualifierSet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemQualifierSet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemQualifierSet,
name: ?BSTR,
iFlags: i32,
objWbemQualifier: ?*?*ISWbemQualifier,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemQualifierSet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const ISWbemQualifierSet,
strName: ?BSTR,
varVal: ?*VARIANT,
bPropagatesToSubclass: i16,
bPropagatesToInstance: i16,
bIsOverridable: i16,
iFlags: i32,
objWbemQualifier: ?*?*ISWbemQualifier,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemQualifierSet,
strName: ?BSTR,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifierSet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifierSet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemQualifierSet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifierSet_Item(self: *const T, name: ?BSTR, iFlags: i32, objWbemQualifier: ?*?*ISWbemQualifier) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifierSet.VTable, self.vtable).Item(@ptrCast(*const ISWbemQualifierSet, self), name, iFlags, objWbemQualifier);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifierSet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifierSet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemQualifierSet, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifierSet_Add(self: *const T, strName: ?BSTR, varVal: ?*VARIANT, bPropagatesToSubclass: i16, bPropagatesToInstance: i16, bIsOverridable: i16, iFlags: i32, objWbemQualifier: ?*?*ISWbemQualifier) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifierSet.VTable, self.vtable).Add(@ptrCast(*const ISWbemQualifierSet, self), strName, varVal, bPropagatesToSubclass, bPropagatesToInstance, bIsOverridable, iFlags, objWbemQualifier);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemQualifierSet_Remove(self: *const T, strName: ?BSTR, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemQualifierSet.VTable, self.vtable).Remove(@ptrCast(*const ISWbemQualifierSet, self), strName, iFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemProperty_Value = @import("../zig.zig").Guid.initString("1a388f98-d4ba-11d1-8b09-00600806d9b6");
pub const IID_ISWbemProperty = &IID_ISWbemProperty_Value;
pub const ISWbemProperty = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Value: fn(
self: *const ISWbemProperty,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Value: fn(
self: *const ISWbemProperty,
varValue: ?*VARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const ISWbemProperty,
strName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsLocal: fn(
self: *const ISWbemProperty,
bIsLocal: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Origin: fn(
self: *const ISWbemProperty,
strOrigin: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_CIMType: fn(
self: *const ISWbemProperty,
iCimType: ?*WbemCimtypeEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Qualifiers_: fn(
self: *const ISWbemProperty,
objWbemQualifierSet: ?*?*ISWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsArray: fn(
self: *const ISWbemProperty,
bIsArray: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_Value(@ptrCast(*const ISWbemProperty, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_put_Value(self: *const T, varValue: ?*VARIANT) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).put_Value(@ptrCast(*const ISWbemProperty, self), varValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_Name(self: *const T, strName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_Name(@ptrCast(*const ISWbemProperty, self), strName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_IsLocal(self: *const T, bIsLocal: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_IsLocal(@ptrCast(*const ISWbemProperty, self), bIsLocal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_Origin(self: *const T, strOrigin: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_Origin(@ptrCast(*const ISWbemProperty, self), strOrigin);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_CIMType(self: *const T, iCimType: ?*WbemCimtypeEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_CIMType(@ptrCast(*const ISWbemProperty, self), iCimType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_Qualifiers_(self: *const T, objWbemQualifierSet: ?*?*ISWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_Qualifiers_(@ptrCast(*const ISWbemProperty, self), objWbemQualifierSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemProperty_get_IsArray(self: *const T, bIsArray: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemProperty.VTable, self.vtable).get_IsArray(@ptrCast(*const ISWbemProperty, self), bIsArray);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemPropertySet_Value = @import("../zig.zig").Guid.initString("dea0a7b2-d4ba-11d1-8b09-00600806d9b6");
pub const IID_ISWbemPropertySet = &IID_ISWbemPropertySet_Value;
pub const ISWbemPropertySet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemPropertySet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemPropertySet,
strName: ?BSTR,
iFlags: i32,
objWbemProperty: ?*?*ISWbemProperty,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemPropertySet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const ISWbemPropertySet,
strName: ?BSTR,
iCIMType: WbemCimtypeEnum,
bIsArray: i16,
iFlags: i32,
objWbemProperty: ?*?*ISWbemProperty,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemPropertySet,
strName: ?BSTR,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPropertySet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPropertySet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemPropertySet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPropertySet_Item(self: *const T, strName: ?BSTR, iFlags: i32, objWbemProperty: ?*?*ISWbemProperty) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPropertySet.VTable, self.vtable).Item(@ptrCast(*const ISWbemPropertySet, self), strName, iFlags, objWbemProperty);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPropertySet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPropertySet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemPropertySet, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPropertySet_Add(self: *const T, strName: ?BSTR, iCIMType: WbemCimtypeEnum, bIsArray: i16, iFlags: i32, objWbemProperty: ?*?*ISWbemProperty) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPropertySet.VTable, self.vtable).Add(@ptrCast(*const ISWbemPropertySet, self), strName, iCIMType, bIsArray, iFlags, objWbemProperty);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPropertySet_Remove(self: *const T, strName: ?BSTR, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPropertySet.VTable, self.vtable).Remove(@ptrCast(*const ISWbemPropertySet, self), strName, iFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemMethod_Value = @import("../zig.zig").Guid.initString("422e8e90-d955-11d1-8b09-00600806d9b6");
pub const IID_ISWbemMethod = &IID_ISWbemMethod_Value;
pub const ISWbemMethod = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const ISWbemMethod,
strName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Origin: fn(
self: *const ISWbemMethod,
strOrigin: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_InParameters: fn(
self: *const ISWbemMethod,
objWbemInParameters: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_OutParameters: fn(
self: *const ISWbemMethod,
objWbemOutParameters: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Qualifiers_: fn(
self: *const ISWbemMethod,
objWbemQualifierSet: ?*?*ISWbemQualifierSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethod_get_Name(self: *const T, strName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethod.VTable, self.vtable).get_Name(@ptrCast(*const ISWbemMethod, self), strName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethod_get_Origin(self: *const T, strOrigin: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethod.VTable, self.vtable).get_Origin(@ptrCast(*const ISWbemMethod, self), strOrigin);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethod_get_InParameters(self: *const T, objWbemInParameters: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethod.VTable, self.vtable).get_InParameters(@ptrCast(*const ISWbemMethod, self), objWbemInParameters);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethod_get_OutParameters(self: *const T, objWbemOutParameters: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethod.VTable, self.vtable).get_OutParameters(@ptrCast(*const ISWbemMethod, self), objWbemOutParameters);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethod_get_Qualifiers_(self: *const T, objWbemQualifierSet: ?*?*ISWbemQualifierSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethod.VTable, self.vtable).get_Qualifiers_(@ptrCast(*const ISWbemMethod, self), objWbemQualifierSet);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemMethodSet_Value = @import("../zig.zig").Guid.initString("c93ba292-d955-11d1-8b09-00600806d9b6");
pub const IID_ISWbemMethodSet = &IID_ISWbemMethodSet_Value;
pub const ISWbemMethodSet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemMethodSet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemMethodSet,
strName: ?BSTR,
iFlags: i32,
objWbemMethod: ?*?*ISWbemMethod,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemMethodSet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethodSet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethodSet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemMethodSet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethodSet_Item(self: *const T, strName: ?BSTR, iFlags: i32, objWbemMethod: ?*?*ISWbemMethod) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethodSet.VTable, self.vtable).Item(@ptrCast(*const ISWbemMethodSet, self), strName, iFlags, objWbemMethod);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemMethodSet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemMethodSet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemMethodSet, self), iCount);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemEventSource_Value = @import("../zig.zig").Guid.initString("27d54d92-0ebe-11d2-8b22-00600806d9b6");
pub const IID_ISWbemEventSource = &IID_ISWbemEventSource_Value;
pub const ISWbemEventSource = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
NextEvent: fn(
self: *const ISWbemEventSource,
iTimeoutMs: i32,
objWbemObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemEventSource,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemEventSource_NextEvent(self: *const T, iTimeoutMs: i32, objWbemObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemEventSource.VTable, self.vtable).NextEvent(@ptrCast(*const ISWbemEventSource, self), iTimeoutMs, objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemEventSource_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemEventSource.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemEventSource, self), objWbemSecurity);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemObjectPath_Value = @import("../zig.zig").Guid.initString("5791bc27-ce9c-11d1-97bf-0000f81e849c");
pub const IID_ISWbemObjectPath = &IID_ISWbemObjectPath_Value;
pub const ISWbemObjectPath = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Path: fn(
self: *const ISWbemObjectPath,
strPath: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Path: fn(
self: *const ISWbemObjectPath,
strPath: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_RelPath: fn(
self: *const ISWbemObjectPath,
strRelPath: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_RelPath: fn(
self: *const ISWbemObjectPath,
strRelPath: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Server: fn(
self: *const ISWbemObjectPath,
strServer: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Server: fn(
self: *const ISWbemObjectPath,
strServer: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Namespace: fn(
self: *const ISWbemObjectPath,
strNamespace: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Namespace: fn(
self: *const ISWbemObjectPath,
strNamespace: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ParentNamespace: fn(
self: *const ISWbemObjectPath,
strParentNamespace: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_DisplayName: fn(
self: *const ISWbemObjectPath,
strDisplayName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_DisplayName: fn(
self: *const ISWbemObjectPath,
strDisplayName: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Class: fn(
self: *const ISWbemObjectPath,
strClass: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Class: fn(
self: *const ISWbemObjectPath,
strClass: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsClass: fn(
self: *const ISWbemObjectPath,
bIsClass: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAsClass: fn(
self: *const ISWbemObjectPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsSingleton: fn(
self: *const ISWbemObjectPath,
bIsSingleton: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetAsSingleton: fn(
self: *const ISWbemObjectPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Keys: fn(
self: *const ISWbemObjectPath,
objWbemNamedValueSet: ?*?*ISWbemNamedValueSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Security_: fn(
self: *const ISWbemObjectPath,
objWbemSecurity: ?*?*ISWbemSecurity,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Locale: fn(
self: *const ISWbemObjectPath,
strLocale: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Locale: fn(
self: *const ISWbemObjectPath,
strLocale: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Authority: fn(
self: *const ISWbemObjectPath,
strAuthority: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Authority: fn(
self: *const ISWbemObjectPath,
strAuthority: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Path(self: *const T, strPath: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Path(@ptrCast(*const ISWbemObjectPath, self), strPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Path(self: *const T, strPath: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Path(@ptrCast(*const ISWbemObjectPath, self), strPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_RelPath(self: *const T, strRelPath: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_RelPath(@ptrCast(*const ISWbemObjectPath, self), strRelPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_RelPath(self: *const T, strRelPath: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_RelPath(@ptrCast(*const ISWbemObjectPath, self), strRelPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Server(self: *const T, strServer: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Server(@ptrCast(*const ISWbemObjectPath, self), strServer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Server(self: *const T, strServer: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Server(@ptrCast(*const ISWbemObjectPath, self), strServer);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Namespace(self: *const T, strNamespace: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Namespace(@ptrCast(*const ISWbemObjectPath, self), strNamespace);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Namespace(self: *const T, strNamespace: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Namespace(@ptrCast(*const ISWbemObjectPath, self), strNamespace);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_ParentNamespace(self: *const T, strParentNamespace: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_ParentNamespace(@ptrCast(*const ISWbemObjectPath, self), strParentNamespace);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_DisplayName(self: *const T, strDisplayName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_DisplayName(@ptrCast(*const ISWbemObjectPath, self), strDisplayName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_DisplayName(self: *const T, strDisplayName: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_DisplayName(@ptrCast(*const ISWbemObjectPath, self), strDisplayName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Class(self: *const T, strClass: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Class(@ptrCast(*const ISWbemObjectPath, self), strClass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Class(self: *const T, strClass: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Class(@ptrCast(*const ISWbemObjectPath, self), strClass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_IsClass(self: *const T, bIsClass: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_IsClass(@ptrCast(*const ISWbemObjectPath, self), bIsClass);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_SetAsClass(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).SetAsClass(@ptrCast(*const ISWbemObjectPath, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_IsSingleton(self: *const T, bIsSingleton: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_IsSingleton(@ptrCast(*const ISWbemObjectPath, self), bIsSingleton);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_SetAsSingleton(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).SetAsSingleton(@ptrCast(*const ISWbemObjectPath, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Keys(self: *const T, objWbemNamedValueSet: ?*?*ISWbemNamedValueSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Keys(@ptrCast(*const ISWbemObjectPath, self), objWbemNamedValueSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Security_(self: *const T, objWbemSecurity: ?*?*ISWbemSecurity) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Security_(@ptrCast(*const ISWbemObjectPath, self), objWbemSecurity);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Locale(self: *const T, strLocale: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Locale(@ptrCast(*const ISWbemObjectPath, self), strLocale);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Locale(self: *const T, strLocale: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Locale(@ptrCast(*const ISWbemObjectPath, self), strLocale);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_get_Authority(self: *const T, strAuthority: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).get_Authority(@ptrCast(*const ISWbemObjectPath, self), strAuthority);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectPath_put_Authority(self: *const T, strAuthority: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectPath.VTable, self.vtable).put_Authority(@ptrCast(*const ISWbemObjectPath, self), strAuthority);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemLastError_Value = @import("../zig.zig").Guid.initString("d962db84-d4bb-11d1-8b09-00600806d9b6");
pub const IID_ISWbemLastError = &IID_ISWbemLastError_Value;
pub const ISWbemLastError = extern struct {
pub const VTable = extern struct {
base: ISWbemObject.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISWbemObject.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemSinkEvents_Value = @import("../zig.zig").Guid.initString("75718ca0-f029-11d1-a1ac-00c04fb6c223");
pub const IID_ISWbemSinkEvents = &IID_ISWbemSinkEvents_Value;
pub const ISWbemSinkEvents = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemSink_Value = @import("../zig.zig").Guid.initString("75718c9f-f029-11d1-a1ac-00c04fb6c223");
pub const IID_ISWbemSink = &IID_ISWbemSink_Value;
pub const ISWbemSink = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
Cancel: fn(
self: *const ISWbemSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSink_Cancel(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSink.VTable, self.vtable).Cancel(@ptrCast(*const ISWbemSink, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemSecurity_Value = @import("../zig.zig").Guid.initString("b54d66e6-2287-11d2-8b33-00600806d9b6");
pub const IID_ISWbemSecurity = &IID_ISWbemSecurity_Value;
pub const ISWbemSecurity = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ImpersonationLevel: fn(
self: *const ISWbemSecurity,
iImpersonationLevel: ?*WbemImpersonationLevelEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_ImpersonationLevel: fn(
self: *const ISWbemSecurity,
iImpersonationLevel: WbemImpersonationLevelEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AuthenticationLevel: fn(
self: *const ISWbemSecurity,
iAuthenticationLevel: ?*WbemAuthenticationLevelEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AuthenticationLevel: fn(
self: *const ISWbemSecurity,
iAuthenticationLevel: WbemAuthenticationLevelEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Privileges: fn(
self: *const ISWbemSecurity,
objWbemPrivilegeSet: ?*?*ISWbemPrivilegeSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSecurity_get_ImpersonationLevel(self: *const T, iImpersonationLevel: ?*WbemImpersonationLevelEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSecurity.VTable, self.vtable).get_ImpersonationLevel(@ptrCast(*const ISWbemSecurity, self), iImpersonationLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSecurity_put_ImpersonationLevel(self: *const T, iImpersonationLevel: WbemImpersonationLevelEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSecurity.VTable, self.vtable).put_ImpersonationLevel(@ptrCast(*const ISWbemSecurity, self), iImpersonationLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSecurity_get_AuthenticationLevel(self: *const T, iAuthenticationLevel: ?*WbemAuthenticationLevelEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSecurity.VTable, self.vtable).get_AuthenticationLevel(@ptrCast(*const ISWbemSecurity, self), iAuthenticationLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSecurity_put_AuthenticationLevel(self: *const T, iAuthenticationLevel: WbemAuthenticationLevelEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSecurity.VTable, self.vtable).put_AuthenticationLevel(@ptrCast(*const ISWbemSecurity, self), iAuthenticationLevel);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemSecurity_get_Privileges(self: *const T, objWbemPrivilegeSet: ?*?*ISWbemPrivilegeSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemSecurity.VTable, self.vtable).get_Privileges(@ptrCast(*const ISWbemSecurity, self), objWbemPrivilegeSet);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemPrivilege_Value = @import("../zig.zig").Guid.initString("26ee67bd-5804-11d2-8b4a-00600806d9b6");
pub const IID_ISWbemPrivilege = &IID_ISWbemPrivilege_Value;
pub const ISWbemPrivilege = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsEnabled: fn(
self: *const ISWbemPrivilege,
bIsEnabled: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_IsEnabled: fn(
self: *const ISWbemPrivilege,
bIsEnabled: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Name: fn(
self: *const ISWbemPrivilege,
strDisplayName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_DisplayName: fn(
self: *const ISWbemPrivilege,
strDisplayName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Identifier: fn(
self: *const ISWbemPrivilege,
iPrivilege: ?*WbemPrivilegeEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilege_get_IsEnabled(self: *const T, bIsEnabled: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilege.VTable, self.vtable).get_IsEnabled(@ptrCast(*const ISWbemPrivilege, self), bIsEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilege_put_IsEnabled(self: *const T, bIsEnabled: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilege.VTable, self.vtable).put_IsEnabled(@ptrCast(*const ISWbemPrivilege, self), bIsEnabled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilege_get_Name(self: *const T, strDisplayName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilege.VTable, self.vtable).get_Name(@ptrCast(*const ISWbemPrivilege, self), strDisplayName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilege_get_DisplayName(self: *const T, strDisplayName: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilege.VTable, self.vtable).get_DisplayName(@ptrCast(*const ISWbemPrivilege, self), strDisplayName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilege_get_Identifier(self: *const T, iPrivilege: ?*WbemPrivilegeEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilege.VTable, self.vtable).get_Identifier(@ptrCast(*const ISWbemPrivilege, self), iPrivilege);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemPrivilegeSet_Value = @import("../zig.zig").Guid.initString("26ee67bf-5804-11d2-8b4a-00600806d9b6");
pub const IID_ISWbemPrivilegeSet = &IID_ISWbemPrivilegeSet_Value;
pub const ISWbemPrivilegeSet = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemPrivilegeSet,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemPrivilegeSet,
iPrivilege: WbemPrivilegeEnum,
objWbemPrivilege: ?*?*ISWbemPrivilege,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemPrivilegeSet,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const ISWbemPrivilegeSet,
iPrivilege: WbemPrivilegeEnum,
bIsEnabled: i16,
objWbemPrivilege: ?*?*ISWbemPrivilege,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemPrivilegeSet,
iPrivilege: WbemPrivilegeEnum,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAll: fn(
self: *const ISWbemPrivilegeSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddAsString: fn(
self: *const ISWbemPrivilegeSet,
strPrivilege: ?BSTR,
bIsEnabled: i16,
objWbemPrivilege: ?*?*ISWbemPrivilege,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemPrivilegeSet, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_Item(self: *const T, iPrivilege: WbemPrivilegeEnum, objWbemPrivilege: ?*?*ISWbemPrivilege) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).Item(@ptrCast(*const ISWbemPrivilegeSet, self), iPrivilege, objWbemPrivilege);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemPrivilegeSet, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_Add(self: *const T, iPrivilege: WbemPrivilegeEnum, bIsEnabled: i16, objWbemPrivilege: ?*?*ISWbemPrivilege) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).Add(@ptrCast(*const ISWbemPrivilegeSet, self), iPrivilege, bIsEnabled, objWbemPrivilege);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_Remove(self: *const T, iPrivilege: WbemPrivilegeEnum) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).Remove(@ptrCast(*const ISWbemPrivilegeSet, self), iPrivilege);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_DeleteAll(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).DeleteAll(@ptrCast(*const ISWbemPrivilegeSet, self));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemPrivilegeSet_AddAsString(self: *const T, strPrivilege: ?BSTR, bIsEnabled: i16, objWbemPrivilege: ?*?*ISWbemPrivilege) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemPrivilegeSet.VTable, self.vtable).AddAsString(@ptrCast(*const ISWbemPrivilegeSet, self), strPrivilege, bIsEnabled, objWbemPrivilege);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemServicesEx_Value = @import("../zig.zig").Guid.initString("d2f68443-85dc-427e-91d8-366554cc754c");
pub const IID_ISWbemServicesEx = &IID_ISWbemServicesEx_Value;
pub const ISWbemServicesEx = extern struct {
pub const VTable = extern struct {
base: ISWbemServices.VTable,
Put: fn(
self: *const ISWbemServicesEx,
objWbemObject: ?*ISWbemObjectEx,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemObjectPath: ?*?*ISWbemObjectPath,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
PutAsync: fn(
self: *const ISWbemServicesEx,
objWbemSink: ?*ISWbemSink,
objWbemObject: ?*ISWbemObjectEx,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemAsyncContext: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISWbemServices.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServicesEx_Put(self: *const T, objWbemObject: ?*ISWbemObjectEx, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemObjectPath: ?*?*ISWbemObjectPath) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServicesEx.VTable, self.vtable).Put(@ptrCast(*const ISWbemServicesEx, self), objWbemObject, iFlags, objWbemNamedValueSet, objWbemObjectPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemServicesEx_PutAsync(self: *const T, objWbemSink: ?*ISWbemSink, objWbemObject: ?*ISWbemObjectEx, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemAsyncContext: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemServicesEx.VTable, self.vtable).PutAsync(@ptrCast(*const ISWbemServicesEx, self), objWbemSink, objWbemObject, iFlags, objWbemNamedValueSet, objWbemAsyncContext);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemObjectEx_Value = @import("../zig.zig").Guid.initString("269ad56a-8a67-4129-bc8c-0506dcfe9880");
pub const IID_ISWbemObjectEx = &IID_ISWbemObjectEx_Value;
pub const ISWbemObjectEx = extern struct {
pub const VTable = extern struct {
base: ISWbemObject.VTable,
Refresh_: fn(
self: *const ISWbemObjectEx,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_SystemProperties_: fn(
self: *const ISWbemObjectEx,
objWbemPropertySet: ?*?*ISWbemPropertySet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetText_: fn(
self: *const ISWbemObjectEx,
iObjectTextFormat: WbemObjectTextFormatEnum,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
bsText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetFromText_: fn(
self: *const ISWbemObjectEx,
bsText: ?BSTR,
iObjectTextFormat: WbemObjectTextFormatEnum,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace ISWbemObject.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectEx_Refresh_(self: *const T, iFlags: i32, objWbemNamedValueSet: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectEx.VTable, self.vtable).Refresh_(@ptrCast(*const ISWbemObjectEx, self), iFlags, objWbemNamedValueSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectEx_get_SystemProperties_(self: *const T, objWbemPropertySet: ?*?*ISWbemPropertySet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectEx.VTable, self.vtable).get_SystemProperties_(@ptrCast(*const ISWbemObjectEx, self), objWbemPropertySet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectEx_GetText_(self: *const T, iObjectTextFormat: WbemObjectTextFormatEnum, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, bsText: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectEx.VTable, self.vtable).GetText_(@ptrCast(*const ISWbemObjectEx, self), iObjectTextFormat, iFlags, objWbemNamedValueSet, bsText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemObjectEx_SetFromText_(self: *const T, bsText: ?BSTR, iObjectTextFormat: WbemObjectTextFormatEnum, iFlags: i32, objWbemNamedValueSet: ?*IDispatch) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemObjectEx.VTable, self.vtable).SetFromText_(@ptrCast(*const ISWbemObjectEx, self), bsText, iObjectTextFormat, iFlags, objWbemNamedValueSet);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemDateTime_Value = @import("../zig.zig").Guid.initString("5e97458a-cf77-11d3-b38f-00105a1f473a");
pub const IID_ISWbemDateTime = &IID_ISWbemDateTime_Value;
pub const ISWbemDateTime = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Value: fn(
self: *const ISWbemDateTime,
strValue: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Value: fn(
self: *const ISWbemDateTime,
strValue: ?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Year: fn(
self: *const ISWbemDateTime,
iYear: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Year: fn(
self: *const ISWbemDateTime,
iYear: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_YearSpecified: fn(
self: *const ISWbemDateTime,
bYearSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_YearSpecified: fn(
self: *const ISWbemDateTime,
bYearSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Month: fn(
self: *const ISWbemDateTime,
iMonth: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Month: fn(
self: *const ISWbemDateTime,
iMonth: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_MonthSpecified: fn(
self: *const ISWbemDateTime,
bMonthSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_MonthSpecified: fn(
self: *const ISWbemDateTime,
bMonthSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Day: fn(
self: *const ISWbemDateTime,
iDay: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Day: fn(
self: *const ISWbemDateTime,
iDay: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_DaySpecified: fn(
self: *const ISWbemDateTime,
bDaySpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_DaySpecified: fn(
self: *const ISWbemDateTime,
bDaySpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Hours: fn(
self: *const ISWbemDateTime,
iHours: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Hours: fn(
self: *const ISWbemDateTime,
iHours: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_HoursSpecified: fn(
self: *const ISWbemDateTime,
bHoursSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_HoursSpecified: fn(
self: *const ISWbemDateTime,
bHoursSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Minutes: fn(
self: *const ISWbemDateTime,
iMinutes: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Minutes: fn(
self: *const ISWbemDateTime,
iMinutes: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_MinutesSpecified: fn(
self: *const ISWbemDateTime,
bMinutesSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_MinutesSpecified: fn(
self: *const ISWbemDateTime,
bMinutesSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Seconds: fn(
self: *const ISWbemDateTime,
iSeconds: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Seconds: fn(
self: *const ISWbemDateTime,
iSeconds: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_SecondsSpecified: fn(
self: *const ISWbemDateTime,
bSecondsSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_SecondsSpecified: fn(
self: *const ISWbemDateTime,
bSecondsSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Microseconds: fn(
self: *const ISWbemDateTime,
iMicroseconds: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_Microseconds: fn(
self: *const ISWbemDateTime,
iMicroseconds: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_MicrosecondsSpecified: fn(
self: *const ISWbemDateTime,
bMicrosecondsSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_MicrosecondsSpecified: fn(
self: *const ISWbemDateTime,
bMicrosecondsSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_UTC: fn(
self: *const ISWbemDateTime,
iUTC: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_UTC: fn(
self: *const ISWbemDateTime,
iUTC: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_UTCSpecified: fn(
self: *const ISWbemDateTime,
bUTCSpecified: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_UTCSpecified: fn(
self: *const ISWbemDateTime,
bUTCSpecified: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsInterval: fn(
self: *const ISWbemDateTime,
bIsInterval: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_IsInterval: fn(
self: *const ISWbemDateTime,
bIsInterval: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetVarDate: fn(
self: *const ISWbemDateTime,
bIsLocal: i16,
dVarDate: ?*f64,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetVarDate: fn(
self: *const ISWbemDateTime,
dVarDate: f64,
bIsLocal: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetFileTime: fn(
self: *const ISWbemDateTime,
bIsLocal: i16,
strFileTime: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetFileTime: fn(
self: *const ISWbemDateTime,
strFileTime: ?BSTR,
bIsLocal: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Value(self: *const T, strValue: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Value(@ptrCast(*const ISWbemDateTime, self), strValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Value(self: *const T, strValue: ?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Value(@ptrCast(*const ISWbemDateTime, self), strValue);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Year(self: *const T, iYear: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Year(@ptrCast(*const ISWbemDateTime, self), iYear);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Year(self: *const T, iYear: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Year(@ptrCast(*const ISWbemDateTime, self), iYear);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_YearSpecified(self: *const T, bYearSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_YearSpecified(@ptrCast(*const ISWbemDateTime, self), bYearSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_YearSpecified(self: *const T, bYearSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_YearSpecified(@ptrCast(*const ISWbemDateTime, self), bYearSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Month(self: *const T, iMonth: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Month(@ptrCast(*const ISWbemDateTime, self), iMonth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Month(self: *const T, iMonth: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Month(@ptrCast(*const ISWbemDateTime, self), iMonth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_MonthSpecified(self: *const T, bMonthSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_MonthSpecified(@ptrCast(*const ISWbemDateTime, self), bMonthSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_MonthSpecified(self: *const T, bMonthSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_MonthSpecified(@ptrCast(*const ISWbemDateTime, self), bMonthSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Day(self: *const T, iDay: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Day(@ptrCast(*const ISWbemDateTime, self), iDay);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Day(self: *const T, iDay: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Day(@ptrCast(*const ISWbemDateTime, self), iDay);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_DaySpecified(self: *const T, bDaySpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_DaySpecified(@ptrCast(*const ISWbemDateTime, self), bDaySpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_DaySpecified(self: *const T, bDaySpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_DaySpecified(@ptrCast(*const ISWbemDateTime, self), bDaySpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Hours(self: *const T, iHours: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Hours(@ptrCast(*const ISWbemDateTime, self), iHours);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Hours(self: *const T, iHours: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Hours(@ptrCast(*const ISWbemDateTime, self), iHours);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_HoursSpecified(self: *const T, bHoursSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_HoursSpecified(@ptrCast(*const ISWbemDateTime, self), bHoursSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_HoursSpecified(self: *const T, bHoursSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_HoursSpecified(@ptrCast(*const ISWbemDateTime, self), bHoursSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Minutes(self: *const T, iMinutes: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Minutes(@ptrCast(*const ISWbemDateTime, self), iMinutes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Minutes(self: *const T, iMinutes: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Minutes(@ptrCast(*const ISWbemDateTime, self), iMinutes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_MinutesSpecified(self: *const T, bMinutesSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_MinutesSpecified(@ptrCast(*const ISWbemDateTime, self), bMinutesSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_MinutesSpecified(self: *const T, bMinutesSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_MinutesSpecified(@ptrCast(*const ISWbemDateTime, self), bMinutesSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Seconds(self: *const T, iSeconds: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Seconds(@ptrCast(*const ISWbemDateTime, self), iSeconds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Seconds(self: *const T, iSeconds: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Seconds(@ptrCast(*const ISWbemDateTime, self), iSeconds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_SecondsSpecified(self: *const T, bSecondsSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_SecondsSpecified(@ptrCast(*const ISWbemDateTime, self), bSecondsSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_SecondsSpecified(self: *const T, bSecondsSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_SecondsSpecified(@ptrCast(*const ISWbemDateTime, self), bSecondsSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_Microseconds(self: *const T, iMicroseconds: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_Microseconds(@ptrCast(*const ISWbemDateTime, self), iMicroseconds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_Microseconds(self: *const T, iMicroseconds: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_Microseconds(@ptrCast(*const ISWbemDateTime, self), iMicroseconds);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_MicrosecondsSpecified(self: *const T, bMicrosecondsSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_MicrosecondsSpecified(@ptrCast(*const ISWbemDateTime, self), bMicrosecondsSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_MicrosecondsSpecified(self: *const T, bMicrosecondsSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_MicrosecondsSpecified(@ptrCast(*const ISWbemDateTime, self), bMicrosecondsSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_UTC(self: *const T, iUTC: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_UTC(@ptrCast(*const ISWbemDateTime, self), iUTC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_UTC(self: *const T, iUTC: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_UTC(@ptrCast(*const ISWbemDateTime, self), iUTC);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_UTCSpecified(self: *const T, bUTCSpecified: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_UTCSpecified(@ptrCast(*const ISWbemDateTime, self), bUTCSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_UTCSpecified(self: *const T, bUTCSpecified: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_UTCSpecified(@ptrCast(*const ISWbemDateTime, self), bUTCSpecified);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_get_IsInterval(self: *const T, bIsInterval: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).get_IsInterval(@ptrCast(*const ISWbemDateTime, self), bIsInterval);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_put_IsInterval(self: *const T, bIsInterval: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).put_IsInterval(@ptrCast(*const ISWbemDateTime, self), bIsInterval);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_GetVarDate(self: *const T, bIsLocal: i16, dVarDate: ?*f64) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).GetVarDate(@ptrCast(*const ISWbemDateTime, self), bIsLocal, dVarDate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_SetVarDate(self: *const T, dVarDate: f64, bIsLocal: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).SetVarDate(@ptrCast(*const ISWbemDateTime, self), dVarDate, bIsLocal);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_GetFileTime(self: *const T, bIsLocal: i16, strFileTime: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).GetFileTime(@ptrCast(*const ISWbemDateTime, self), bIsLocal, strFileTime);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemDateTime_SetFileTime(self: *const T, strFileTime: ?BSTR, bIsLocal: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemDateTime.VTable, self.vtable).SetFileTime(@ptrCast(*const ISWbemDateTime, self), strFileTime, bIsLocal);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemRefresher_Value = @import("../zig.zig").Guid.initString("14d8250e-d9c2-11d3-b38f-00105a1f473a");
pub const IID_ISWbemRefresher = &IID_ISWbemRefresher_Value;
pub const ISWbemRefresher = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get__NewEnum: fn(
self: *const ISWbemRefresher,
pUnk: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Item: fn(
self: *const ISWbemRefresher,
iIndex: i32,
objWbemRefreshableItem: ?*?*ISWbemRefreshableItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Count: fn(
self: *const ISWbemRefresher,
iCount: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Add: fn(
self: *const ISWbemRefresher,
objWbemServices: ?*ISWbemServicesEx,
bsInstancePath: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemRefreshableItem: ?*?*ISWbemRefreshableItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
AddEnum: fn(
self: *const ISWbemRefresher,
objWbemServices: ?*ISWbemServicesEx,
bsClassName: ?BSTR,
iFlags: i32,
objWbemNamedValueSet: ?*IDispatch,
objWbemRefreshableItem: ?*?*ISWbemRefreshableItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemRefresher,
iIndex: i32,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Refresh: fn(
self: *const ISWbemRefresher,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_AutoReconnect: fn(
self: *const ISWbemRefresher,
bCount: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
put_AutoReconnect: fn(
self: *const ISWbemRefresher,
bCount: i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
DeleteAll: fn(
self: *const ISWbemRefresher,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_get__NewEnum(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).get__NewEnum(@ptrCast(*const ISWbemRefresher, self), pUnk);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_Item(self: *const T, iIndex: i32, objWbemRefreshableItem: ?*?*ISWbemRefreshableItem) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).Item(@ptrCast(*const ISWbemRefresher, self), iIndex, objWbemRefreshableItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_get_Count(self: *const T, iCount: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).get_Count(@ptrCast(*const ISWbemRefresher, self), iCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_Add(self: *const T, objWbemServices: ?*ISWbemServicesEx, bsInstancePath: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemRefreshableItem: ?*?*ISWbemRefreshableItem) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).Add(@ptrCast(*const ISWbemRefresher, self), objWbemServices, bsInstancePath, iFlags, objWbemNamedValueSet, objWbemRefreshableItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_AddEnum(self: *const T, objWbemServices: ?*ISWbemServicesEx, bsClassName: ?BSTR, iFlags: i32, objWbemNamedValueSet: ?*IDispatch, objWbemRefreshableItem: ?*?*ISWbemRefreshableItem) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).AddEnum(@ptrCast(*const ISWbemRefresher, self), objWbemServices, bsClassName, iFlags, objWbemNamedValueSet, objWbemRefreshableItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_Remove(self: *const T, iIndex: i32, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).Remove(@ptrCast(*const ISWbemRefresher, self), iIndex, iFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_Refresh(self: *const T, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).Refresh(@ptrCast(*const ISWbemRefresher, self), iFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_get_AutoReconnect(self: *const T, bCount: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).get_AutoReconnect(@ptrCast(*const ISWbemRefresher, self), bCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_put_AutoReconnect(self: *const T, bCount: i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).put_AutoReconnect(@ptrCast(*const ISWbemRefresher, self), bCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefresher_DeleteAll(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefresher.VTable, self.vtable).DeleteAll(@ptrCast(*const ISWbemRefresher, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_ISWbemRefreshableItem_Value = @import("../zig.zig").Guid.initString("5ad4bf92-daab-11d3-b38f-00105a1f473a");
pub const IID_ISWbemRefreshableItem = &IID_ISWbemRefreshableItem_Value;
pub const ISWbemRefreshableItem = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Index: fn(
self: *const ISWbemRefreshableItem,
iIndex: ?*i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Refresher: fn(
self: *const ISWbemRefreshableItem,
objWbemRefresher: ?*?*ISWbemRefresher,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_IsSet: fn(
self: *const ISWbemRefreshableItem,
bIsSet: ?*i16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_Object: fn(
self: *const ISWbemRefreshableItem,
objWbemObject: ?*?*ISWbemObjectEx,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_ObjectSet: fn(
self: *const ISWbemRefreshableItem,
objWbemObjectSet: ?*?*ISWbemObjectSet,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Remove: fn(
self: *const ISWbemRefreshableItem,
iFlags: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_get_Index(self: *const T, iIndex: ?*i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).get_Index(@ptrCast(*const ISWbemRefreshableItem, self), iIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_get_Refresher(self: *const T, objWbemRefresher: ?*?*ISWbemRefresher) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).get_Refresher(@ptrCast(*const ISWbemRefreshableItem, self), objWbemRefresher);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_get_IsSet(self: *const T, bIsSet: ?*i16) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).get_IsSet(@ptrCast(*const ISWbemRefreshableItem, self), bIsSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_get_Object(self: *const T, objWbemObject: ?*?*ISWbemObjectEx) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).get_Object(@ptrCast(*const ISWbemRefreshableItem, self), objWbemObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_get_ObjectSet(self: *const T, objWbemObjectSet: ?*?*ISWbemObjectSet) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).get_ObjectSet(@ptrCast(*const ISWbemRefreshableItem, self), objWbemObjectSet);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn ISWbemRefreshableItem_Remove(self: *const T, iFlags: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const ISWbemRefreshableItem.VTable, self.vtable).Remove(@ptrCast(*const ISWbemRefreshableItem, self), iFlags);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_WMIExtension_Value = @import("../zig.zig").Guid.initString("f0975afe-5c7f-11d2-8b74-00104b2afb41");
pub const CLSID_WMIExtension = &CLSID_WMIExtension_Value;
const IID_IWMIExtension_Value = @import("../zig.zig").Guid.initString("adc1f06e-5c7e-11d2-8b74-00104b2afb41");
pub const IID_IWMIExtension = &IID_IWMIExtension_Value;
pub const IWMIExtension = extern struct {
pub const VTable = extern struct {
base: IDispatch.VTable,
// TODO: this function has a "SpecialName", should Zig do anything with this?
get_WMIObjectPath: fn(
self: *const IWMIExtension,
strWMIObjectPath: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetWMIObject: fn(
self: *const IWMIExtension,
objWMIObject: ?*?*ISWbemObject,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
GetWMIServices: fn(
self: *const IWMIExtension,
objWMIServices: ?*?*ISWbemServices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IDispatch.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMIExtension_get_WMIObjectPath(self: *const T, strWMIObjectPath: ?*?BSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMIExtension.VTable, self.vtable).get_WMIObjectPath(@ptrCast(*const IWMIExtension, self), strWMIObjectPath);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMIExtension_GetWMIObject(self: *const T, objWMIObject: ?*?*ISWbemObject) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMIExtension.VTable, self.vtable).GetWMIObject(@ptrCast(*const IWMIExtension, self), objWMIObject);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWMIExtension_GetWMIServices(self: *const T, objWMIServices: ?*?*ISWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWMIExtension.VTable, self.vtable).GetWMIServices(@ptrCast(*const IWMIExtension, self), objWMIServices);
}
};}
pub usingnamespace MethodMixin(@This());
};
const CLSID_WbemLevel1Login_Value = @import("../zig.zig").Guid.initString("8bc3f05e-d86b-11d0-a075-00c04fb68820");
pub const CLSID_WbemLevel1Login = &CLSID_WbemLevel1Login_Value;
const CLSID_WbemLocalAddrRes_Value = @import("../zig.zig").Guid.initString("a1044801-8f7e-11d1-9e7c-00c04fc324a8");
pub const CLSID_WbemLocalAddrRes = &CLSID_WbemLocalAddrRes_Value;
const CLSID_WbemUninitializedClassObject_Value = @import("../zig.zig").Guid.initString("7a0227f6-7108-11d1-ad90-00c04fd8fdff");
pub const CLSID_WbemUninitializedClassObject = &CLSID_WbemUninitializedClassObject_Value;
const CLSID_WbemDCOMTransport_Value = @import("../zig.zig").Guid.initString("f7ce2e13-8c90-11d1-9e7b-00c04fc324a8");
pub const CLSID_WbemDCOMTransport = &CLSID_WbemDCOMTransport_Value;
pub const tag_WBEM_LOGIN_TYPE = enum(i32) {
FLAG_INPROC_LOGIN = 0,
FLAG_LOCAL_LOGIN = 1,
FLAG_REMOTE_LOGIN = 2,
AUTHENTICATION_METHOD_MASK = 15,
FLAG_USE_MULTIPLE_CHALLENGES = 16,
};
pub const WBEM_FLAG_INPROC_LOGIN = tag_WBEM_LOGIN_TYPE.FLAG_INPROC_LOGIN;
pub const WBEM_FLAG_LOCAL_LOGIN = tag_WBEM_LOGIN_TYPE.FLAG_LOCAL_LOGIN;
pub const WBEM_FLAG_REMOTE_LOGIN = tag_WBEM_LOGIN_TYPE.FLAG_REMOTE_LOGIN;
pub const WBEM_AUTHENTICATION_METHOD_MASK = tag_WBEM_LOGIN_TYPE.AUTHENTICATION_METHOD_MASK;
pub const WBEM_FLAG_USE_MULTIPLE_CHALLENGES = tag_WBEM_LOGIN_TYPE.FLAG_USE_MULTIPLE_CHALLENGES;
const IID_IWbemTransport_Value = @import("../zig.zig").Guid.initString("553fe584-2156-11d0-b6ae-00aa003240c7");
pub const IID_IWbemTransport = &IID_IWbemTransport_Value;
pub const IWbemTransport = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: fn(
self: *const IWbemTransport,
) 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 IWbemTransport_Initialize(self: *const T) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemTransport.VTable, self.vtable).Initialize(@ptrCast(*const IWbemTransport, self));
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemLevel1Login_Value = @import("../zig.zig").Guid.initString("f309ad18-d86a-11d0-a075-00c04fb68820");
pub const IID_IWbemLevel1Login = &IID_IWbemLevel1Login_Value;
pub const IWbemLevel1Login = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
EstablishPosition: fn(
self: *const IWbemLevel1Login,
wszLocaleList: ?PWSTR,
dwNumLocales: u32,
reserved: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
RequestChallenge: fn(
self: *const IWbemLevel1Login,
wszNetworkResource: ?PWSTR,
wszUser: ?PWSTR,
Nonce: ?*u8,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
WBEMLogin: fn(
self: *const IWbemLevel1Login,
wszPreferredLocale: ?PWSTR,
AccessToken: ?*u8,
lFlags: i32,
pCtx: ?*IWbemContext,
ppNamespace: ?*?*IWbemServices,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
NTLMLogin: fn(
self: *const IWbemLevel1Login,
wszNetworkResource: ?PWSTR,
wszPreferredLocale: ?PWSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
ppNamespace: ?*?*IWbemServices,
) 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 IWbemLevel1Login_EstablishPosition(self: *const T, wszLocaleList: ?PWSTR, dwNumLocales: u32, reserved: ?*u32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemLevel1Login.VTable, self.vtable).EstablishPosition(@ptrCast(*const IWbemLevel1Login, self), wszLocaleList, dwNumLocales, reserved);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemLevel1Login_RequestChallenge(self: *const T, wszNetworkResource: ?PWSTR, wszUser: ?PWSTR, Nonce: ?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemLevel1Login.VTable, self.vtable).RequestChallenge(@ptrCast(*const IWbemLevel1Login, self), wszNetworkResource, wszUser, Nonce);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemLevel1Login_WBEMLogin(self: *const T, wszPreferredLocale: ?PWSTR, AccessToken: ?*u8, lFlags: i32, pCtx: ?*IWbemContext, ppNamespace: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemLevel1Login.VTable, self.vtable).WBEMLogin(@ptrCast(*const IWbemLevel1Login, self), wszPreferredLocale, AccessToken, lFlags, pCtx, ppNamespace);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemLevel1Login_NTLMLogin(self: *const T, wszNetworkResource: ?PWSTR, wszPreferredLocale: ?PWSTR, lFlags: i32, pCtx: ?*IWbemContext, ppNamespace: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemLevel1Login.VTable, self.vtable).NTLMLogin(@ptrCast(*const IWbemLevel1Login, self), wszNetworkResource, wszPreferredLocale, lFlags, pCtx, ppNamespace);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemConnectorLogin_Value = @import("../zig.zig").Guid.initString("d8ec9cb1-b135-4f10-8b1b-c7188bb0d186");
pub const IID_IWbemConnectorLogin = &IID_IWbemConnectorLogin_Value;
pub const IWbemConnectorLogin = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ConnectorLogin: fn(
self: *const IWbemConnectorLogin,
wszNetworkResource: ?PWSTR,
wszPreferredLocale: ?PWSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
riid: ?*const Guid,
pInterface: ?*?*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 IWbemConnectorLogin_ConnectorLogin(self: *const T, wszNetworkResource: ?PWSTR, wszPreferredLocale: ?PWSTR, lFlags: i32, pCtx: ?*IWbemContext, riid: ?*const Guid, pInterface: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConnectorLogin.VTable, self.vtable).ConnectorLogin(@ptrCast(*const IWbemConnectorLogin, self), wszNetworkResource, wszPreferredLocale, lFlags, pCtx, riid, pInterface);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemAddressResolution_Value = @import("../zig.zig").Guid.initString("f7ce2e12-8c90-11d1-9e7b-00c04fc324a8");
pub const IID_IWbemAddressResolution = &IID_IWbemAddressResolution_Value;
pub const IWbemAddressResolution = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Resolve: fn(
self: *const IWbemAddressResolution,
wszNamespacePath: ?PWSTR,
wszAddressType: ?PWSTR,
pdwAddressLength: ?*u32,
pabBinaryAddress: ?*?*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 IWbemAddressResolution_Resolve(self: *const T, wszNamespacePath: ?PWSTR, wszAddressType: ?PWSTR, pdwAddressLength: ?*u32, pabBinaryAddress: ?*?*u8) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemAddressResolution.VTable, self.vtable).Resolve(@ptrCast(*const IWbemAddressResolution, self), wszNamespacePath, wszAddressType, pdwAddressLength, pabBinaryAddress);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemClientTransport_Value = @import("../zig.zig").Guid.initString("f7ce2e11-8c90-11d1-9e7b-00c04fc324a8");
pub const IID_IWbemClientTransport = &IID_IWbemClientTransport_Value;
pub const IWbemClientTransport = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
ConnectServer: fn(
self: *const IWbemClientTransport,
strAddressType: ?BSTR,
dwBinaryAddressLength: u32,
abBinaryAddress: [*:0]u8,
strNetworkResource: ?BSTR,
strUser: ?BSTR,
strPassword: ?<PASSWORD>,
strLocale: ?BSTR,
lSecurityFlags: i32,
strAuthority: ?BSTR,
pCtx: ?*IWbemContext,
ppNamespace: ?*?*IWbemServices,
) 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 IWbemClientTransport_ConnectServer(self: *const T, strAddressType: ?BSTR, dwBinaryAddressLength: u32, abBinaryAddress: [*:0]u8, strNetworkResource: ?BSTR, strUser: ?BSTR, strPassword: ?BSTR, strLocale: ?BSTR, lSecurityFlags: i32, strAuthority: ?BSTR, pCtx: ?*IWbemContext, ppNamespace: ?*?*IWbemServices) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClientTransport.VTable, self.vtable).ConnectServer(@ptrCast(*const IWbemClientTransport, self), strAddressType, dwBinaryAddressLength, abBinaryAddress, strNetworkResource, strUser, strPassword, strLocale, lSecurityFlags, strAuthority, pCtx, ppNamespace);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemClientConnectionTransport_Value = @import("../zig.zig").Guid.initString("a889c72a-fcc1-4a9e-af61-ed071333fb5b");
pub const IID_IWbemClientConnectionTransport = &IID_IWbemClientConnectionTransport_Value;
pub const IWbemClientConnectionTransport = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Open: fn(
self: *const IWbemClientConnectionTransport,
strAddressType: ?BSTR,
dwBinaryAddressLength: u32,
abBinaryAddress: [*:0]u8,
strObject: ?BSTR,
strUser: ?BSTR,
strPassword: ?BSTR,
strLocale: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
riid: ?*const Guid,
pInterface: ?*?*anyopaque,
pCallRes: ?*?*IWbemCallResult,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
OpenAsync: fn(
self: *const IWbemClientConnectionTransport,
strAddressType: ?BSTR,
dwBinaryAddressLength: u32,
abBinaryAddress: [*:0]u8,
strObject: ?BSTR,
strUser: ?BSTR,
strPassword: ?BSTR,
strLocale: ?BSTR,
lFlags: i32,
pCtx: ?*IWbemContext,
riid: ?*const Guid,
pResponseHandler: ?*IWbemObjectSink,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
Cancel: fn(
self: *const IWbemClientConnectionTransport,
lFlags: i32,
pHandler: ?*IWbemObjectSink,
) 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 IWbemClientConnectionTransport_Open(self: *const T, strAddressType: ?BSTR, dwBinaryAddressLength: u32, abBinaryAddress: [*:0]u8, strObject: ?BSTR, strUser: ?BSTR, strPassword: ?BSTR, strLocale: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, riid: ?*const Guid, pInterface: ?*?*anyopaque, pCallRes: ?*?*IWbemCallResult) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClientConnectionTransport.VTable, self.vtable).Open(@ptrCast(*const IWbemClientConnectionTransport, self), strAddressType, dwBinaryAddressLength, abBinaryAddress, strObject, strUser, strPassword, strLocale, lFlags, pCtx, riid, pInterface, pCallRes);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClientConnectionTransport_OpenAsync(self: *const T, strAddressType: ?BSTR, dwBinaryAddressLength: u32, abBinaryAddress: [*:0]u8, strObject: ?BSTR, strUser: ?BSTR, strPassword: ?BSTR, strLocale: ?BSTR, lFlags: i32, pCtx: ?*IWbemContext, riid: ?*const Guid, pResponseHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClientConnectionTransport.VTable, self.vtable).OpenAsync(@ptrCast(*const IWbemClientConnectionTransport, self), strAddressType, dwBinaryAddressLength, abBinaryAddress, strObject, strUser, strPassword, strLocale, lFlags, pCtx, riid, pResponseHandler);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemClientConnectionTransport_Cancel(self: *const T, lFlags: i32, pHandler: ?*IWbemObjectSink) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemClientConnectionTransport.VTable, self.vtable).Cancel(@ptrCast(*const IWbemClientConnectionTransport, self), lFlags, pHandler);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IWbemConstructClassObject_Value = @import("../zig.zig").Guid.initString("9ef76194-70d5-11d1-ad90-00c04fd8fdff");
pub const IID_IWbemConstructClassObject = &IID_IWbemConstructClassObject_Value;
pub const IWbemConstructClassObject = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetInheritanceChain: fn(
self: *const IWbemConstructClassObject,
lNumAntecedents: i32,
// TODO: what to do with BytesParamIndex 0?
awszAntecedents: ?*?PWSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetPropertyOrigin: fn(
self: *const IWbemConstructClassObject,
wszPropertyName: ?[*:0]const u16,
lOriginIndex: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetMethodOrigin: fn(
self: *const IWbemConstructClassObject,
wszMethodName: ?[*:0]const u16,
lOriginIndex: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
SetServerNamespace: fn(
self: *const IWbemConstructClassObject,
wszServer: ?[*:0]const u16,
wszNamespace: ?[*: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 IWbemConstructClassObject_SetInheritanceChain(self: *const T, lNumAntecedents: i32, awszAntecedents: ?*?PWSTR) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConstructClassObject.VTable, self.vtable).SetInheritanceChain(@ptrCast(*const IWbemConstructClassObject, self), lNumAntecedents, awszAntecedents);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConstructClassObject_SetPropertyOrigin(self: *const T, wszPropertyName: ?[*:0]const u16, lOriginIndex: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConstructClassObject.VTable, self.vtable).SetPropertyOrigin(@ptrCast(*const IWbemConstructClassObject, self), wszPropertyName, lOriginIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConstructClassObject_SetMethodOrigin(self: *const T, wszMethodName: ?[*:0]const u16, lOriginIndex: i32) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConstructClassObject.VTable, self.vtable).SetMethodOrigin(@ptrCast(*const IWbemConstructClassObject, self), wszMethodName, lOriginIndex);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IWbemConstructClassObject_SetServerNamespace(self: *const T, wszServer: ?[*:0]const u16, wszNamespace: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @ptrCast(*const IWbemConstructClassObject.VTable, self.vtable).SetServerNamespace(@ptrCast(*const IWbemConstructClassObject, self), wszServer, wszNamespace);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (1)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows8.0'
pub extern "mi" fn MI_Application_InitializeV1(
flags: u32,
applicationID: ?*const u16,
extendedError: ?*?*MI_Instance,
application: ?*MI_Application,
) callconv(@import("std").os.windows.WINAPI) MI_Result;
//--------------------------------------------------------------------------------
// 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 BSTR = @import("../foundation.zig").BSTR;
const HRESULT = @import("../foundation.zig").HRESULT;
const IDispatch = @import("../system/com.zig").IDispatch;
const IUnknown = @import("../system/com.zig").IUnknown;
const PWSTR = @import("../foundation.zig").PWSTR;
const SAFEARRAY = @import("../system/com.zig").SAFEARRAY;
const VARIANT = @import("../system/com.zig").VARIANT;
test {
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
if (@hasDecl(@This(), "MI_MethodDecl_Invoke")) { _ = MI_MethodDecl_Invoke; }
if (@hasDecl(@This(), "MI_ProviderFT_Load")) { _ = MI_ProviderFT_Load; }
if (@hasDecl(@This(), "MI_ProviderFT_Unload")) { _ = MI_ProviderFT_Unload; }
if (@hasDecl(@This(), "MI_ProviderFT_GetInstance")) { _ = MI_ProviderFT_GetInstance; }
if (@hasDecl(@This(), "MI_ProviderFT_EnumerateInstances")) { _ = MI_ProviderFT_EnumerateInstances; }
if (@hasDecl(@This(), "MI_ProviderFT_CreateInstance")) { _ = MI_ProviderFT_CreateInstance; }
if (@hasDecl(@This(), "MI_ProviderFT_ModifyInstance")) { _ = MI_ProviderFT_ModifyInstance; }
if (@hasDecl(@This(), "MI_ProviderFT_DeleteInstance")) { _ = MI_ProviderFT_DeleteInstance; }
if (@hasDecl(@This(), "MI_ProviderFT_AssociatorInstances")) { _ = MI_ProviderFT_AssociatorInstances; }
if (@hasDecl(@This(), "MI_ProviderFT_ReferenceInstances")) { _ = MI_ProviderFT_ReferenceInstances; }
if (@hasDecl(@This(), "MI_ProviderFT_EnableIndications")) { _ = MI_ProviderFT_EnableIndications; }
if (@hasDecl(@This(), "MI_ProviderFT_DisableIndications")) { _ = MI_ProviderFT_DisableIndications; }
if (@hasDecl(@This(), "MI_ProviderFT_Subscribe")) { _ = MI_ProviderFT_Subscribe; }
if (@hasDecl(@This(), "MI_ProviderFT_Unsubscribe")) { _ = MI_ProviderFT_Unsubscribe; }
if (@hasDecl(@This(), "MI_ProviderFT_Invoke")) { _ = MI_ProviderFT_Invoke; }
if (@hasDecl(@This(), "MI_Module_Load")) { _ = MI_Module_Load; }
if (@hasDecl(@This(), "MI_Module_Unload")) { _ = MI_Module_Unload; }
if (@hasDecl(@This(), "MI_CancelCallback")) { _ = MI_CancelCallback; }
if (@hasDecl(@This(), "MI_MainFunction")) { _ = MI_MainFunction; }
if (@hasDecl(@This(), "MI_OperationCallback_PromptUser")) { _ = MI_OperationCallback_PromptUser; }
if (@hasDecl(@This(), "MI_OperationCallback_WriteError")) { _ = MI_OperationCallback_WriteError; }
if (@hasDecl(@This(), "MI_OperationCallback_WriteMessage")) { _ = MI_OperationCallback_WriteMessage; }
if (@hasDecl(@This(), "MI_OperationCallback_WriteProgress")) { _ = MI_OperationCallback_WriteProgress; }
if (@hasDecl(@This(), "MI_OperationCallback_Instance")) { _ = MI_OperationCallback_Instance; }
if (@hasDecl(@This(), "MI_OperationCallback_StreamedParameter")) { _ = MI_OperationCallback_StreamedParameter; }
if (@hasDecl(@This(), "MI_OperationCallback_Indication")) { _ = MI_OperationCallback_Indication; }
if (@hasDecl(@This(), "MI_OperationCallback_Class")) { _ = MI_OperationCallback_Class; }
if (@hasDecl(@This(), "MI_Deserializer_ClassObjectNeeded")) { _ = MI_Deserializer_ClassObjectNeeded; }
@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/system/wmi.zig |
const std = @import("std");
const assert = std.debug.assert;
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var input_file = try std.fs.cwd().openFile("input/04.txt", .{});
defer input_file.close();
var buffered_reader = std.io.bufferedReader(input_file.reader());
const score = try calculateWinningScore(allocator, buffered_reader.reader());
std.debug.print("winning score: {}\n", .{score});
}
// Maps number -> position
const Board = std.AutoHashMap(u64, u64);
fn won(game_board: u25) bool {
const winning_positions = [_]u25{
0b11111_00000_00000_00000_00000,
0b00000_11111_00000_00000_00000,
0b00000_00000_11111_00000_00000,
0b00000_00000_00000_11111_00000,
0b00000_00000_00000_00000_11111,
0b10000_10000_10000_10000_10000,
0b01000_01000_01000_01000_01000,
0b00100_00100_00100_00100_00100,
0b00010_00010_00010_00010_00010,
0b00001_00001_00001_00001_00001,
};
return for (winning_positions) |pos| {
if (game_board & pos == pos) break true;
} else false;
}
fn sumUnmarkedNumbers(board: Board, game_board: u25) u64 {
var sum: u64 = 0;
var pos: u5 = 0;
while (pos < 25) : (pos += 1) {
if (game_board & (@as(u25, 1) << pos) == 0) {
var iter = board.iterator();
while (iter.next()) |entry| {
if (entry.value_ptr.* == pos) {
sum += entry.key_ptr.*;
}
}
}
}
return sum;
}
fn calculateWinningScore(gpa: std.mem.Allocator, reader: anytype) !u64 {
var arena = std.heap.ArenaAllocator.init(gpa);
defer arena.deinit();
const allocator = arena.allocator();
var buf: [1024]u8 = undefined;
var numbers_drawn = std.ArrayList(u64).init(allocator);
var boards = std.ArrayList(Board).init(allocator);
// Read all numbers
{
const line = (try reader.readUntilDelimiterOrEof(&buf, '\n')) orelse return error.MissingData;
var iter = std.mem.split(u8, line, ",");
while (iter.next()) |number| {
try numbers_drawn.append(try std.fmt.parseInt(u64, number, 10));
}
}
// Read all boards
while (try reader.readUntilDelimiterOrEof(&buf, '\n')) |empty_line| {
if (empty_line.len != 0) return error.WrongFormat;
const board = try boards.addOne();
board.* = Board.init(allocator);
var i: usize = 0;
while (i < 5) : (i += 1) {
const line = (try reader.readUntilDelimiterOrEof(&buf, '\n')) orelse return error.MissingData;
var j: usize = 0;
var iter = std.mem.tokenize(u8, line, " ");
while (iter.next()) |number| : (j += 1) {
try board.put(try std.fmt.parseInt(u64, number, 10), i * 5 + j);
}
if (j != 5) return error.WrongFormat;
}
assert(board.count() == 25);
}
// Pick all numbers
var game_boards = try allocator.alloc(u25, boards.items.len);
for (game_boards) |*x| x.* = 0;
for (numbers_drawn.items) |number| {
for (boards.items) |board, i| {
if (board.get(number)) |pos| {
game_boards[i] |= (@as(u25, 1) << @intCast(u5, pos));
}
if (won(game_boards[i])) {
return sumUnmarkedNumbers(board, game_boards[i]) * number;
}
}
}
return error.NoBoardWins;
}
test "example 1" {
const text =
\\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 fbs = std.io.fixedBufferStream(text);
const score = try calculateWinningScore(std.testing.allocator, fbs.reader());
try std.testing.expectEqual(@as(u64, 4512), score);
} | src/04.zig |
const std = @import("std");
const w4 = @import("wasm4.zig");
const world = @import("world.zig");
const Player = @import("Player.zig");
const Obstacle = @import("Obstacle.zig");
const GameState = enum { title, running, game_over };
//Allocator for printing score
var buffer: [5]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buffer);
const allocator = fba.allocator();
var prng: std.rand.DefaultPrng = undefined;
var random: std.rand.Random = undefined;
var frame_count: u32 = 0;
var player: Player = undefined;
var obstacles: std.BoundedArray(Obstacle, 40) = undefined;
var prev_state: u8 = 0;
var current_game_state: GameState = undefined;
var score: u32 = 0;
export fn start() void {
w4.PALETTE.* = .{
0xe0f8cf,
0xe5b083,
0x306850,
0x071821,
};
current_game_state = .title;
}
fn startGame() void {
prng = std.rand.DefaultPrng.init(frame_count);
random = prng.random();
score = 0;
player = Player.init();
obstacles = std.BoundedArray(Obstacle, 40).init(0) catch @panic("couldn't init obstacles array");
var obstacle = Obstacle{.x = 120};
obstacles.append(obstacle) catch @panic("couldn't append obstacle");
current_game_state = .running;
}
export fn update() void {
frame_count +%= 1;
processInput();
if (current_game_state == .running) {
player.update();
updateObstacles();
if (findCollision()) {
current_game_state = .game_over;
player.hitObstacle();
w4.tone(620 | (140 << 16), (10 << 24) | 24, 100, w4.TONE_MODE2);
}
if (frame_count % 60 == 0) score += 1;
}
draw();
}
fn processInput() void {
const gamepad = w4.GAMEPAD1.*;
const just_pressed = gamepad & (gamepad ^ prev_state);
if (current_game_state == .running and just_pressed & w4.BUTTON_UP != 0) {
player.jump();
}
if ((current_game_state == .title and just_pressed != 0) or (current_game_state == .game_over and just_pressed & (w4.BUTTON_1 | w4.BUTTON_2) != 0)) {
startGame();
}
prev_state = gamepad;
}
fn updateObstacles() void {
if (frame_count % 2 == 0) {
for (obstacles.slice()) |*obstacle| {
obstacle.updatePosition();
}
}
for (obstacles.constSlice()) |*obstacle| {
if (obstacle.x <= -9) {
_ = obstacles.orderedRemove(0);
}
}
handleObstacleSpawning();
}
fn handleObstacleSpawning() void {
if (frame_count % 40 == 0) {
if (random.intRangeLessThan(u8, 0, 100) <= 30) {
var obstacle = Obstacle.spawn();
obstacles.append(obstacle) catch @panic("couldn't append obstacle");
}
}
}
fn findCollision() bool {
const obstacle = fetchClosestObstacle();
if (obstacle == null) return false;
const x_interlap = std.math.absInt(obstacle.?.x - player.x) catch @panic("int overflow");
const y_interlap = std.math.absInt(player.y - world.ground_level) catch @panic("int overflow");
if (x_interlap < 8 and y_interlap < 8) return true;
return false;
}
fn fetchClosestObstacle() ?Obstacle {
for (obstacles.constSlice()) |obstacle| {
if (obstacle.x >= player.x) return obstacle;
}
return null;
}
fn draw() void {
if (current_game_state == .title) {
drawTitle();
}
if (current_game_state != .title) {
world.drawGround();
drawScore();
drawObstacles();
player.draw();
if (current_game_state == .game_over) {
drawGameOver();
}
}
}
fn drawTitle() void {
w4.DRAW_COLORS.* = 0x0004;
w4.text("Press UP button", 15, 50);
w4.text("to start", 45, 60);
}
fn drawObstacles() void {
w4.DRAW_COLORS.* = 0x3;
for (obstacles.constSlice()) |obstacle| {
obstacle.draw();
}
}
fn drawScore() void {
w4.DRAW_COLORS.* = 0x0004;
w4.text("Score:", 80, 1);
const score_string = std.fmt.allocPrint(
allocator,
"{d}",
.{score},
) catch @panic("can't print score");
defer allocator.free(score_string);
w4.text(score_string, 130, 1);
}
fn drawGameOver() void {
w4.DRAW_COLORS.* = 0x0044;
w4.rect(0, 20, 160, 30);
w4.DRAW_COLORS.* = 0x0001;
w4.text("Game Over", 45, 30);
} | src/main.zig |
const std = @import("std");
const deps = @import("./deps.zig");
const Benchmark = struct {
name: []const u8,
path: []const u8,
};
const BENCHMARKS = [_]Benchmark{
.{ .name = "insert_random_check_balance", .path = "./benchmark/insert_random_check_balance.zig" },
};
const tracy_dummy = std.build.Pkg{
.name = "tracy",
.path = .{ .path = "src/tracy_dummy.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 exe = b.addExecutable("fetch-rewards-be-coding-exercise", "src/main.zig");
exe.setTarget(target);
exe.setBuildMode(mode);
exe.install();
exe.addPackage(deps.pkgs.apple_pie.pkg.?);
exe.addPackage(deps.pkgs.chrono.pkg.?);
exe.addPackage(tracy_dummy);
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 coverage = b.option(bool, "test-coverage", "Generate test coverage with kcov (supports linux)") orelse false;
const tests = b.addTest("src/main.zig");
tests.setTarget(target);
tests.addPackage(deps.pkgs.apple_pie.pkg.?);
tests.addPackage(deps.pkgs.chrono.pkg.?);
tests.addPackage(tracy_dummy);
if (coverage) {
tests.setExecCmd(&[_]?[]const u8{
"kcov",
"--exclude-pattern=lib/std,.zigmod",
"kcov-output",
null,
});
}
const test_step = b.step("test", "Run the app's tests");
test_step.dependOn(&tests.step);
const benchmark_target = if (!target.isGnuLibC()) target else glib_2_18_target: {
var b_target = target;
b_target.glibc_version = std.builtin.Version{ .major = 2, .minor = 18 };
break :glib_2_18_target b_target;
};
inline for (BENCHMARKS) |benchmark| {
const bench_exe = b.addExecutable(benchmark.name, benchmark.path);
bench_exe.setTarget(benchmark_target);
bench_exe.setBuildMode(mode);
deps.addAllTo(bench_exe);
bench_exe.addPackage(.{
.name = "fetch-rewards-be-coding-exercise",
.path = .{ .path = "src/main.zig" },
.dependencies = &[_]std.build.Pkg{
deps.pkgs.apple_pie.pkg.?,
deps.pkgs.chrono.pkg.?,
deps.pkgs.tracy.pkg.?,
},
});
const bench_run_cmd = bench_exe.run();
bench_run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| {
bench_run_cmd.addArgs(args);
}
const bench_run_step = b.step("run-" ++ benchmark.name, "Run the " ++ benchmark.name ++ " benchmark");
bench_run_step.dependOn(&bench_run_cmd.step);
}
} | build.zig |
const std = @import("std");
const sliceAsBytes = std.mem.sliceAsBytes;
const utils = @import("utils");
const kernel = @import("root").kernel;
const memory = kernel.memory;
const RealMemoryMap = memory.RealMemoryMap;
const AllocError = memory.AllocError;
const FreeError = memory.FreeError;
const Range = memory.Range;
const print = kernel.print;
const platform = @import("platform.zig");
pub const frame_size = utils.Ki(4);
pub const page_size = frame_size;
const pages_per_table = utils.Ki(1);
const table_pages_size = page_size * pages_per_table;
const tables_per_directory = utils.Ki(1);
const table_size = @sizeOf(u32) * pages_per_table;
export var active_page_directory: [tables_per_directory]u32
align(frame_size) linksection(".data") = undefined;
export var kernel_page_tables: []u32 = undefined;
pub export var kernel_range_start_available: u32 = undefined;
export var kernel_page_table_count: u32 = 0;
extern var _VIRTUAL_LOW_START: u32;
pub fn get_address(dir_index: usize, table_index: usize) callconv(.Inline) usize {
return dir_index * table_pages_size + table_index * page_size;
}
// Page Directory Operations
pub fn get_directory_index(address: u32) callconv(.Inline) u32 {
return (address & 0xffc00000) >> 22;
}
extern var _VIRTUAL_OFFSET: u32;
pub fn get_kernel_space_start_directory_index() callconv(.Inline) u32 {
return get_directory_index(@ptrToInt(&_VIRTUAL_OFFSET));
}
pub fn table_is_present(entry: u32) callconv(.Inline) bool {
return (entry & 1) == 1;
}
pub fn get_table_address(entry: u32) callconv(.Inline) u32 {
return entry & 0xfffff000;
}
// (End of Page Directory Operations)
// Page Table Operations
pub fn get_table_index(address: u32) callconv(.Inline) u32 {
return (address & 0x003ff000) >> 12;
}
pub fn page_is_present(entry: u32) callconv(.Inline) bool {
// Bit 9 (0x200) marks a guard page to Georgios. This will be marked as not
// present in the entry itself (bit 1) so that it causes a page fault if
// accessed.
return (entry & 0x201) != 0;
}
pub fn as_guard_page(entry: u32) callconv(.Inline) u32 {
return (entry & 0xfffffffe) | 0x200;
}
pub fn page_is_guard_page(entry: u32) callconv(.Inline) bool {
return (entry & 0x201) == 0x200;
}
pub fn get_page_address(entry: u32) callconv(.Inline) u32 {
return entry & 0xfffff000;
}
pub fn present_entry(address: u32) callconv(.Inline) u32 {
return (address & 0xfffff000) | 1;
}
pub fn set_entry(entry: *allowzero u32, address: usize, user: bool) callconv(.Inline) void {
// TODO: Seperate User and Write
entry.* = present_entry(address) | (if (user) @as(u32, 0b110) else @as(u32, 0));
}
// (End of Page Table Operations)
pub fn invalidate_page(address: u32) void {
asm volatile ("invlpg (%[address])" : : [address] "{eax}" (address));
}
pub fn reload_active_page_directory() void {
asm volatile (
\\ movl $low_page_directory, %%eax
\\ movl %%eax, %%cr3
:::
"eax"
);
}
pub fn load_page_directory(new: []const u32, old: ?[]u32) utils.Error!void {
const end = get_kernel_space_start_directory_index();
if (old) |o| {
_ = try utils.memory_copy_error(
sliceAsBytes(o[0..end]), sliceAsBytes(active_page_directory[0..end]));
}
_ = try utils.memory_copy_error(
sliceAsBytes(active_page_directory[0..end]), sliceAsBytes(new[0..end]));
reload_active_page_directory();
}
const FrameAccessSlot = struct {
i: u16,
current_frame_address: ?u32 = null,
page_address: u32 = undefined,
page_table_entry: *u32 = undefined,
pub fn init(self: *FrameAccessSlot) void {
self.page_address = @ptrToInt(&_VIRTUAL_LOW_START) + page_size * self.i;
self.page_table_entry = &kernel_page_tables[get_table_index(self.page_address)];
}
};
/// Before we can allocate memory properly we need to be able to manually
/// change physical memory to setup frame allocation and create new page
/// tables. We can bootstrap this process by using a bit of real and virtual
/// memory we know is safe to use and map it to the frame want to change.
///
/// This involves reserving a FrameAccessSlot using a FrameAccess object for
/// the type to map. There can only be one FrameAccess using a slot at a time
/// or else there will be a panic. See below for the slot objects.
fn FrameAccess(comptime Type: type) type {
const Traits = @typeInfo(Type);
comptime var slice_len: ?comptime_int = null;
comptime var PtrType: type = undefined;
const GetType = switch (Traits) {
std.builtin.TypeId.Array => |array_type| blk: {
slice_len = array_type.len;
PtrType = [*]array_type.child;
break :blk []array_type.child;
},
else => else_blk: {
PtrType = *Type;
break :else_blk *Type;
}
};
return struct {
const Self = @This();
slot: *FrameAccessSlot,
ptr: PtrType,
pub fn new(slot: *FrameAccessSlot, frame_address: u32) Self {
if (slot.current_frame_address != null) {
@panic("The FrameAccess slot is already active!");
}
slot.current_frame_address = frame_address;
const needed_entry = (frame_address & 0xfffff000) | 1;
if (slot.page_table_entry.* != needed_entry) {
slot.page_table_entry.* = needed_entry;
invalidate_page(slot.page_address);
}
return Self{.slot = slot, .ptr = @intToPtr(PtrType, slot.page_address)};
}
pub fn get(self: *const Self) GetType {
return if (slice_len) |l| self.ptr[0..l] else self.ptr;
}
pub fn done(self: *const Self) void {
if (self.slot.current_frame_address == null) {
@panic("Done called, but slot is already inactive");
}
self.slot.current_frame_address = null;
}
};
}
var pmem_frame_access_slot: FrameAccessSlot = .{.i = 0};
var page_table_frame_access_slot: FrameAccessSlot = .{.i = 2};
var page_frame_access_slot: FrameAccessSlot = .{.i = 1};
// NOTE: More cannot be added unless room is made in the linking script by
// adjusting .low_force_space_begin_align to make _REAL_LOW_END increase.
/// Add Frame Groups to Our Memory Map from Multiboot Memory Map
pub fn process_multiboot2_mmap(map: *RealMemoryMap, tag: *const Range) void {
const entry_size = @intToPtr(*u32, tag.start + 8).*;
const entries_end = tag.start + tag.size;
var entry_ptr = tag.start + 16;
while (entry_ptr < entries_end) : (entry_ptr += entry_size) {
if (@intToPtr(*u32, entry_ptr + 16).* == 1) {
var range_start = @intCast(usize, @intToPtr(*u64, entry_ptr).*);
var range_size = @intCast(usize, @intToPtr(*u64, entry_ptr + 8).*);
const range_end = range_start + range_size;
if (range_start >= platform.kernel_real_start() and
platform.kernel_real_end() <= range_end) {
// This is the kernel, remove it from the range.
range_size = range_end - kernel_range_start_available;
range_start = kernel_range_start_available;
}
if (range_start < frame_size) {
// This is the Real Mode IVT and BDA, remove it from the range.
range_start = frame_size;
}
map.add_frame_group(range_start, range_size);
}
}
}
/// Kernel Memory System Platform Implementation
///
/// Physical Memory Allocation is based on
/// http://ethv.net/workshops/osdev/notes/notes-2
/// When a physical frame isn't being used it is part of a linked list.
pub const ManagerImpl = struct {
const FreeFramePtr = ?usize;
const FreeFramePtrAccess = FrameAccess(FreeFramePtr);
fn access_free_frame(frame: u32) FreeFramePtrAccess {
return FreeFramePtrAccess.new(&pmem_frame_access_slot, frame);
}
const TableAccess = FrameAccess([pages_per_table]u32);
fn access_page_table(frame: u32) TableAccess {
return TableAccess.new(&page_table_frame_access_slot, frame);
}
const PageAccess = FrameAccess([page_size]u8);
fn access_page(frame: u32) PageAccess {
return PageAccess.new(&page_frame_access_slot, frame);
}
parent: *memory.Manager = undefined,
next_free_frame: FreeFramePtr = null,
kernel_tables_index_start: usize = 0,
start_of_virtual_space: usize = 0,
page_allocator: memory.Allocator = undefined,
pub fn init(self: *ManagerImpl, parent: *memory.Manager, memory_map: *RealMemoryMap) void {
self.parent = parent;
self.page_allocator.alloc_impl = ManagerImpl.page_alloc;
self.page_allocator.free_impl = ManagerImpl.page_free;
parent.big_alloc = &self.page_allocator;
pmem_frame_access_slot.init();
page_table_frame_access_slot.init();
page_frame_access_slot.init();
// var total_count: usize = 0;
for (memory_map.frame_groups[0..memory_map.frame_group_count]) |*i| {
// total_count += i.frame_count;
var frame: usize = 0;
while (frame < i.frame_count) {
self.push_frame(i.start + frame * frame_size);
frame += 1;
}
}
// var counted: usize = 0;
// while (true) {
// _ = self.pop_frame() catch break;
// counted += 1;
// }
// print.format("total_count: {}, counted: {}\n", total_count, counted);
self.start_of_virtual_space = utils.align_up(
@ptrToInt(kernel_page_tables.ptr) + kernel_page_tables.len * table_size,
table_pages_size);
}
pub fn push_frame(self: *ManagerImpl, frame: usize) void {
// Put the current next_free_frame into the frame.
const access = access_free_frame(frame);
access.get().* = self.next_free_frame;
access.done();
// Point to that frame.
self.next_free_frame = frame;
}
pub fn pop_frame(self: *ManagerImpl) AllocError!usize {
if (self.next_free_frame) |frame| {
const prev = frame;
// Get the "next" next_free_frame from the contents of the current
// one.
const access = access_free_frame(frame);
self.next_free_frame = access.get().*;
access.done();
// Return the previous next_free_frame
return prev;
}
return AllocError.OutOfMemory;
}
pub fn get_unused_kernel_space(self: *ManagerImpl, requested_size: usize) AllocError!Range {
// print.format("get_unused_kernel_space {:x}\n", requested_size);
const start = self.start_of_virtual_space;
const dir_index_start = get_directory_index(start);
const table_index_start = get_table_index(start);
var rv = Range{.size = utils.align_up(requested_size, page_size)};
var range = Range{};
var dir_index: usize = dir_index_start;
while (dir_index < tables_per_directory) {
// print.format(" - Table {:x}\n", dir_index);
const dir_offset = dir_index * table_pages_size;
const dir_entry = active_page_directory[dir_index];
if (!table_is_present(dir_entry)) {
if (range.size == 0) {
range.start = dir_offset;
}
range.size += table_pages_size;
if (range.size >= rv.size) {
rv.start = range.start;
return rv;
}
dir_index += 1;
continue;
}
const access = access_page_table(get_table_address(active_page_directory[dir_index]));
defer access.done();
const table = access.get();
var table_index: usize =
if (dir_index == dir_index_start) table_index_start else 0;
while (table_index < pages_per_table) {
// print.format(" - Page {:x}\n", table_index);
if (page_is_present(table[table_index])) {
if (range.size > 0) {
range.size = 0;
range.start = 0;
}
} else {
if (range.size == 0) {
range.start = dir_offset + table_index * page_size;
}
range.size += page_size;
if (range.size >= rv.size) {
rv.start = range.start;
return rv;
}
}
table_index += 1;
}
dir_index += 1;
}
return AllocError.OutOfMemory;
}
pub fn new_page_table(self: *ManagerImpl, page_directory: []u32,
dir_index: usize, user: bool) AllocError!void {
// print.format("new_page_table {:x}\n", dir_index);
// TODO: Go through memory.Memory
const table_address = try self.pop_frame();
// TODO set_entry for page_directory
set_entry(&page_directory[dir_index], table_address, user);
const access = access_page_table(table_address);
const table = access.get();
var i: usize = 0;
while (i < pages_per_table) {
table[i] = 0;
i += 1;
}
access.done();
}
// TODO: Read/Write and Any Other Options
pub fn mark_virtual_memory_present(self: *ManagerImpl,
page_directory: []u32, range: Range, user: bool) AllocError!void {
// print.format("mark_virtual_memory_present {:a} {:a}\n", .{range.start, range.size});
const dir_index_start = get_directory_index(range.start);
const table_index_start = get_table_index(range.start);
var dir_index: usize = dir_index_start;
var marked: usize = 0;
while (dir_index < tables_per_directory) {
// print.format(" - Table {:x}\n", dir_index);
if (!table_is_present(page_directory[dir_index])) {
try self.new_page_table(page_directory, dir_index, user);
}
const access = access_page_table(get_table_address(page_directory[dir_index]));
defer access.done();
const table = access.get();
if (user) {
// TODO: Seperate User and Write
page_directory[dir_index] |= (0b11 << 1);
}
var table_index: usize =
if (dir_index == dir_index_start) table_index_start else 0;
while (table_index < pages_per_table) {
// print.format(" - Page {:x} {:x} {:x}\n",
// dir_index, table_index, table[table_index]);
if (page_is_present(table[table_index])) {
print.format("{:x}\n", .{get_address(dir_index, table_index)});
@panic("mark_virtual_memory_present: Page already present!");
}
// TODO: Go through memory.Memory for pop_frame
const frame = try self.pop_frame();
set_entry(&table[table_index], frame, user);
if (&page_directory[0] == &active_page_directory[0]) {
invalidate_page(get_address(dir_index, table_index));
}
marked += page_size;
if (marked >= range.size) return;
table_index += 1;
}
dir_index += 1;
}
}
// TODO
fn mark_virtual_memory_absent(self: *ManagerImpl, range: Range) void {
_ = self;
_ = range;
}
pub fn make_guard_page(self: *ManagerImpl, page_directory: ?[]u32,
address: usize, user: bool) AllocError!void {
const page_dir = page_directory orelse active_page_directory[0..];
const dir_index = get_directory_index(address);
if (!table_is_present(page_dir[dir_index])) {
try self.new_page_table(page_dir, dir_index, user);
}
const access = access_page_table(get_table_address(page_dir[dir_index]));
defer access.done();
const table = access.get();
const table_index = get_table_index(address);
const free_frame: ?u32 = if (page_is_present(table[table_index]))
get_page_address(table[table_index]) else null;
table[table_index] = as_guard_page(table[table_index]);
if (&page_dir[0] == &active_page_directory[0]) {
invalidate_page(get_address(dir_index, table_index));
}
if (free_frame) |addr| {
self.push_frame(addr);
}
}
fn page_alloc(allocator: *memory.Allocator, size: usize, align_to: usize) AllocError![]u8 {
_ = align_to;
const self = @fieldParentPtr(ManagerImpl, "page_allocator", allocator);
const range = try self.get_unused_kernel_space(size);
try self.mark_virtual_memory_present(active_page_directory[0..], range, false);
return range.to_slice(u8);
}
fn page_free(allocator: *memory.Allocator, value: []const u8, aligned_to: usize) FreeError!void {
const self = @fieldParentPtr(ManagerImpl, "page_allocator", allocator);
// TODO
_ = self;
_ = value;
_ = aligned_to;
}
pub fn new_page_directory(self: *ManagerImpl) AllocError![]u32 {
_ = self;
const page_directory =
try self.parent.big_alloc.alloc_array(u32, tables_per_directory);
_ = utils.memory_set(sliceAsBytes(page_directory[0..]), 0);
return page_directory;
}
pub fn page_directory_memory_copy(self: *ManagerImpl, page_directory: []u32,
address: usize, data: []const u8) AllocError!void {
// print.format("page_directory_memory_copy: {} b to {:a}\n", .{data.len, address});
const dir_index_start = get_directory_index(address);
const table_index_start = get_table_index(address);
var dir_index: usize = dir_index_start;
var data_left = data;
var page_offset = address % page_size;
while (data_left.len > 0 and dir_index < tables_per_directory) {
if (!table_is_present(page_directory[dir_index])) {
try self.new_page_table(page_directory, dir_index, true);
}
var table_index: usize =
if (dir_index == dir_index_start) table_index_start else 0;
while (data_left.len > 0 and table_index < pages_per_table) {
const table_access = access_page_table(get_table_address(page_directory[dir_index]));
defer table_access.done();
const table = table_access.get();
if (!page_is_present(table[table_index])) {
// TODO: Go through memory.Memory for pop_frame
const frame = try self.pop_frame();
set_entry(&table[table_index], frame, true);
if (&page_directory[0] == &active_page_directory[0]) {
invalidate_page(get_address(dir_index, table_index));
}
}
const page_access = access_page(get_page_address(table[table_index]));
defer page_access.done();
const page = page_access.get()[page_offset..];
page_offset = 0;
const copied = utils.memory_copy_truncate(page, data_left);
data_left = data_left[copied..];
table_index += 1;
}
dir_index += 1;
}
if (data_left.len > 0) {
@panic("address_space_copy: data_left.len > 0 at end!");
}
}
pub fn page_directory_memory_set(self: *ManagerImpl, page_directory: []u32,
address: usize, byte: u8, len: usize) AllocError!void {
const dir_index_start = get_directory_index(address);
const table_index_start = get_table_index(address);
var dir_index: usize = dir_index_start;
var left = len;
var page_offset = address % page_size;
while (left > 0 and dir_index < tables_per_directory) {
if (!table_is_present(page_directory[dir_index])) {
try self.new_page_table(page_directory, dir_index, true);
}
var table_index: usize =
if (dir_index == dir_index_start) table_index_start else 0;
while (left > 0 and table_index < pages_per_table) {
const table_access = access_page_table(get_table_address(page_directory[dir_index]));
defer table_access.done();
const table = table_access.get();
if (!page_is_present(table[table_index])) {
// TODO: Go through memory.Memory for pop_frame
const frame = try self.pop_frame();
set_entry(&table[table_index], frame, true);
if (&page_directory[0] == &active_page_directory[0]) {
invalidate_page(get_address(dir_index, table_index));
}
}
const page_access = access_page(get_page_address(table[table_index]));
defer page_access.done();
var page = page_access.get()[page_offset..];
if (page.len > left) {
page.len = left;
}
page_offset = 0;
utils.memory_set(page, byte);
left -= page.len;
table_index += 1;
}
dir_index += 1;
}
}
// TODO: This page structure iteration code is starting to seem very boiler
// plate. Figure out a way to simplify it or else more likely make it
// generic.
// Assumes range address is page aligned.
pub fn map_i(self: *ManagerImpl, page_directory: []u32, virtual_range: Range,
physical_start: usize, user: bool) AllocError!void {
const dir_index_start = get_directory_index(virtual_range.start);
const table_index_start = get_table_index(virtual_range.start);
var dir_index: usize = dir_index_start;
var left = virtual_range.size;
var physical_address = physical_start;
while (left > 0 and dir_index < tables_per_directory) {
if (!table_is_present(page_directory[dir_index])) {
try self.new_page_table(page_directory, dir_index, user);
}
const table_access = access_page_table(get_table_address(page_directory[dir_index]));
defer table_access.done();
const table = table_access.get();
var table_index: usize =
if (dir_index == dir_index_start) table_index_start else 0;
while (left > 0 and table_index < pages_per_table) {
const a = get_address(dir_index, table_index);
set_entry(&table[table_index], physical_address, user);
if (&page_directory[0] == &active_page_directory[0]) {
invalidate_page(a);
}
left -= page_size;
physical_address += page_size;
table_index += 1;
}
dir_index += 1;
}
if (left > 0) {
@panic("map: left > 0 at end!");
}
}
pub fn map(self: *ManagerImpl, virtual_range: Range, physical_start: usize,
user: bool) AllocError!void {
try self.map_i(active_page_directory[0..], virtual_range, physical_start, user);
}
}; | kernel/platform/memory.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const window = @import("Window.zig");
const c = @import("c.zig").c;
const files = @import("../Files.zig");
const expect = std.testing.expect;
const ReferenceCounter = @import("../RefCount.zig").ReferenceCounter;
// Base internal formats
pub const image_type_base_internal_formats = [_]u32{
c.GL_RED,
c.GL_RG,
c.GL_RGB,
c.GL_RGBA,
c.GL_RGBA,
c.GL_DEPTH_COMPONENT,
c.GL_DEPTH_COMPONENT,
c.GL_DEPTH_COMPONENT,
c.GL_DEPTH_COMPONENT,
c.GL_RED,
c.GL_RG,
c.GL_RGB,
c.GL_RGBA,
c.GL_RED,
c.GL_RG,
c.GL_RGB,
c.GL_RGBA,
c.GL_RGB,
};
pub const image_type_sized_internal_formats = [_]u32{
c.GL_R8,
c.GL_RG8,
c.GL_RGB8,
c.GL_RGBA8,
c.GL_RGB10_A2,
c.GL_DEPTH_COMPONENT16,
c.GL_DEPTH_COMPONENT24,
c.GL_DEPTH_COMPONENT32,
c.GL_DEPTH_COMPONENT32F,
c.GL_R32F,
c.GL_RG32F,
c.GL_RGB32F,
c.GL_RGBA32F,
c.GL_R16F,
c.GL_RG16F,
c.GL_RGB16F,
c.GL_RGBA16F,
c.GL_R11F_G11F_B10F,
};
pub const ImageType = enum {
R,
RG,
RGB,
RGBA,
RGB10A2,
Depth16,
Depth24,
Depth32,
Depth32F,
R32F,
RG32F,
RGB32F,
RGBA32F,
R16F,
RG16F,
RGB16F,
RGBA16F,
RG11FB10F,
};
const min_filter_gl_values = [_]i32{
c.GL_NEAREST,
c.GL_LINEAR,
c.GL_NEAREST_MIPMAP_NEAREST,
c.GL_LINEAR_MIPMAP_NEAREST,
c.GL_NEAREST_MIPMAP_LINEAR,
c.GL_LINEAR_MIPMAP_LINEAR,
};
// Do not change - scene files depend on the integer values of this enum
pub const MinFilter = enum(i32) {
Nearest,
Linear,
// One mip-map level
NearestMipMapNearest,
LinearMipMapNearest,
// Two mip-map levels
NearestMipMapLinear,
LinearMipMapLinear,
};
pub fn imageDataSize(w: usize, h: usize, imgType: ImageType) usize {
var expectedDataSize: usize = 0;
if (imgType == ImageType.RGBA32F) {
expectedDataSize = w * h * 16;
} else if (imgType == ImageType.RGB32F) {
expectedDataSize = w * h * 12;
} else if (imgType == ImageType.RG32F) {
expectedDataSize = w * h * 8;
} else if (imgType == ImageType.RGBA or imgType == ImageType.Depth32 or imgType == ImageType.Depth32F or imgType == ImageType.RGB10A2 or imgType == ImageType.R32F) {
expectedDataSize = w * h * 4;
} else if (imgType == ImageType.RGB or imgType == ImageType.Depth24) {
expectedDataSize = w * h * 3;
} else if (imgType == ImageType.RG or imgType == ImageType.Depth16) {
assert(w * 2 % 4 == 0); // Ensure rows are a multiple of 4 bytes
expectedDataSize = w * h * 2;
} else if (imgType == ImageType.R) {
assert(w % 4 == 0); // Ensure rows are a multiple of 4 bytes
expectedDataSize = w * h;
} else {
assert(false);
}
return expectedDataSize;
}
pub fn setTextureFiltering(textureId: c_uint, gl_type: c_uint, smooth_when_magnified: bool, min_filter: MinFilter) void {
c.glBindTexture(gl_type, textureId);
if (smooth_when_magnified) {
c.glTexParameteri(gl_type, c.GL_TEXTURE_MAG_FILTER, c.GL_LINEAR);
} else {
c.glTexParameteri(gl_type, c.GL_TEXTURE_MAG_FILTER, c.GL_NEAREST);
}
c.glTexParameteri(gl_type, c.GL_TEXTURE_MIN_FILTER, min_filter_gl_values[@intCast(usize, @enumToInt(min_filter))]);
if (min_filter == MinFilter.Nearest or min_filter == MinFilter.Linear) {
c.glTexParameteri(gl_type, c.GL_TEXTURE_BASE_LEVEL, 0);
c.glTexParameteri(gl_type, c.GL_TEXTURE_MAX_LEVEL, 0);
}
c.glTexParameteri(gl_type, c.GL_TEXTURE_WRAP_S, c.GL_CLAMP_TO_EDGE);
c.glTexParameteri(gl_type, c.GL_TEXTURE_WRAP_T, c.GL_CLAMP_TO_EDGE);
}
pub fn createTexture(gl_type: c_uint, smooth_when_magnified: bool, min_filter: MinFilter) !c_uint {
var textureId: u32 = 0;
c.glGenTextures(1, @ptrCast([*c]c_uint, &textureId));
if (textureId == 0) {
return error.OpenGLError;
}
setTextureFiltering(textureId, gl_type, smooth_when_magnified, min_filter);
return textureId;
}
pub const Texture2D = struct {
ref_count: ReferenceCounter = ReferenceCounter{},
width: u32,
height: u32,
imageType: ImageType,
id: u32,
min_filter: MinFilter,
pub fn initAndUpload(w: u32, h: u32, imgType: ImageType, data: ?[]const u8, smooth_when_magnified: bool, min_filter: MinFilter) !Texture2D {
var t = try init(smooth_when_magnified, min_filter);
try t.upload(w, h, imgType, data);
return t;
}
pub fn init(smooth_when_magnified: bool, min_filter: MinFilter) !Texture2D {
return Texture2D{
.width = 0,
.height = 0,
.imageType = ImageType.RGBA,
.id = try createTexture(c.GL_TEXTURE_2D, smooth_when_magnified, min_filter),
.min_filter = min_filter,
};
}
pub fn setFiltering(self: *Texture2D, smooth_when_magnified: bool, min_filter: MinFilter) !void {
if (self.id == 0) {
assert(false);
return error.InvalidState;
}
setTextureFiltering(self.id, c.GL_TEXTURE_2D, smooth_when_magnified, min_filter);
}
// Needed if using shadow sampler types
// (untested)
pub fn enableDepthCompare(self: Texture2D) void {
c.glBindTexture(c.GL_TEXTURE_2D, self.id);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_COMPARE_MODE, c.GL_COMPARE_REF_TO_TEXTURE);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_COMPARE_FUNC, c.GL_LESS);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MAG_FILTER, c.GL_LINEAR);
c.glTexParameteri(c.GL_TEXTURE_2D, c.GL_TEXTURE_MIN_FILTER, c.GL_LINEAR);
}
pub fn bindToUnit(self: Texture2D, unit: u32) !void {
if (self.width == 0 or self.height == 0 or self.id == 0) {
assert(false);
return error.InvalidState;
}
if (unit >= window.maximumNumTextureImageUnits()) {
return error.InvalidParameter;
}
c.glActiveTexture(c.GL_TEXTURE0 + unit);
c.glBindTexture(c.GL_TEXTURE_2D, self.id);
}
pub fn bind(self: Texture2D) !void {
try self.bindToUnit(0);
}
pub fn unbind(unit: u32) void {
if (unit >= window.maximumNumTextureImageUnits()) {
return;
}
c.glActiveTexture(c.GL_TEXTURE0 + unit);
c.glBindTexture(c.GL_TEXTURE_2D, 0);
}
// If data is null then texture data will be uninitialised
pub fn upload(self: *Texture2D, w: u32, h: u32, imgType: ImageType, data: ?[]const u8) !void {
if (w == 0 or h == 0 or w > window.maximumTextureSize() or h > window.maximumTextureSize()) {
assert(false);
return error.InvalidParameter;
}
if (data != null) {
const expectedDataSize = imageDataSize(w, h, imgType);
if (data.?.len != expectedDataSize) {
assert(false);
return error.InvalidParameter;
}
}
self.width = w;
self.height = h;
self.imageType = imgType;
var internalFormat: u32 = image_type_sized_internal_formats[@enumToInt(imgType)];
try self.bind();
var ptr: [*c]const u8 = 0;
if (data != null) {
ptr = data.?.ptr;
}
var data_format: c_uint = c.GL_UNSIGNED_BYTE;
if (imgType == ImageType.RGB10A2) {
data_format = c.GL_UNSIGNED_INT_10_10_10_2;
}
c.glTexImage2D(c.GL_TEXTURE_2D, 0, @intCast(c_int, internalFormat), @intCast(c_int, w), @intCast(c_int, h), 0, image_type_base_internal_formats[@enumToInt(imgType)], data_format, ptr);
if (self.min_filter != MinFilter.Nearest and self.min_filter != MinFilter.Linear) {
c.glGenerateMipmap(c.GL_TEXTURE_2D);
}
}
pub fn download(self: Texture2D, outputBuffer: []u8) !void {
const expectedDataSize = imageDataSize(self.width, self.height, self.imageType);
if (outputBuffer.len != expectedDataSize) {
assert(false);
return error.InvalidParameter;
}
try self.bind();
c.glGetTexImage(c.GL_TEXTURE_2D, 0, image_type_base_internal_formats[@enumToInt(self.imageType)], c.GL_UNSIGNED_BYTE, outputBuffer.ptr);
}
pub fn free(self: *Texture2D) void {
if (self.id == 0) {
assert(false);
return;
}
self.ref_count.deinit();
c.glDeleteTextures(1, @ptrCast([*c]c_uint, &self.id));
self.id = 0;
}
pub fn freeIfUnused(self: *Texture2D) void {
if (self.ref_count.n == 0) {
self.free();
}
}
pub fn loadFromFile(file_path: []const u8, allocator: *std.mem.Allocator, smooth_when_magnified: bool, min_filter: MinFilter, components: u32) !Texture2D {
if (components == 0 or components > 4) {
return error.InvalidParameter;
}
var tex = try Texture2D.init(smooth_when_magnified, min_filter);
errdefer tex.free();
const file_data = try files.loadFile(file_path, allocator);
defer allocator.free(file_data);
var w: i32 = undefined;
var h: i32 = undefined;
var n: i32 = undefined;
const data = c.stbi_load_from_memory(file_data.ptr, @intCast(c_int, file_data.len), @ptrCast([*c]c_int, &w), @ptrCast([*c]c_int, &h), @ptrCast([*c]c_int, &n), @intCast(c_int, components));
if (data == null) {
return error.DecodeError;
}
defer c.stbi_image_free(data);
assert(w > 0);
assert(h > 0);
var img_type: ImageType = undefined;
if (components == 1) {
img_type = ImageType.R;
} else if (components == 2) {
img_type = ImageType.RG;
} else if (components == 3) {
img_type = ImageType.RGB;
} else if (components == 4) {
img_type = ImageType.RGBA;
} else {
assert(false);
return error.InvalidParameter;
}
try tex.upload(@intCast(u32, w), @intCast(u32, h), img_type, data[0..(@intCast(u32, w) * @intCast(u32, h) * components)]);
return tex;
}
// Use the asset module if you need to load compressed rgb10a2 images
pub fn loadFromRGB10A2File(file_path: []const u8, allocator: *std.mem.Allocator, smooth_when_magnified: bool, min_filter: MinFilter) !Texture2D {
var tex = try Texture2D.init(smooth_when_magnified, min_filter);
errdefer tex.free();
const file_data = try files.loadFile(file_path, allocator);
defer allocator.free(file_data);
const file_data_u32: []u32 = std.mem.bytesAsSlice(u32, file_data);
if (file_data_u32[0] != 0x62677200 or file_data_u32[1] != 0x32613031) {
return error.InvalidMagic;
}
const w = file_data_u32[2];
const h = file_data_u32[3];
if (w == 0 or h == 0 or w > 32768 or h > 32768) {
return error.InvalidDimensions;
}
try tex.upload(w, h, ImageType.RGB10A2, file_data[16..(w * h * 4 + 16)]);
return tex;
}
pub fn saveToFile(self: Texture2D, file_path: []const u8, allocator: *std.mem.Allocator) !void {
if (self.imageType != ImageType.RGBA) {
return error.ImageFormatNotSupported;
}
const expectedDataSize = self.width * self.height * 4;
var outputBuffer = try allocator.alloc(u8, expectedDataSize);
try self.download(outputBuffer);
const err = c.stbi_write_png(@ptrCast([*c]const u8, file_path.ptr), @intCast(c_int, self.width), @intCast(c_int, self.height), 4, outputBuffer.ptr, @intCast(c_int, self.width * 4));
if (err == 0) {
return error.STBImageWriteError;
}
}
};
// Use freeDecodedImage to free the returned slice
// 'components' should be 0 or the desired number of data channels
// If components is 0 then it is set to the number of channels in the image
pub fn decodeImage(image_file_data: []const u8, components: *u32, image_width: *u32, image_height: *u32, allocator: *std.mem.Allocator) ![]align(4) u8 {
if (components.* > 4) {
return error.InvalidParameter;
}
var desired_channels = components.*;
var w: i32 = undefined;
var h: i32 = undefined;
var n: i32 = undefined;
const data = c.stbi_load_from_memory(image_file_data.ptr, @intCast(c_int, image_file_data.len), @ptrCast([*c]c_int, &w), @ptrCast([*c]c_int, &h), @ptrCast([*c]c_int, &n), @intCast(c_int, desired_channels));
if (data == null or w < 1 or h < 1 or n == 0 or n > 4) {
return error.DecodeError;
}
if (components.* == 0) {
components.* = @intCast(u32, n);
}
image_width.* = @intCast(u32, w);
image_height.* = @intCast(u32, w);
return @alignCast(4, data[0..(@intCast(u32, w) * @intCast(u32, h) * @intCast(u32, desired_channels))]);
}
pub fn freeDecodedImage(data: []align(4) u8) void {
var d: *c_void = @ptrCast(*c_void, data.ptr);
var d2: ?*c_void = d;
c.stbi_image_free(d2);
}
test "2d texture" {
try window.createWindow(false, 200, 200, "test", true, 0);
var texture: Texture2D = try Texture2D.init(false, MinFilter.Nearest);
expect(texture.id > 0);
const dataIn: []const u8 = &[4]u8{ 127, 127, 127, 127 };
try texture.upload(1, 1, ImageType.RGBA, dataIn);
expect(texture.width == 1);
expect(texture.height == 1);
expect(texture.imageType == ImageType.RGBA);
var data: [4]u8 = undefined;
try texture.download(&data);
expect(mem.eql(u8, data[0..], dataIn));
try texture.bind();
try texture.bindToUnit(15);
texture.free();
window.closeWindow();
} | src/WindowGraphicsInput/Image.zig |
pub const tlds: []const []const u8 = &.{
"aaa",
"aarp",
"abarth",
"abb",
"abbott",
"abbvie",
"abc",
"able",
"abogado",
"abudhabi",
"ac",
"academy",
"accenture",
"accountant",
"accountants",
"aco",
"actor",
"ad",
"adac",
"ads",
"adult",
"ae",
"aeg",
"aero",
"aetna",
"af",
"afamilycompany",
"afl",
"africa",
"ag",
"agakhan",
"agency",
"ai",
"aig",
"airbus",
"airforce",
"airtel",
"akdn",
"al",
"alfaromeo",
"alibaba",
"alipay",
"allfinanz",
"allstate",
"ally",
"alsace",
"alstom",
"am",
"amazon",
"americanexpress",
"americanfamily",
"amex",
"amfam",
"amica",
"amsterdam",
"analytics",
"android",
"anquan",
"anz",
"ao",
"aol",
"apartments",
"app",
"apple",
"aq",
"aquarelle",
"ar",
"arab",
"aramco",
"archi",
"army",
"arpa",
"art",
"arte",
"as",
"asda",
"asia",
"associates",
"at",
"athleta",
"attorney",
"au",
"auction",
"audi",
"audible",
"audio",
"auspost",
"author",
"auto",
"autos",
"avianca",
"aw",
"aws",
"ax",
"axa",
"az",
"azure",
"ba",
"baby",
"baidu",
"banamex",
"bananarepublic",
"band",
"bank",
"bar",
"barcelona",
"barclaycard",
"barclays",
"barefoot",
"bargains",
"baseball",
"basketball",
"bauhaus",
"bayern",
"bb",
"bbc",
"bbt",
"bbva",
"bcg",
"bcn",
"bd",
"be",
"beats",
"beauty",
"beer",
"bentley",
"berlin",
"best",
"bestbuy",
"bet",
"bf",
"bg",
"bh",
"bharti",
"bi",
"bible",
"bid",
"bike",
"bing",
"bingo",
"bio",
"biz",
"bj",
"black",
"blackfriday",
"blockbuster",
"blog",
"bloomberg",
"blue",
"bm",
"bms",
"bmw",
"bn",
"bnpparibas",
"bo",
"boats",
"boehringer",
"bofa",
"bom",
"bond",
"boo",
"book",
"booking",
"bosch",
"bostik",
"boston",
"bot",
"boutique",
"box",
"br",
"bradesco",
"bridgestone",
"broadway",
"broker",
"brother",
"brussels",
"bs",
"bt",
"budapest",
"bugatti",
"build",
"builders",
"business",
"buy",
"buzz",
"bv",
"bw",
"by",
"bz",
"bzh",
"ca",
"cab",
"cafe",
"cal",
"call",
"calvinklein",
"cam",
"camera",
"camp",
"cancerresearch",
"canon",
"capetown",
"capital",
"capitalone",
"car",
"caravan",
"cards",
"care",
"career",
"careers",
"cars",
"casa",
"case",
"cash",
"casino",
"cat",
"catering",
"catholic",
"cba",
"cbn",
"cbre",
"cbs",
"cc",
"cd",
"center",
"ceo",
"cern",
"cf",
"cfa",
"cfd",
"cg",
"ch",
"chanel",
"channel",
"charity",
"chase",
"chat",
"cheap",
"chintai",
"christmas",
"chrome",
"church",
"ci",
"cipriani",
"circle",
"cisco",
"citadel",
"citi",
"citic",
"city",
"cityeats",
"ck",
"cl",
"claims",
"cleaning",
"click",
"clinic",
"clinique",
"clothing",
"cloud",
"club",
"clubmed",
"cm",
"cn",
"co",
"coach",
"codes",
"coffee",
"college",
"cologne",
"com",
"comcast",
"commbank",
"community",
"company",
"compare",
"computer",
"comsec",
"condos",
"construction",
"consulting",
"contact",
"contractors",
"cooking",
"cookingchannel",
"cool",
"coop",
"corsica",
"country",
"coupon",
"coupons",
"courses",
"cpa",
"cr",
"credit",
"creditcard",
"creditunion",
"cricket",
"crown",
"crs",
"cruise",
"cruises",
"csc",
"cu",
"cuisinella",
"cv",
"cw",
"cx",
"cy",
"cymru",
"cyou",
"cz",
"dabur",
"dad",
"dance",
"data",
"date",
"dating",
"datsun",
"day",
"dclk",
"dds",
"de",
"deal",
"dealer",
"deals",
"degree",
"delivery",
"dell",
"deloitte",
"delta",
"democrat",
"dental",
"dentist",
"desi",
"design",
"dev",
"dhl",
"diamonds",
"diet",
"digital",
"direct",
"directory",
"discount",
"discover",
"dish",
"diy",
"dj",
"dk",
"dm",
"dnp",
"do",
"docs",
"doctor",
"dog",
"domains",
"dot",
"download",
"drive",
"dtv",
"dubai",
"duck",
"dunlop",
"dupont",
"durban",
"dvag",
"dvr",
"dz",
"earth",
"eat",
"ec",
"eco",
"edeka",
"edu",
"education",
"ee",
"eg",
"email",
"emerck",
"energy",
"engineer",
"engineering",
"enterprises",
"epson",
"equipment",
"er",
"ericsson",
"erni",
"es",
"esq",
"estate",
"et",
"etisalat",
"eu",
"eurovision",
"eus",
"events",
"exchange",
"expert",
"exposed",
"express",
"extraspace",
"fage",
"fail",
"fairwinds",
"faith",
"family",
"fan",
"fans",
"farm",
"farmers",
"fashion",
"fast",
"fedex",
"feedback",
"ferrari",
"ferrero",
"fi",
"fiat",
"fidelity",
"fido",
"film",
"final",
"finance",
"financial",
"fire",
"firestone",
"firmdale",
"fish",
"fishing",
"fit",
"fitness",
"fj",
"fk",
"flickr",
"flights",
"flir",
"florist",
"flowers",
"fly",
"fm",
"fo",
"foo",
"food",
"foodnetwork",
"football",
"ford",
"forex",
"forsale",
"forum",
"foundation",
"fox",
"fr",
"free",
"fresenius",
"frl",
"frogans",
"frontdoor",
"frontier",
"ftr",
"fujitsu",
"fun",
"fund",
"furniture",
"futbol",
"fyi",
"ga",
"gal",
"gallery",
"gallo",
"gallup",
"game",
"games",
"gap",
"garden",
"gay",
"gb",
"gbiz",
"gd",
"gdn",
"ge",
"gea",
"gent",
"genting",
"george",
"gf",
"gg",
"ggee",
"gh",
"gi",
"gift",
"gifts",
"gives",
"giving",
"gl",
"glade",
"glass",
"gle",
"global",
"globo",
"gm",
"gmail",
"gmbh",
"gmo",
"gmx",
"gn",
"godaddy",
"gold",
"goldpoint",
"golf",
"goo",
"goodyear",
"goog",
"google",
"gop",
"got",
"gov",
"gp",
"gq",
"gr",
"grainger",
"graphics",
"gratis",
"green",
"gripe",
"grocery",
"group",
"gs",
"gt",
"gu",
"guardian",
"gucci",
"guge",
"guide",
"guitars",
"guru",
"gw",
"gy",
"hair",
"hamburg",
"hangout",
"haus",
"hbo",
"hdfc",
"hdfcbank",
"health",
"healthcare",
"help",
"helsinki",
"here",
"hermes",
"hgtv",
"hiphop",
"hisamitsu",
"hitachi",
"hiv",
"hk",
"hkt",
"hm",
"hn",
"hockey",
"holdings",
"holiday",
"homedepot",
"homegoods",
"homes",
"homesense",
"honda",
"horse",
"hospital",
"host",
"hosting",
"hot",
"hoteles",
"hotels",
"hotmail",
"house",
"how",
"hr",
"hsbc",
"ht",
"hu",
"hughes",
"hyatt",
"hyundai",
"ibm",
"icbc",
"ice",
"icu",
"id",
"ie",
"ieee",
"ifm",
"ikano",
"il",
"im",
"imamat",
"imdb",
"immo",
"immobilien",
"in",
"inc",
"industries",
"infiniti",
"info",
"ing",
"ink",
"institute",
"insurance",
"insure",
"int",
"international",
"intuit",
"investments",
"io",
"ipiranga",
"iq",
"ir",
"irish",
"is",
"ismaili",
"ist",
"istanbul",
"it",
"itau",
"itv",
"jaguar",
"java",
"jcb",
"je",
"jeep",
"jetzt",
"jewelry",
"jio",
"jll",
"jm",
"jmp",
"jnj",
"jo",
"jobs",
"joburg",
"jot",
"joy",
"jp",
"jpmorgan",
"jprs",
"juegos",
"juniper",
"kaufen",
"kddi",
"ke",
"kerryhotels",
"kerrylogistics",
"kerryproperties",
"kfh",
"kg",
"kh",
"ki",
"kia",
"kim",
"kinder",
"kindle",
"kitchen",
"kiwi",
"km",
"kn",
"koeln",
"komatsu",
"kosher",
"kp",
"kpmg",
"kpn",
"kr",
"krd",
"kred",
"kuokgroup",
"kw",
"ky",
"kyoto",
"kz",
"la",
"lacaixa",
"lamborghini",
"lamer",
"lancaster",
"lancia",
"land",
"landrover",
"lanxess",
"lasalle",
"lat",
"latino",
"latrobe",
"law",
"lawyer",
"lb",
"lc",
"lds",
"lease",
"leclerc",
"lefrak",
"legal",
"lego",
"lexus",
"lgbt",
"li",
"lidl",
"life",
"lifeinsurance",
"lifestyle",
"lighting",
"like",
"lilly",
"limited",
"limo",
"lincoln",
"linde",
"link",
"lipsy",
"live",
"living",
"lixil",
"lk",
"llc",
"llp",
"loan",
"loans",
"locker",
"locus",
"loft",
"lol",
"london",
"lotte",
"lotto",
"love",
"lpl",
"lplfinancial",
"lr",
"ls",
"lt",
"ltd",
"ltda",
"lu",
"lundbeck",
"luxe",
"luxury",
"lv",
"ly",
"ma",
"macys",
"madrid",
"maif",
"maison",
"makeup",
"man",
"management",
"mango",
"map",
"market",
"marketing",
"markets",
"marriott",
"marshalls",
"maserati",
"mattel",
"mba",
"mc",
"mckinsey",
"md",
"me",
"med",
"media",
"meet",
"melbourne",
"meme",
"memorial",
"men",
"menu",
"merckmsd",
"mg",
"mh",
"miami",
"microsoft",
"mil",
"mini",
"mint",
"mit",
"mitsubishi",
"mk",
"ml",
"mlb",
"mls",
"mm",
"mma",
"mn",
"mo",
"mobi",
"mobile",
"moda",
"moe",
"moi",
"mom",
"monash",
"money",
"monster",
"mormon",
"mortgage",
"moscow",
"moto",
"motorcycles",
"mov",
"movie",
"mp",
"mq",
"mr",
"ms",
"msd",
"mt",
"mtn",
"mtr",
"mu",
"museum",
"mutual",
"mv",
"mw",
"mx",
"my",
"mz",
"na",
"nab",
"nagoya",
"name",
"natura",
"navy",
"nba",
"nc",
"ne",
"nec",
"net",
"netbank",
"netflix",
"network",
"neustar",
"new",
"news",
"next",
"nextdirect",
"nexus",
"nf",
"nfl",
"ng",
"ngo",
"nhk",
"ni",
"nico",
"nike",
"nikon",
"ninja",
"nissan",
"nissay",
"nl",
"no",
"nokia",
"northwesternmutual",
"norton",
"now",
"nowruz",
"nowtv",
"np",
"nr",
"nra",
"nrw",
"ntt",
"nu",
"nyc",
"nz",
"obi",
"observer",
"off",
"office",
"okinawa",
"olayan",
"olayangroup",
"oldnavy",
"ollo",
"om",
"omega",
"one",
"ong",
"onl",
"online",
"ooo",
"open",
"oracle",
"orange",
"org",
"organic",
"origins",
"osaka",
"otsuka",
"ott",
"ovh",
"pa",
"page",
"panasonic",
"paris",
"pars",
"partners",
"parts",
"party",
"passagens",
"pay",
"pccw",
"pe",
"pet",
"pf",
"pfizer",
"pg",
"ph",
"pharmacy",
"phd",
"philips",
"phone",
"photo",
"photography",
"photos",
"physio",
"pics",
"pictet",
"pictures",
"pid",
"pin",
"ping",
"pink",
"pioneer",
"pizza",
"pk",
"pl",
"place",
"play",
"playstation",
"plumbing",
"plus",
"pm",
"pn",
"pnc",
"pohl",
"poker",
"politie",
"porn",
"post",
"pr",
"pramerica",
"praxi",
"press",
"prime",
"pro",
"prod",
"productions",
"prof",
"progressive",
"promo",
"properties",
"property",
"protection",
"pru",
"prudential",
"ps",
"pt",
"pub",
"pw",
"pwc",
"py",
"qa",
"qpon",
"quebec",
"quest",
"qvc",
"racing",
"radio",
"raid",
"re",
"read",
"realestate",
"realtor",
"realty",
"recipes",
"red",
"redstone",
"redumbrella",
"rehab",
"reise",
"reisen",
"reit",
"reliance",
"ren",
"rent",
"rentals",
"repair",
"report",
"republican",
"rest",
"restaurant",
"review",
"reviews",
"rexroth",
"rich",
"richardli",
"ricoh",
"ril",
"rio",
"rip",
"rmit",
"ro",
"rocher",
"rocks",
"rodeo",
"rogers",
"room",
"rs",
"rsvp",
"ru",
"rugby",
"ruhr",
"run",
"rw",
"rwe",
"ryukyu",
"sa",
"saarland",
"safe",
"safety",
"sakura",
"sale",
"salon",
"samsclub",
"samsung",
"sandvik",
"sandvikcoromant",
"sanofi",
"sap",
"sarl",
"sas",
"save",
"saxo",
"sb",
"sbi",
"sbs",
"sc",
"sca",
"scb",
"schaeffler",
"schmidt",
"scholarships",
"school",
"schule",
"schwarz",
"science",
"scjohnson",
"scot",
"sd",
"se",
"search",
"seat",
"secure",
"security",
"seek",
"select",
"sener",
"services",
"ses",
"seven",
"sew",
"sex",
"sexy",
"sfr",
"sg",
"sh",
"shangrila",
"sharp",
"shaw",
"shell",
"shia",
"shiksha",
"shoes",
"shop",
"shopping",
"shouji",
"show",
"showtime",
"si",
"silk",
"sina",
"singles",
"site",
"sj",
"sk",
"ski",
"skin",
"sky",
"skype",
"sl",
"sling",
"sm",
"smart",
"smile",
"sn",
"sncf",
"so",
"soccer",
"social",
"softbank",
"software",
"sohu",
"solar",
"solutions",
"song",
"sony",
"soy",
"spa",
"space",
"sport",
"spot",
"sr",
"srl",
"ss",
"st",
"stada",
"staples",
"star",
"statebank",
"statefarm",
"stc",
"stcgroup",
"stockholm",
"storage",
"store",
"stream",
"studio",
"study",
"style",
"su",
"sucks",
"supplies",
"supply",
"support",
"surf",
"surgery",
"suzuki",
"sv",
"swatch",
"swiftcover",
"swiss",
"sx",
"sy",
"sydney",
"systems",
"sz",
"tab",
"taipei",
"talk",
"taobao",
"target",
"tatamotors",
"tatar",
"tattoo",
"tax",
"taxi",
"tc",
"tci",
"td",
"tdk",
"team",
"tech",
"technology",
"tel",
"temasek",
"tennis",
"teva",
"tf",
"tg",
"th",
"thd",
"theater",
"theatre",
"tiaa",
"tickets",
"tienda",
"tiffany",
"tips",
"tires",
"tirol",
"tj",
"tjmaxx",
"tjx",
"tk",
"tkmaxx",
"tl",
"tm",
"tmall",
"tn",
"to",
"today",
"tokyo",
"tools",
"top",
"toray",
"toshiba",
"total",
"tours",
"town",
"toyota",
"toys",
"tr",
"trade",
"trading",
"training",
"travel",
"travelchannel",
"travelers",
"travelersinsurance",
"trust",
"trv",
"tt",
"tube",
"tui",
"tunes",
"tushu",
"tv",
"tvs",
"tw",
"tz",
"ua",
"ubank",
"ubs",
"ug",
"uk",
"unicom",
"university",
"uno",
"uol",
"ups",
"us",
"uy",
"uz",
"va",
"vacations",
"vana",
"vanguard",
"vc",
"ve",
"vegas",
"ventures",
"verisign",
"versicherung",
"vet",
"vg",
"vi",
"viajes",
"video",
"vig",
"viking",
"villas",
"vin",
"vip",
"virgin",
"visa",
"vision",
"viva",
"vivo",
"vlaanderen",
"vn",
"vodka",
"volkswagen",
"volvo",
"vote",
"voting",
"voto",
"voyage",
"vu",
"vuelos",
"wales",
"walmart",
"walter",
"wang",
"wanggou",
"watch",
"watches",
"weather",
"weatherchannel",
"webcam",
"weber",
"website",
"wed",
"wedding",
"weibo",
"weir",
"wf",
"whoswho",
"wien",
"wiki",
"williamhill",
"win",
"windows",
"wine",
"winners",
"wme",
"wolterskluwer",
"woodside",
"work",
"works",
"world",
"wow",
"ws",
"wtc",
"wtf",
"xbox",
"xerox",
"xfinity",
"xihuan",
"xin",
"xn--11b4c3d",
"xn--1ck2e1b",
"xn--1qqw23a",
"xn--2scrj9c",
"xn--30rr7y",
"xn--3bst00m",
"xn--3ds443g",
"xn--3e0b707e",
"xn--3hcrj9c",
"xn--3oq18vl8pn36a",
"xn--3pxu8k",
"xn--42c2d9a",
"xn--45br5cyl",
"xn--45brj9c",
"xn--45q11c",
"xn--4dbrk0ce",
"xn--4gbrim",
"xn--54b7fta0cc",
"xn--55qw42g",
"xn--55qx5d",
"xn--5su34j936bgsg",
"xn--5tzm5g",
"xn--6frz82g",
"xn--6qq986b3xl",
"xn--80adxhks",
"xn--80ao21a",
"xn--80aqecdr1a",
"xn--80asehdb",
"xn--80aswg",
"xn--8y0a063a",
"xn--90a3ac",
"xn--90ae",
"xn--90ais",
"xn--9dbq2a",
"xn--9et52u",
"xn--9krt00a",
"xn--b4w605ferd",
"xn--bck1b9a5dre4c",
"xn--c1avg",
"xn--c2br7g",
"xn--cck2b3b",
"xn--cckwcxetd",
"xn--cg4bki",
"xn--clchc0ea0b2g2a9gcd",
"xn--czr694b",
"xn--czrs0t",
"xn--czru2d",
"xn--d1acj3b",
"xn--d1alf",
"xn--e1a4c",
"xn--eckvdtc9d",
"xn--efvy88h",
"xn--fct429k",
"xn--fhbei",
"xn--fiq228c5hs",
"xn--fiq64b",
"xn--fiqs8s",
"xn--fiqz9s",
"xn--fjq720a",
"xn--flw351e",
"xn--fpcrj9c3d",
"xn--fzc2c9e2c",
"xn--fzys8d69uvgm",
"xn--g2xx48c",
"xn--gckr3f0f",
"xn--gecrj9c",
"xn--gk3at1e",
"xn--h2breg3eve",
"xn--h2brj9c",
"xn--h2brj9c8c",
"xn--hxt814e",
"xn--i1b6b1a6a2e",
"xn--imr513n",
"xn--io0a7i",
"xn--j1aef",
"xn--j1amh",
"xn--j6w193g",
"xn--jlq480n2rg",
"xn--jlq61u9w7b",
"xn--jvr189m",
"xn--kcrx77d1x4a",
"xn--kprw13d",
"xn--kpry57d",
"xn--kput3i",
"xn--l1acc",
"xn--lgbbat1ad8j",
"xn--mgb9awbf",
"xn--mgba3a3ejt",
"xn--mgba3a4f16a",
"xn--mgba7c0bbn0a",
"xn--mgbaakc7dvf",
"xn--mgbaam7a8h",
"xn--mgbab2bd",
"xn--mgbah1a3hjkrd",
"xn--mgbai9azgqp6j",
"xn--mgbayh7gpa",
"xn--mgbbh1a",
"xn--mgbbh1a71e",
"xn--mgbc0a9azcg",
"xn--mgbca7dzdo",
"xn--mgbcpq6gpa1a",
"xn--mgberp4a5d4ar",
"xn--mgbgu82a",
"xn--mgbi4ecexp",
"xn--mgbpl2fh",
"xn--mgbt3dhd",
"xn--mgbtx2b",
"xn--mgbx4cd0ab",
"xn--mix891f",
"xn--mk1bu44c",
"xn--mxtq1m",
"xn--ngbc5azd",
"xn--ngbe9e0a",
"xn--ngbrx",
"xn--node",
"xn--nqv7f",
"xn--nqv7fs00ema",
"xn--nyqy26a",
"xn--o3cw4h",
"xn--ogbpf8fl",
"xn--otu796d",
"xn--p1acf",
"xn--p1ai",
"xn--pgbs0dh",
"xn--pssy2u",
"xn--q7ce6a",
"xn--q9jyb4c",
"xn--qcka1pmc",
"xn--qxa6a",
"xn--qxam",
"xn--rhqv96g",
"xn--rovu88b",
"xn--rvc1e0am3e",
"xn--s9brj9c",
"xn--ses554g",
"xn--t60b56a",
"xn--tckwe",
"xn--tiq49xqyj",
"xn--unup4y",
"xn--vermgensberater-ctb",
"xn--vermgensberatung-pwb",
"xn--vhquv",
"xn--vuq861b",
"xn--w4r85el8fhu5dnra",
"xn--w4rs40l",
"xn--wgbh1c",
"xn--wgbl6a",
"xn--xhq521b",
"xn--xkc2al3hye2a",
"xn--xkc2dl3a5ee0h",
"xn--y9a3aq",
"xn--yfro4i67o",
"xn--ygbi2ammx",
"xn--zfr164b",
"xxx",
"xyz",
"yachts",
"yahoo",
"yamaxun",
"yandex",
"ye",
"yodobashi",
"yoga",
"yokohama",
"you",
"youtube",
"yt",
"yun",
"za",
"zappos",
"zara",
"zero",
"zip",
"zm",
"zone",
"zuerich",
"zw",
}; | src/lib.zig |
const std = @import("std");
const os = @import("root").os;
const apic = @import("apic.zig");
const ports = @import("ports.zig");
const kb = os.drivers.hid.keyboard;
const eoi = @import("apic.zig").eoi;
const Extendedness = enum {
Extended,
NotExtended,
};
pub var kb_interrupt_vector: u8 = undefined;
pub var kb_interrupt_gsi: u32 = undefined;
const scancode_extended = 0xE0;
fn parse_scancode(ext: Extendedness, scancode: u8) void {
switch(ext) {
.Extended => {
switch(scancode) {
0x2A => { // Print screen press
std.debug.assert(kb_wait_byte() == scancode_extended);
std.debug.assert(kb_wait_byte() == 0x37);
state.event(.Press, .PrintScreen);
return;
},
0xB7 => { // Print screen release
std.debug.assert(kb_wait_byte() == scancode_extended);
std.debug.assert(kb_wait_byte() == 0xAA);
state.event(.Release, .PrintScreen);
return;
},
else => { },
}
},
.NotExtended => {
switch(scancode) {
0xE1 => {
std.debug.assert(kb_wait_byte() == 0x1D);
std.debug.assert(kb_wait_byte() == 0x45);
std.debug.assert(kb_wait_byte() == 0xE1);
std.debug.assert(kb_wait_byte() == 0x9D);
std.debug.assert(kb_wait_byte() == 0xC5);
state.event(.Press, .PauseBreak);
// There is no event for releasing this key,
// so we just gotta pretend it's released instantly
state.event(.Release, .PauseBreak);
return;
},
else => { },
}
},
}
const loc = key_location(ext, scancode & 0x7F) catch return;
if(scancode & 0x80 != 0) {
state.event(.Release, loc);
} else {
state.event(.Press, loc);
}
}
var state: kb.KeyboardState = .{};
fn kb_has_byte() bool {
return (ports.inb(0x64) & 1) != 0;
}
fn kb_wait_byte() u8 {
while(!kb_has_byte()) { }
return ports.inb(0x60);
}
fn handle_keyboard_interrupt() void {
var ext: Extendedness = .NotExtended;
var scancode = kb_wait_byte();
if(scancode == scancode_extended) {
ext = .Extended;
scancode = kb_wait_byte();
}
parse_scancode(ext, scancode);
eoi();
}
pub fn kb_handler(_: *os.platform.InterruptFrame) void {
while(kb_has_byte()) {
handle_keyboard_interrupt();
}
}
pub fn kb_init() void {
const i = os.platform.get_and_disable_interrupts();
defer os.platform.set_interrupts(i);
if(kb_has_byte()) {
handle_keyboard_interrupt();
}
}
fn key_location(ext: Extendedness, scancode: u8) !kb.keys.Location {
switch(ext) {
.NotExtended => {
return switch(scancode) {
0x01 => .Escape,
0x02 => .NumberKey1,
0x03 => .NumberKey2,
0x04 => .NumberKey3,
0x05 => .NumberKey4,
0x06 => .NumberKey5,
0x07 => .NumberKey6,
0x08 => .NumberKey7,
0x09 => .NumberKey8,
0x0A => .NumberKey9,
0x0B => .NumberKey0,
0x0C => .RightOf0,
0x0D => .LeftOfBackspace,
0x0E => .Backspace,
0x0F => .Tab,
0x10 => .Line1_1,
0x11 => .Line1_2,
0x12 => .Line1_3,
0x13 => .Line1_4,
0x14 => .Line1_5,
0x15 => .Line1_6,
0x16 => .Line1_7,
0x17 => .Line1_8,
0x18 => .Line1_9,
0x19 => .Line1_10,
0x1A => .Line1_11,
0x1B => .Line1_12,
0x1C => .Enter,
0x1D => .LeftCtrl,
0x1E => .Line2_1,
0x1F => .Line2_2,
0x20 => .Line2_3,
0x21 => .Line2_4,
0x22 => .Line2_5,
0x23 => .Line2_6,
0x24 => .Line2_7,
0x25 => .Line2_8,
0x26 => .Line2_9,
0x27 => .Line2_10,
0x28 => .Line2_11,
0x29 => .LeftOf1,
0x2A => .LeftShift,
0x2B => .Line2_12,
0x2C => .Line3_1,
0x2D => .Line3_2,
0x2E => .Line3_3,
0x2F => .Line3_4,
0x30 => .Line3_5,
0x31 => .Line3_6,
0x32 => .Line3_7,
0x33 => .Line3_8,
0x34 => .Line3_9,
0x35 => .Line3_10,
0x36 => .RightShift,
0x37 => .NumpadMultiplication,
0x38 => .LeftAlt,
0x39 => .Spacebar,
0x3A => .CapsLock,
0x3B => .F1,
0x3C => .F2,
0x3D => .F3,
0x3E => .F4,
0x3F => .F5,
0x40 => .F6,
0x41 => .F7,
0x42 => .F8,
0x43 => .F9,
0x44 => .F10,
0x45 => .NumLock,
0x46 => .ScrollLock,
0x47 => .Numpad7,
0x48 => .Numpad8,
0x49 => .Numpad9,
0x4A => .NumpadSubtraction,
0x4B => .Numpad4,
0x4C => .Numpad5,
0x4D => .Numpad6,
0x4E => .NumpadAddition,
0x4F => .Numpad1,
0x50 => .Numpad2,
0x51 => .Numpad3,
0x52 => .Numpad0,
0x53 => .NumpadPoint,
0x56 => .RightOfLeftShift,
0x57 => .F11,
0x58 => .F12,
else => {
os.log("PS2: Unhandled scancode 0x{X}\n", .{scancode});
return error.UnknownScancode;
},
};
},
.Extended => {
return switch(scancode) {
0x10 => .MediaRewind,
0x19 => .MediaForward,
0x20 => .MediaMute,
0x1C => .NumpadEnter,
0x1D => .RightCtrl,
0x22 => .MediaPausePlay,
0x24 => .MediaStop,
0x2E => .MediaVolumeDown,
0x30 => .MediaVolumeUp,
0x35 => .NumpadDivision,
0x38 => .RightAlt,
0x47 => .Home,
0x48 => .ArrowUp,
0x49 => .PageUp,
0x4B => .ArrowLeft,
0x4D => .ArrowRight,
0x4F => .End,
0x50 => .ArrowDown,
0x51 => .PageDown,
0x52 => .Insert,
0x53 => .Delete,
0x5B => .LeftSuper,
0x5C => .RightSuper,
0x5D => .OptionKey,
else => {
os.log("PS2: Unhandled extended scancode 0x{X}\n", .{scancode});
return error.UnknownScancode;
},
};
},
}
} | src/platform/x86_64/ps2.zig |
const std = @import("std");
const math = std.math;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const mat = @import("zalgebra");
const mat4 = mat.mat4;
const vec = mat.vec3;
const log = std.log;
var c_allocator = std.heap.c_allocator;
const roundUp = @import("main.zig").roundUp;
const load_ply = @import("load_ply.zig");
const load_adf = @import("load_adf.zig");
const Vertex = load_ply.Vertex;
// TODO: handle restrictive maxImageDimension2D
const texwidth = 16384;
const valwidth = texwidth * valres;
pub const valres = 4;
pub const valcount = valres * valres * valres;
pub const subdiv = 2;
pub const childcount = subdiv * subdiv * subdiv;
const fork_depth = 2;
pub var max_depth: u32 = 5;
const padding = 0.1;
pub const ChildRefs = [childcount]i32;
pub const MaterialInfo = u32;
pub const SerialModel = struct {
tree: []ChildRefs,
values: []u8,
material: []MaterialInfo,
width: u32,
height: u32,
pub fn deinit(self: @This(), allocator: *Allocator) void {
allocator.free(self.tree);
allocator.free(self.material);
allocator.free(self.values);
}
};
const Ref = union(enum) {
full_node: usize,
leaf_node: usize,
parallel_result: usize,
none: void,
};
pub const OctNode = struct {
children: [childcount]Ref = [_]Ref{.none} ** childcount,
values: [valcount]u8 = [_]u8{0} ** valcount,
material: MaterialInfo = 0xff00ff00, // pink for missing material
};
const Task = struct {
const Self = @This();
handle: *Thread,
node_mem: *ArrayList(OctNode),
leaf_mem: *ArrayList([valcount]u8),
vertex_mem: []Vertex,
// used for linearizing
node_offset: usize = 0,
leaf_offset: usize = 0,
const Params = struct {
vertices: []Vertex,
depth: i32,
pos: vec,
center_value: f32,
node_mem_ref: *ArrayList(OctNode),
leaf_mem_ref: *ArrayList([valcount]u8),
vertex_mem_ref: []Vertex,
};
fn launch(vertices: []const Vertex, depth: i32, pos: vec, center_value: f32) !Self {
const allocator = c_allocator;
var self = Self{
.handle = undefined,
.node_mem = try allocator.create(ArrayList(OctNode)),
.leaf_mem = try allocator.create(ArrayList([valcount]u8)),
.vertex_mem = try allocator.alloc(Vertex, vertices.len * (max_depth - fork_depth + 1))
};
self.node_mem.* = ArrayList(OctNode).init(allocator);
self.leaf_mem.* = ArrayList([valcount]u8).init(allocator);
std.mem.copy(Vertex, self.vertex_mem, vertices);
self.handle = try Thread.spawn(Params{
.vertices = self.vertex_mem[0..vertices.len],
.depth = depth,
.pos = pos,
.center_value = center_value,
.node_mem_ref = self.node_mem,
.leaf_mem_ref = self.leaf_mem,
.vertex_mem_ref = self.vertex_mem,
}, launched);
return self;
}
fn launched(context: Params) void {
forked = true;
midnodes = context.node_mem_ref;
leaves = context.leaf_mem_ref;
possibleCount = context.vertices.len;
possibleBuffer = context.vertex_mem_ref;
defer c_allocator.free(possibleBuffer);
_ = construct(context.vertices, context.depth, context.pos, context.center_value)
catch @panic("TODO: Pass error back to parent thread");
}
fn wait(self: *Self) void {
self.handle.wait();
}
fn deinit(self: *Self) void {
var allocator = c_allocator;
self.node_mem.deinit();
c_allocator.destroy(self.node_mem);
self.leaf_mem.deinit();
c_allocator.destroy(self.leaf_mem);
}
};
pub fn load(allocator: *Allocator, path: []const u8) !SerialModel {
const stdout = std.io.getStdOut().writer();
var start = std.time.milliTimestamp();
if (std.mem.endsWith(u8, path, ".adf")) {
const adf = try load_adf.load(allocator, path);
log.info("Loaded {s} in {} ms\n", .{ path, std.time.milliTimestamp() - start });
return adf;
}
var m = gen: {
var verts: []Vertex = undefined;
if (!std.mem.endsWith(u8, path, ".ply")) {
return error.FormatNotSupported;
}
verts = try load_ply.load(allocator, path);
defer allocator.free(verts);
log.info("Loaded {s} in {} ms\n", .{ path, std.time.milliTimestamp() - start });
start = std.time.milliTimestamp();
var mdl = try sdfGen(allocator, verts);
log.info("Generated adf in {} ms\n", .{std.time.milliTimestamp() - start});
break :gen mdl;
};
const saveto = try std.mem.join(allocator, ".", &[_][]const u8{ path[0..(path.len - 4)], "adf" });
defer allocator.free(saveto);
try load_adf.save(m, saveto);
return m;
}
threadlocal var midnodes: *ArrayList(OctNode) = undefined;
threadlocal var leaves: *ArrayList([valcount]u8) = undefined;
var parallel_tasks: ArrayList(Task) = undefined;
pub fn sdfGen(allocator: *Allocator, vertices: []Vertex) !SerialModel { // (Vertex *raw_vertices, int32_t vertexcount, int32_t depth)
normalize(vertices);
var node_mem = ArrayList(OctNode).init(allocator);
defer node_mem.deinit();
midnodes = &node_mem;
var leaf_mem = ArrayList([valcount]u8).init(allocator);
defer leaf_mem.deinit();
leaves = &leaf_mem;
parallel_tasks = ArrayList(Task).init(allocator);
defer {
for (parallel_tasks.items) |*p| {
p.deinit();
}
parallel_tasks.deinit();
}
{
possibleBuffer = try allocator.alloc(Vertex, vertices.len * (fork_depth + 1));
defer allocator.free(possibleBuffer);
_ = try construct(vertices, 0, vec.zero(), 2);
}
const tasks = parallel_tasks.items;
var node_offset = midnodes.items.len;
for (tasks) |*p| {
p.wait();
p.node_offset = node_offset;
node_offset += p.node_mem.items.len;
}
var leaf_offset = node_offset + leaves.items.len;
for (tasks) |*p| {
p.leaf_offset = leaf_offset;
leaf_offset += p.leaf_mem.items.len;
}
var octree = try allocator.alloc(ChildRefs, node_offset);
const material_mem = try allocator.alloc(MaterialInfo, node_offset);
const height = roundUp(@intCast(u32, leaf_offset), texwidth / valres) * valres;
const pixelData = try allocator.alloc(u8, valwidth * height);
errdefer allocator.free(pixelData);
linearize(midnodes.items, leaves.items, 0, node_offset,
octree, material_mem, pixelData);
for (tasks) |p| {
linearize(p.node_mem.items, p.leaf_mem.items,
p.node_offset, p.leaf_offset,
octree, material_mem, pixelData);
}
log.debug("\nmid nodes {}\nleaf nodes {}\n",
.{ node_offset, leaf_offset - node_offset}
);
return SerialModel{
.tree = octree,
.values = pixelData,
.material = material_mem,
.width = texwidth,
.height = height,
};
}
/// modifies vertices so that their coordinates are within a range of [-1,1].
fn normalize(vertices: []Vertex) void {
for (vertices) |*vert| {
vert.Position.y *= -1;
vert.Position.z *= -1;
vert.Normal.y *= -1;
vert.Normal.z *= -1;
}
var lower = vec.one().scale(math.inf(f32));
var higher = vec.one().scale(-math.inf(f32));
for (vertices) |vert| {
lower = vec.min(lower, vert.Position);
higher = vec.max(higher, vert.Position);
}
const extent = higher.sub(lower);
const size = math.max(extent.x, math.max(extent.y, extent.z));
const padded_size = size * (1 + padding);
const padded_base = lower.sub(vec.one().scale(0.5 * padding * size)); //.add(vec.one().scale(0.003));
for (vertices) |*vert| {
vert.Position = vert.Position.sub(padded_base).scale(1 / padded_size);
}
}
fn linearize(
nodes: []OctNode,
leav: [][valcount]u8,
node_start: usize,
leaf_start: usize,
octree: []ChildRefs,
material: []MaterialInfo,
pixelData: []u8
) void {
const tasks = parallel_tasks.items;
for (nodes) |node, k| {
const i = k + node_start;
for (octree[i]) |*treenode, j| {
treenode.* = switch (node.children[j]) {
.full_node => |index| @intCast(i32, node_start + index),
.leaf_node => |index| @intCast(i32, leaf_start + index),
.parallel_result => |task| @intCast(i32, tasks[task].node_offset),
.none => -1,
};
}
material[i] = node.material;
const val = node.values;
mapValToTexture(pixelData, node.values, i);
}
for (leav) |val, leafi| {
const i = leafi + leaf_start;
mapValToTexture(pixelData, val, i);
}
}
fn mapValToTexture(tex: []u8, v: [valcount]u8, i: usize) void {
// black magic index juggling
const texbase = valres * valwidth * (valres * valres * i / valwidth)
+ valres * valres * i % valwidth;
var x: usize = 0;
while (x < valres) : (x += 1) {
var y: usize = 0;
while (y < valres) : (y += 1) {
var z: usize = 0;
while (z < valres) : (z += 1) {
const vali = x + y * valres + z * valres * valres;
const texi = texbase + z + x * valres + y * valwidth;
tex[texi] = v[vali];
}
}
}
}
const ConstructError = Allocator.Error || Thread.SpawnError;
threadlocal var forked = false; // this is disgusting
fn construct(vertices: []const Vertex, depth: i32, pos: vec, center_value: f32) ConstructError!Ref {
if (depth == fork_depth and !forked) {
try parallel_tasks.append(try Task.launch(vertices, depth, pos, center_value));
return Ref{ .parallel_result = parallel_tasks.items.len - 1 };
}
const scale = math.pow(f32, 0.5, @intToFloat(f32, depth));
const center = pos.add(vec.one().scale(0.5 * scale));
const start = possibleCount;
var possible = getPossible(center, center_value + @sqrt(3.0) / 2.0 * scale, vertices);
defer possibleCount = start; // Not nice, but efficient.
var values = discreteDistances(pos, scale, possible);
if (depth >= max_depth) {
try leaves.append(values);
return Ref{ .leaf_node = leaves.items.len - 1 };
}
var this = try genChildren(pos, scale / subdiv, possible, depth);
switch (this) {
.leaf_node =>
try leaves.append(values),
.full_node => |f| {
midnodes.items[f].values = values;
midnodes.items[f].material = vecToRgba(vec.one().sub(pos));//0x77cc44aa;
},
else => {}
}
return this;
}
fn vecToRgba(v: vec) u32 {
const assert = std.debug.assert;
const r = @floatToInt(u32, v.x * 255);
assert(r < 256);
const g = @floatToInt(u32, v.y * 255);
assert(g < 256);
const b = @floatToInt(u32, v.z * 255);
assert(b < 256);
const a = @as(u32, 128);
return (r << 24) + (g << 16) + (b << 8) + a;
}
fn genChildren(pos: vec, subscale: f32, possible: []const Vertex, depth: i32) ConstructError!Ref {
var has_children = false;
var this: usize = 0;
var i: usize = 0;
while (i < childcount) : (i += 1) {
const subpos = pos.add(splitChildIndex(i).scale(subscale));
const subcenter = subpos.add(vec.one().scale(0.5 * subscale));
const subcenter_value = trueDistanceAt(subcenter, possible);
if (subcenter_value < subscale * @sqrt(3.0) or depth <= fork_depth + 1) {
if (!has_children) {
has_children = true;
this = midnodes.items.len;
try midnodes.append(OctNode{});
}
const child_p = try construct(possible, depth + 1, subpos, subcenter_value);
midnodes.items[this].children[i] = child_p;
}
}
if (has_children) {
return Ref{ .full_node = this };
} else {
return Ref{ .leaf_node = leaves.items.len };
}
}
fn splitValueIndex(i: usize) vec {
return vec.new(
@intToFloat(f32, i % valres) / (valres - 1),
@intToFloat(f32, (i / valres) % valres) / (valres - 1),
@intToFloat(f32, (i / valres / valres) % valres) / (valres - 1),
);
}
fn splitChildIndex(i: usize) vec {
return vec.new(
@intToFloat(f32, i % subdiv) / (subdiv - 1),
@intToFloat(f32, (i / subdiv) % subdiv) / (subdiv - 1),
@intToFloat(f32, (i / subdiv / subdiv) % subdiv) / (subdiv - 1),
);
}
threadlocal var possibleBuffer: []Vertex = undefined;
threadlocal var possibleCount: usize = 0;
fn getPossible(p: vec, minDistance: f32, possible: []const Vertex) []const Vertex {
const start = possibleCount;
var minSquared = minDistance; // * global_scale;
minSquared *= minSquared;
for (possible) |vert| {
const delta = vert.Position.sub(p);
if (delta.dot(delta) < minSquared) {
possibleBuffer[possibleCount] = vert;
possibleCount += 1;
}
}
return possibleBuffer[start..possibleCount];
}
fn trueDistanceAt(p: vec, vertices: []const Vertex) f32 {
var minDistance = math.inf(f32);
for (vertices) |v| {
const delta = v.Position.sub(p);
if (delta.dot(delta) < minDistance) {
minDistance = delta.dot(delta);
}
}
if (math.isInf(minDistance) or math.isNan(minDistance))
@panic("Invalid vertices");
return @sqrt(minDistance);
}
const from: f32 = -1;
const to: f32 = 3;
fn discreteDistances(pos: vec, scale: f32, possible: []const Vertex) [valcount]u8 {
var res: [valcount]u8 = undefined;
for (res) |*r, i| {
const value = distanceAt(pos.add(splitValueIndex(i).scale(scale)), possible);
const v = (value / scale - from) / (to - from);
r.* = @floatToInt(u8, std.math.clamp(v, 0, 1) * 255);
}
return res;
}
fn distanceAt(p: vec, vertices: []const Vertex) f32 {
var closest: Vertex = undefined;
var minDistance = math.inf(f32);
for (vertices) |v| {
const delta = v.Position.sub(p);
if (delta.dot(delta) < minDistance) {
minDistance = delta.dot(delta);
closest = v;
}
}
if (math.isInf(minDistance) or math.isNan(minDistance))
@panic("Invalid vertices");
minDistance = @sqrt(minDistance);
if (minDistance < 0.02) {
minDistance = closest.Normal.scale(1 / closest.Normal.length()).dot(p.sub(closest.Position));
} else if (inside(p, closest)) {
minDistance *= -1;
}
return minDistance;
}
fn inside(p: vec, closest: Vertex) bool {
return closest.Normal.dot(closest.Position.sub(p)) > 0;
} | src/model.zig |
const std = @import("std");
const msgpack = @import("msgpack.zig");
const Value = msgpack.Value;
const deserialize = msgpack.deserialize;
const toVal = msgpack.toVal;
const serializeList = msgpack.serializeList;
test "serializes and deserializes f32, and f64" {
// Serializing
const expected = &[_]u8{
148, 202, 68, 13, 248,
229, 202, 196, 13, 248,
229, 203, 65, 33, 84,
141, 135, 43, 2, 12,
203, 193, 33, 84, 141,
135, 43, 2, 12,
};
const serialized = try msgpack.serializeList(std.testing.allocator, &[_]Value{
toVal(567.889, f32),
toVal(-567.889, f32),
toVal(567878.764, f64),
toVal(-567878.764, f64),
});
defer serialized.deinit();
std.testing.expectEqualSlices(u8, serialized.items, expected);
// Deserializing
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer allocator.deinit();
const deserialized = (try deserialize(&allocator, serialized.items)).Array;
std.testing.expectEqual(deserialized[0].Float32, 567.889);
std.testing.expectEqual(deserialized[1].Float32, -567.889);
std.testing.expectEqual(deserialized[2].Float64, 567878.764);
std.testing.expectEqual(deserialized[3].Float64, -567878.764);
}
test "deserializes u8, u16, u32, u64" {
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer allocator.deinit();
const expected: []const Value = &[_]Value{
toVal(8, u8),
toVal(7699, u16),
toVal(7870887, u32),
toVal(8798787097890789, u64),
};
const byte_list = try msgpack.serializeList(std.testing.allocator, expected);
defer byte_list.deinit();
const deserialized = (try deserialize(&allocator, byte_list.items)).Array;
var i: usize = 0;
while (i < expected.len) : (i += 1) {
std.testing.expectEqual(expected[i], deserialized[i]);
}
}
test "deserializes fixarray" {
std.testing.log_level = std.log.Level.debug;
const expected: Value = toVal(&[_]Value{
toVal("hello", []const u8),
toVal("goodbye", []const u8),
toVal(6, i8),
}, []const Value);
var serialized = try serializeList(std.testing.allocator, expected.Array);
const bytes = serialized.toOwnedSlice();
defer std.testing.allocator.free(bytes);
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer allocator.deinit();
const deserialized = try deserialize(&allocator, bytes);
std.testing.expectEqual(deserialized.Array.len, expected.Array.len);
std.testing.expectEqualStrings(deserialized.Array[0].String, expected.Array[0].String);
std.testing.expectEqualStrings(deserialized.Array[1].String, expected.Array[1].String);
std.testing.expectEqual(deserialized.Array[2].Int8, expected.Array[2].Int8);
}
test "deserializes negative fixnum" {
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
const deserialized = try deserialize(&allocator, &[_]u8{
// -32 in msgpack, so right at the boundary of what a negative fixint
// can be (any less and it would be an int8).
224});
const expected: i8 = -32;
std.testing.expectEqual(expected, deserialized.Int8);
}
test "deserializes array32 with fixnums" {
std.testing.log_level = std.log.Level.debug;
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer allocator.deinit();
const deserialized = try deserialize(&allocator, &[_]u8{
221, 0, 0, 0, 3, 1, 2, 3,
});
const expected = &[_]Value{
toVal(1, i8),
toVal(2, i8),
toVal(3, i8),
};
var i: usize = 0;
while (i < expected.len) : (i += 1) {
std.testing.expectEqual(expected[i].Int8, deserialized.Array[i].Int8);
}
}
test "deserializes 'hello'" {
std.testing.log_level = std.log.Level.debug;
var allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer allocator.deinit();
const val = try deserialize(&allocator, &[_]u8{
165, 104, 101, 108, 108, 111,
});
var i: usize = 0;
const expected_bytes = "hello";
while (i < expected_bytes.len) : (i += 1) {
std.testing.expectEqual(expected_bytes[i], val.String[i]);
}
}
test "serialization" {
var test_allocator = std.testing.allocator;
var a = std.heap.ArenaAllocator.init(test_allocator);
defer a.deinit();
var map = std.StringHashMap(Value).init(test_allocator);
defer map.deinit();
try map.put("stuff", toVal(5, i8));
try map.put("stuff more", toVal(-200.9877, f32));
try map.put("stuff more more", toVal("wassup yo?", []const u8));
try map.put("stuff more more more", toVal(false, null));
const val = try serializeList(test_allocator, &[_]Value{
toVal(map, null),
toVal(64, i8),
toVal(true, null),
toVal(832, u16),
toVal(&[_]Value{
toVal(false, null),
toVal("hello there", []const u8),
toVal(&[_]Value{
toVal("Even more nesting", []const u8),
toVal(567, i16),
toVal(false, null),
toVal(null, null),
}, []const Value),
}, []const Value),
});
defer val.deinit();
// std.debug.warn("[", .{});
// for (val.items) |item| {
// std.debug.warn("{}, ", .{item});
// }
// std.debug.warn("]\n", .{});
} | src/msgpack_test.zig |
const std = @import("std");
const bottom = @import("bottom");
const args = @import("zig-args");
const builtin = @import("builtin");
const build_options = @import("build_options");
const help_text = @embedFile("help.txt");
const bufferSize = 128 * 1024;
const newline = if(builtin.os.tag == .windows) "\r\n" else "\n";
/// We create options similar to bottom RS
const Options = struct {
bottomiffy: ?bool = null,
help: bool = false,
regress: ?bool = null,
version: bool = false,
input: ?[]const u8 = null,
output: ?[]const u8 = null,
pub const shorthands = .{
.b = "bottomiffy",
.h = "help",
.r = "regress",
.V = "version",
.i = "input",
.o = "output",
};
};
pub fn main() void {
if(builtin.os.tag == .windows) {
if (std.os.windows.kernel32.SetConsoleOutputCP(65001) == 0) {
std.log.err("Your windows console does not support UTF-8, try using Windows Terminal at: {s}", .{"https://apps.microsoft.com/store/detail/windows-terminal/9N0DX20HK701?hl=en-us&gl=US"});
std.os.exit(5);
}
}
consoleApp() catch |err| {
std.log.err("The program exited with the following error: {}", .{err});
std.log.err("if you are writting to terminal, see if you can write to it normal, if your are pointing to a file, please check you have enough space or the right permissions", .{});
};
}
pub fn consoleApp() !void {
var allocator: std.mem.Allocator = undefined;
var arena: std.heap.ArenaAllocator = undefined;
defer arena.deinit();
if (build_options.use_c) {
arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
} else {
var generalPurpose = std.heap.GeneralPurposeAllocator(.{}){};
arena = std.heap.ArenaAllocator.init(generalPurpose.allocator());
}
allocator = arena.allocator();
errdefer arena.deinit();
const options = args.parseForCurrentProcess(Options, allocator, .print) catch return std.os.exit(1);
defer options.deinit();
var stderr = std.io.getStdErr();
defer stderr.close();
errdefer stderr.close();
if (options.options.help) {
try help();
std.os.exit(0);
}
if (options.options.version) {
try version();
std.os.exit(0);
}
if (options.options.bottomiffy == null and options.options.regress == null) {
try help();
try stderr.writer().writeAll("You have to specify either bottomify or regress OwO");
std.os.exit(1);
}
var bottomiffy_option: bool = options.options.bottomiffy orelse false;
var regress_option: bool = options.options.regress orelse false;
if (bottomiffy_option and regress_option) {
try help();
try stderr.writer().writeAll("You cannot use both bottomify and regress UwU");
std.os.exit(1);
}
var inputFile = std.io.getStdIn();
errdefer inputFile.close();
defer inputFile.close();
var outputFile = std.io.getStdOut();
errdefer outputFile.close();
defer outputFile.close();
if (options.options.input) |path| {
inputFile = std.fs.cwd().openFile(path, std.fs.File.OpenFlags{}) catch std.os.exit(2);
}
if (options.options.output) |path| {
outputFile = std.fs.cwd().createFile(path, std.fs.File.CreateFlags{}) catch std.os.exit(2);
}
if (bottomiffy_option) {
try bottomiffy(inputFile, outputFile);
}
if (regress_option) {
try regress(inputFile, outputFile);
}
std.os.exit(0);
}
pub fn bottomiffy(fileInput: std.fs.File, fileOutput: std.fs.File) !void {
var bufferInput: std.io.BufferedReader(bufferSize, std.fs.File.Reader) = .{ .unbuffered_reader = fileInput.reader() };
var bufferOut: std.io.BufferedWriter(bufferSize * bottom.encoder.max_expansion_per_byte, std.fs.File.Writer) = .{ .unbuffered_writer = fileOutput.writer() };
var bufferBottom: [bufferSize * bottom.encoder.max_expansion_per_byte]u8 = undefined;
var buffer: [bufferSize]u8 = undefined;
var size: usize = 1;
defer bufferOut.flush() catch |err| {
std.log.err("Error while flushing output: {}", .{err});
std.os.exit(3);
};
if (fileInput.handle == std.io.getStdIn().handle) {
var stdin_buffer = bufferInput.reader().readUntilDelimiter(&buffer, '\n') catch |err| {
std.log.err("Error while reading input from stdin: {}, the max buffer size on console is {d}", .{ err, bufferSize });
std.os.exit(1);
};
var outbuffer: []u8 = bottom.encoder.encode(stdin_buffer[0..stdin_buffer.len - (newline.len - 1)], &bufferBottom);
_ = try bufferOut.writer().writeAll(outbuffer);
if (fileOutput.handle == std.io.getStdOut().handle) {
_ = try bufferOut.writer().write(newline);
}
buffer = undefined;
bufferBottom = undefined;
return;
}
while (size != 0) {
size = try bufferInput.read(&buffer);
if (size > 0) {
var outbuffer: []u8 = bottom.encoder.encode(buffer[0 .. size - 1], &bufferBottom);
_ = try bufferOut.writer().writeAll(outbuffer);
buffer = undefined;
bufferBottom = undefined;
}
}
}
pub fn regress(fileInput: std.fs.File, fileOutput: std.fs.File) !void {
var bufferInput: std.io.BufferedReader(bufferSize, std.fs.File.Reader) = .{ .unbuffered_reader = fileInput.reader() };
var bufferOut: std.io.BufferedWriter(bufferSize * bottom.encoder.max_expansion_per_byte, std.fs.File.Writer) = .{ .unbuffered_writer = fileOutput.writer() };
var bufferRegress: [bufferSize * bottom.encoder.max_expansion_per_byte]u8 = undefined;
var buffer: [bufferSize]u8 = undefined;
var temp: []u8 = &@as([1]u8, undefined);
defer bufferOut.flush() catch |err| {
std.log.err("Error while flushing output: {}", .{err});
std.os.exit(3);
};
if (fileInput.handle == std.io.getStdIn().handle) {
var stdin_buffer = bufferInput.reader().readUntilDelimiter(&buffer, '\n') catch |err| {
std.log.err("Error while reading input from stdin: {}, the max buffer size on console is {d}", .{ err, bufferSize });
std.os.exit(1);
};
var outbuffer: []u8 = bottom.decoder.decode(stdin_buffer[0..stdin_buffer.len - (newline.len - 1)], bufferRegress[0..(buffer.len/bottom.encoder.max_expansion_per_byte - 1 ) * 2 ]) catch |err| {
std.log.err("Error while decoding input from stdin: {}", .{ err });
std.os.exit(1);
};
_ = try bufferOut.writer().writeAll(outbuffer);
if (fileOutput.handle == std.io.getStdOut().handle) {
_ = try bufferOut.writer().write(newline);
}
buffer = undefined;
bufferRegress = undefined;
return;
}
while (temp.len != 0) {
temp = (try bufferInput.reader().readUntilDelimiterOrEof(&buffer, "👈"[4])) orelse &@as([0]u8, undefined);
if (temp.len > 0) {
var outbuffer: u8 = bottom.decoder.decodeByte(temp[0 .. temp.len - 7]) orelse {
std.log.err("Error while decoding input from stdin: {}", .{ error.invalid_input });
std.os.exit(1);
};
_ = try bufferOut.writer().writeByte(outbuffer);
buffer = undefined;
bufferRegress = undefined;
}
}
}
pub fn help() !void {
try std.io.getStdOut().writer().writeAll(help_text);
}
pub fn version() !void {
try std.io.getStdOut().writer().writeAll(build_options.version);
} | src/main.zig |
const std = @import("std");
pub const CBaseEntity = opaque {};
pub const IServerUnknown = opaque {};
pub const IHandleEntity = opaque {};
pub const PVSInfo = opaque {};
pub const CreateInterfaceFn = fn (name: [*:0]const u8, ret: ?*c_int) callconv(.C) ?*align(@alignOf(*anyopaque)) anyopaque;
pub const ServerClass = opaque {};
pub const CBaseNetworkable = opaque {};
pub const CCommand = opaque {};
pub const Color = extern struct {
r: u8,
g: u8,
b: u8,
a: u8 = 255,
};
pub const CvarDLLIdentifier = c_int;
pub const ConCommandBase = opaque {};
pub const FontDrawType = enum(c_int) {
default,
nonadditive,
additive,
};
pub const wchar = switch (@import("builtin").os.tag) {
.windows => u16,
else => u32,
};
pub const HFont = u32;
pub const Vpanel = u32;
pub const InputContextHandle = ?*opaque {};
pub const VGuiPanel = enum(c_int) {
root,
gameui_dll,
client_dll,
tools,
in_game_screens,
game_dll,
client_dll_tools,
gameui_background,
puzzlemaker,
transition_effect,
steam_overlay,
};
pub const InputEvent = opaque {};
pub const PaintMode = packed struct {
ui_panels: bool,
in_game_panels: bool,
};
pub const LevelLoadingProgress = enum(c_int) {
none,
changelevel,
spawnserver,
loadworldmodel,
crcmap,
crcclientdll,
createnetworkstringtables,
precacheworld,
clearworld,
levelinit,
precache,
activateserver,
beginconnect,
signonchallenge,
signonconnect,
signonconnected,
processserverinfo,
processstringtable,
signonnew,
sendclientinfo,
sendsignondata,
createentities,
fullyconnected,
precachelighting,
readytoplay,
};
pub const IntRect = extern struct {
x0: c_int,
y0: c_int,
x1: c_int,
y1: c_int,
};
pub const QueryCvarCookie = c_int;
pub const QueryCvarValueStatus = enum(c_int) {
value_intact,
cvar_not_found,
not_a_cvar,
cvar_protected,
};
pub const SurfaceFeature = enum(c_int) {
antialiased_fonts = 1,
dropshadow_fonts = 2,
escape_key = 3,
opening_new_html_windows = 4,
frame_minimize_maximize = 5,
outline_fonts = 6,
direct_hwnd_render = 7,
};
pub const IHTMLEvents = opaque {};
pub const IHTML = opaque {};
pub const HCursor = u32;
pub const HTexture = u32;
pub const Vertex = extern struct {
position: Vector2D,
tex_coord: Vector2D,
};
pub const Vector2D = extern struct {
x: f32,
y: f32,
};
pub const FontCharRenderInfo = opaque {};
pub const IVguiMatInfo = opaque {};
pub const ImageFormat = c_int; // TODO: this is really an enum but it's fucking huge
pub const IImage = opaque {};
pub const DrawTexturedRectParms = extern struct {
x0: c_int,
y0: c_int,
x1: c_int,
y1: c_int,
s0: f32,
t0: f32,
s1: f32,
t1: f32,
alpha_ul: u8,
alpha_ur: u8,
alpha_lr: u8,
alpha_ll: u8,
angle: f32,
};
pub const Vector3D = extern struct {
x: f32,
y: f32,
z: f32,
};
pub const QAngle = extern struct {
pitch: f32,
yaw: f32,
roll: f32,
};
pub const Model = opaque {}; // model_t
pub const SurfInfo = struct {
verts: [16]Vector3D,
nverts: c_ulong,
plane: VPlane,
engine_data: *anyopaque,
};
pub const VPlane = struct {
normal: Vector3D,
dist: f32,
};
pub const IMaterial = opaque {};
pub const IClientEntity = opaque {};
pub const IServerEntity = opaque {};
pub const CEntityRespawnInfo = extern struct {
hammer_id: c_int,
ent_text: [*:0]const u8,
};
pub const CGlobalVars = opaque {}; | sdk/misc.zig |
const std = @import("std");
const print = std.debug.print;
const testing = std.testing;
const assert = std.debug.assert;
//assume base >= 0
fn isValidNumber(comptime UT: type, cust_nr: []UT, base: UT) bool {
for (cust_nr) |m_el| {
if (m_el >= base)
return false;
}
return true;
}
fn isNotNull(comptime UT: type, cust_nr: []const UT) bool {
for (cust_nr) |m_el| {
if (m_el != 0) {
return true;
}
}
return false;
}
// on successfull addition return true, otherwise false
fn add(comptime UT: type, cust_nr: []UT, base: UT) bool {
var carry = false;
var index: u32 = @intCast(u32, cust_nr.len - 1);
while (index > 0) : (index -= 1) {
var added_val = cust_nr[index] + 1;
if (added_val == base) {
carry = true;
} else {
cust_nr[index] = added_val;
break;
}
}
// prevent index underflow
if (index == 0 and carry == true and cust_nr[index] + 1 == base) {
return false; // could not increase anymore
}
// zero out numbers right of the index
if (carry == true) {
std.debug.assert(index < cust_nr.len - 1);
index += 1;
while (index < cust_nr.len) : (index += 1) {
cust_nr[index] = 0;
}
}
return true;
}
test "isValidNumber" {
const base: u32 = 4;
var mem_array = [_]u32{ 1, 2, 3 };
var is_val_nr = isValidNumber(u32, &mem_array, base);
try testing.expectEqual(true, is_val_nr);
}
test "isNull" {
var mem_array1 = [_]u32{ 0, 0, 0 };
var is_not_null = isNotNull(u32, &mem_array1);
try testing.expectEqual(false, is_not_null);
var mem_array2 = [_]u32{ 1, 1, 1 };
is_not_null = isNotNull(u32, &mem_array2);
try testing.expectEqual(true, is_not_null);
}
test "add" {
const base: u32 = 4;
var mem_array = [_]u32{ 1, 2, 3 };
const result = add(u32, &mem_array, base);
const exp_mem_array = [_]u32{ 1, 3, 0 };
try testing.expectEqual(exp_mem_array, mem_array);
try testing.expectEqual(true, result);
mem_array = [_]u32{ 3, 3, 3 };
const result2 = add(u32, &mem_array, base);
try testing.expectEqual(mem_array, mem_array);
try testing.expectEqual(false, result2);
} | src/customNumberSystem.zig |
const std = @import("std");
const builtin = @import("builtin");
const minInt = std.math.minInt;
const maxInt = std.math.maxInt;
const expect = std.testing.expect;
test "saturating add" {
const S = struct {
fn doTheTest() !void {
try testSatAdd(i8, -3, 10, 7);
try testSatAdd(i8, 3, -10, -7);
try testSatAdd(i8, -128, -128, -128);
try testSatAdd(i2, 1, 1, 1);
try testSatAdd(i2, 1, -1, 0);
try testSatAdd(i2, -1, -1, -2);
try testSatAdd(i64, maxInt(i64), 1, maxInt(i64));
try testSatAdd(i128, maxInt(i128), -maxInt(i128), 0);
try testSatAdd(i128, minInt(i128), maxInt(i128), -1);
try testSatAdd(i8, 127, 127, 127);
try testSatAdd(u2, 0, 0, 0);
try testSatAdd(u2, 0, 1, 1);
try testSatAdd(u8, 3, 10, 13);
try testSatAdd(u8, 255, 255, 255);
try testSatAdd(u2, 3, 2, 3);
try testSatAdd(u3, 7, 1, 7);
try testSatAdd(u128, maxInt(u128), 1, maxInt(u128));
}
fn testSatAdd(comptime T: type, lhs: T, rhs: T, expected: T) !void {
try expect((lhs +| rhs) == expected);
var x = lhs;
x +|= rhs;
try expect(x == expected);
}
};
try S.doTheTest();
comptime try S.doTheTest();
comptime try S.testSatAdd(comptime_int, 0, 0, 0);
comptime try S.testSatAdd(comptime_int, -1, 1, 0);
comptime try S.testSatAdd(comptime_int, 3, 2, 5);
comptime try S.testSatAdd(comptime_int, -3, -2, -5);
comptime try S.testSatAdd(comptime_int, 3, -2, 1);
comptime try S.testSatAdd(comptime_int, -3, 2, -1);
comptime try S.testSatAdd(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 1119305249183743626545271163355074748512);
comptime try S.testSatAdd(comptime_int, 7, -593423721213448152027139550640105366508, -593423721213448152027139550640105366501);
}
test "saturating subtraction" {
const S = struct {
fn doTheTest() !void {
try testSatSub(i8, -3, 10, -13);
try testSatSub(i8, -3, -10, 7);
try testSatSub(i8, -128, -128, 0);
try testSatSub(i8, -1, 127, -128);
try testSatSub(i2, 1, 1, 0);
try testSatSub(i2, 1, -1, 1);
try testSatSub(i2, -2, -2, 0);
try testSatSub(i64, minInt(i64), 1, minInt(i64));
try testSatSub(i128, maxInt(i128), -1, maxInt(i128));
try testSatSub(i128, minInt(i128), -maxInt(i128), -1);
try testSatSub(u2, 0, 0, 0);
try testSatSub(u2, 0, 1, 0);
try testSatSub(u5, 0, 31, 0);
try testSatSub(u8, 10, 3, 7);
try testSatSub(u8, 0, 255, 0);
try testSatSub(u128, 0, maxInt(u128), 0);
}
fn testSatSub(comptime T: type, lhs: T, rhs: T, expected: T) !void {
try expect((lhs -| rhs) == expected);
var x = lhs;
x -|= rhs;
try expect(x == expected);
}
};
try S.doTheTest();
comptime try S.doTheTest();
comptime try S.testSatSub(comptime_int, 0, 0, 0);
comptime try S.testSatSub(comptime_int, 1, 1, 0);
comptime try S.testSatSub(comptime_int, 3, 2, 1);
comptime try S.testSatSub(comptime_int, -3, -2, -1);
comptime try S.testSatSub(comptime_int, 3, -2, 5);
comptime try S.testSatSub(comptime_int, -3, 2, -5);
comptime try S.testSatSub(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 182846383813587550256162760261375991602);
comptime try S.testSatSub(comptime_int, 7, -593423721213448152027139550640105366508, 593423721213448152027139550640105366515);
}
test "saturating multiplication" {
// TODO: once #9660 has been solved, remove this line
if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
try testSatMul(i8, -3, 10, -30);
try testSatMul(i4, 2, 4, 7);
try testSatMul(i8, 2, 127, 127);
try testSatMul(i8, -128, -128, 127);
try testSatMul(i8, maxInt(i8), maxInt(i8), maxInt(i8));
try testSatMul(i16, maxInt(i16), -1, minInt(i16) + 1);
try testSatMul(i128, maxInt(i128), -1, minInt(i128) + 1);
try testSatMul(i128, minInt(i128), -1, maxInt(i128));
try testSatMul(u8, 10, 3, 30);
try testSatMul(u8, 2, 255, 255);
try testSatMul(u128, maxInt(u128), maxInt(u128), maxInt(u128));
}
fn testSatMul(comptime T: type, lhs: T, rhs: T, expected: T) !void {
try expect((lhs *| rhs) == expected);
var x = lhs;
x *|= rhs;
try expect(x == expected);
}
};
try S.doTheTest();
comptime try S.doTheTest();
comptime try S.testSatMul(comptime_int, 0, 0, 0);
comptime try S.testSatMul(comptime_int, 3, 2, 6);
comptime try S.testSatMul(comptime_int, 651075816498665588400716961808225370057, 468229432685078038144554201546849378455, 304852860194144160265083087140337419215516305999637969803722975979232817921935);
comptime try S.testSatMul(comptime_int, 7, -593423721213448152027139550640105366508, -4153966048494137064189976854480737565556);
}
test "saturating shift-left" {
const S = struct {
fn doTheTest() !void {
try testSatShl(i8, 1, 2, 4);
try testSatShl(i8, 127, 1, 127);
try testSatShl(i8, -128, 1, -128);
// TODO: remove this check once #9668 is completed
if (builtin.cpu.arch != .wasm32) {
// skip testing ints > 64 bits on wasm due to miscompilation / wasmtime ci error
try testSatShl(i128, maxInt(i128), 64, maxInt(i128));
try testSatShl(u128, maxInt(u128), 64, maxInt(u128));
}
try testSatShl(u8, 1, 2, 4);
try testSatShl(u8, 255, 1, 255);
}
fn testSatShl(comptime T: type, lhs: T, rhs: T, expected: T) !void {
try expect((lhs <<| rhs) == expected);
var x = lhs;
x <<|= rhs;
try expect(x == expected);
}
};
try S.doTheTest();
comptime try S.doTheTest();
comptime try S.testSatShl(comptime_int, 0, 0, 0);
comptime try S.testSatShl(comptime_int, 1, 2, 4);
comptime try S.testSatShl(comptime_int, 13, 150, 18554220005177478453757717602843436772975706112);
comptime try S.testSatShl(comptime_int, -582769, 180, -893090893854873184096635538665358532628308979495815656505344);
}
test "saturating shl uses the LHS type" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
const lhs_const: u8 = 1;
var lhs_var: u8 = 1;
const rhs_const: usize = 8;
var rhs_var: usize = 8;
try expect((lhs_const <<| 8) == 255);
try expect((lhs_const <<| rhs_const) == 255);
try expect((lhs_const <<| rhs_var) == 255);
try expect((lhs_var <<| 8) == 255);
try expect((lhs_var <<| rhs_const) == 255);
try expect((lhs_var <<| rhs_var) == 255);
try expect((@as(u8, 1) <<| 8) == 255);
try expect((@as(u8, 1) <<| rhs_const) == 255);
try expect((@as(u8, 1) <<| rhs_var) == 255);
try expect((1 <<| @as(u8, 200)) == 1606938044258990275541962092341162602522202993782792835301376);
} | test/behavior/saturating_arithmetic.zig |
const std = @import("std");
const pike = @import("pike.zig");
const posix = @import("os/posix.zig");
const os = std.os;
const net = std.net;
const mem = std.mem;
pub inline fn init() !void {}
pub inline fn deinit() void {}
pub const Handle = struct {
inner: os.fd_t,
wake_fn: fn (self: *Handle, batch: *pike.Batch, opts: pike.WakeOptions) void,
pub inline fn wake(self: *Handle, batch: *pike.Batch, opts: pike.WakeOptions) void {
self.wake_fn(self, batch, opts);
}
};
pub const Notifier = struct {
const Self = @This();
handle: i32,
pub fn init() !Self {
const handle = try os.epoll_create1(os.linux.EPOLL.CLOEXEC);
errdefer os.close(handle);
return Self{ .handle = handle };
}
pub fn deinit(self: *const Self) void {
os.close(self.handle);
}
pub fn register(self: *const Self, handle: *const Handle, comptime opts: pike.PollOptions) !void {
if (handle.inner == -1) return;
var events: u32 = os.linux.EPOLL.ET | os.linux.EPOLL.ERR | os.linux.EPOLL.RDHUP;
if (opts.read) events |= os.linux.EPOLL.IN;
if (opts.write) events |= os.linux.EPOLL.OUT;
_ = os.linux.epoll_ctl(self.handle, os.linux.EPOLL.CTL_ADD, handle.inner, &os.linux.epoll_event{
.events = events,
.data = .{ .ptr = @ptrToInt(handle) },
});
}
pub fn poll(self: *const Self, timeout: i32) !void {
var events: [128]os.linux.epoll_event = undefined;
var batch: pike.Batch = .{};
defer pike.dispatch(batch, .{});
const num_events = os.epoll_wait(self.handle, &events, timeout);
for (events[0..num_events]) |e| {
if (e.data.ptr == 0) continue;
const handle = @intToPtr(*Handle, e.data.ptr);
const shutdown = e.events & (os.linux.EPOLL.ERR | os.linux.EPOLL.RDHUP) != 0;
const read_ready = e.events & os.linux.EPOLL.IN != 0;
const write_ready = e.events & os.linux.EPOLL.OUT != 0;
handle.wake(&batch, .{
.shutdown = shutdown,
.read_ready = read_ready,
.write_ready = write_ready,
});
}
}
}; | notifier_epoll.zig |
const std = @import("std");
const prot = @import("protocols.zig");
const Focus = @import("focus.zig").Focus;
const CompositorOutput = @import("output.zig").CompositorOutput;
const Window = @import("window.zig").Window;
const compositor = @import("compositor.zig");
pub var CURRENT_VIEW: *View = undefined;
pub const View = struct {
output: ?*CompositorOutput,
top: ?*Window,
pointer_window: ?*Window,
active_window: ?*Window,
focus: Focus,
const Self = @This();
pub fn visible(self: *Self) bool {
return true;
}
pub fn back(self: *Self) ?*Window {
var it = self.top;
var window: ?*Window = null;
while (it) |w| : (it = w.toplevel.prev) {
window = w;
}
return window;
}
pub fn push(self: *Self, window: *Window) void {
if (self.top) |top| {
if (top == window) {
return;
}
top.toplevel.next = window;
window.toplevel.prev = top;
}
self.top = window;
}
pub fn remove(self: *Self, window: *Window) void {
if (self.top == window) {
self.top = window.toplevel.prev;
}
window.toplevel.deinit();
}
pub fn mouseClick(self: *Self, button: u32, action: u32) !void {
if (self.pointer_window) |pointer_window| {
if (action == 1) {
if (self.top != pointer_window.toplevelWindow()) {
self.raise(pointer_window.toplevelWindow());
}
if (pointer_window.toplevelWindow() != self.active_window) {
if (self.active_window) |active_window| {
try active_window.deactivate();
}
try pointer_window.activate();
self.active_window = pointer_window;
}
}
try pointer_window.mouseClick(button, action);
} else {
if (self.active_window) |active_window| {
if (action == 1) {
try active_window.deactivate();
self.active_window = null;
}
}
}
}
pub fn raise(self: *Self, raising_window: *Window) void {
// 1. iterate down, removing any marks
var it = self.top;
while (it) |window| : (it = window.toplevel.prev) {
window.toplevel.mark = false;
}
// 2. Raise our parent if it exists
if (raising_window.parent) |parent| {
// var root = pointer_window.root();
var parent_toplevel = parent.toplevelWindow();
parent.toplevel.mark = true;
self.remove(parent_toplevel);
self.push(parent_toplevel);
}
// 3. Raise our window
var raising_window_toplevel = raising_window.toplevelWindow();
self.remove(raising_window_toplevel);
self.push(raising_window_toplevel);
raising_window_toplevel.toplevel.mark = true;
// 4. Raise any of our children
it = self.back();
while (it) |window| : (it = window.toplevel.next) {
if (window.toplevel.mark == true) {
break;
}
if (window.parent == raising_window.toplevelWindow()) {
self.remove(window);
self.push(window);
window.toplevel.mark = true;
}
}
}
pub fn updatePointer(self: *Self, x: f64, y: f64) !void {
var new_pointer_window: ?*Window = null;
var it = self.top;
while (it) |window| : (it = window.toplevel.prev) {
if (window.windowUnderPointer(x, y)) |w| {
new_pointer_window = w;
break;
}
}
if (new_pointer_window != self.pointer_window) {
if (self.pointer_window) |old_pointer_window| {
try old_pointer_window.pointerLeave();
if (self.focus == Focus.FollowsMouse) {
try old_pointer_window.deactivate();
self.active_window = null;
}
}
if (new_pointer_window) |window| {
std.debug.warn("new pointer_window: {}\n", .{window.index});
try window.pointerEnter(x, y);
if (self.focus == Focus.FollowsMouse) {
try window.activate();
self.active_window = window;
}
} else {
std.debug.warn("new pointer_window: null\n", .{});
compositor.COMPOSITOR.client_cursor = null;
}
}
self.pointer_window = new_pointer_window;
if (self.pointer_window) |window| {
try window.pointerMotion(x, y);
}
}
pub fn keyboard(self: *Self, time: u32, button: u32, action: u32) !void {
if (self.active_window) |active_window| {
try active_window.keyboardKey(time, button, action);
}
}
pub fn mouseAxis(self: *Self, time: u32, axis: u32, value: f64) !void {
if (self.pointer_window) |pointer_window| {
try pointer_window.mouseAxis(time, axis, value);
}
}
pub fn deinit(self: *Self) void {
self.* = makeView(self.output);
}
};
pub fn makeView(output: ?*CompositorOutput) View {
return View{
.output = output,
.top = null,
.pointer_window = null,
.active_window = null,
.focus = Focus.Click,
};
} | src/view.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.