mirror of
https://github.com/ghostty-org/ghostty.git
synced 2026-06-15 08:03:56 +00:00
e45f002d1a
Register parsing now validates the full register request shape before constructing the parsed command. Inputs that only contain the verb separator, such as `r`, `r;cp=e0a0`, or `r;foo`, now fail with InvalidFormat instead of reaching Register invariants guarded by asserts. Valid empty-payload requests still parse when they include the payload separator, allowing execution to report malformed_payload through the normal protocol response path.
849 lines
29 KiB
Zig
849 lines
29 KiB
Zig
const std = @import("std");
|
||
const Allocator = std.mem.Allocator;
|
||
const assert = std.debug.assert;
|
||
const Glyf = @import("../../../font/opentype/glyf.zig").Glyf;
|
||
|
||
/// Maximum decoded glyph payload size accepted by the protocol.
|
||
/// This is documented in the spec.
|
||
const max_payload_size = 64 * 1024; // 64 KiB
|
||
|
||
/// Stateful parser for a single glyph APC payload after the `25a1;` prefix.
|
||
pub const CommandParser = struct {
|
||
alloc: Allocator,
|
||
data: std.ArrayList(u8) = .empty,
|
||
|
||
/// Maximum bytes the data payload can buffer. This is to prevent
|
||
/// malicious input from causing us to allocate too much memory.
|
||
max_bytes: usize,
|
||
|
||
pub const Error = Allocator.Error || error{InvalidFormat};
|
||
|
||
/// Create a glyph APC parser that buffers the raw command bytes.
|
||
pub fn init(alloc: Allocator, max_bytes: usize) CommandParser {
|
||
return .{ .alloc = alloc, .max_bytes = max_bytes };
|
||
}
|
||
|
||
/// Release any buffered command bytes owned by the parser.
|
||
pub fn deinit(self: *CommandParser) void {
|
||
self.data.deinit(self.alloc);
|
||
}
|
||
|
||
/// Append one more byte of APC payload to the buffered command.
|
||
pub fn feed(self: *CommandParser, byte: u8) Allocator.Error!void {
|
||
if (self.data.items.len >= self.max_bytes) return error.OutOfMemory;
|
||
try self.data.append(self.alloc, byte);
|
||
}
|
||
|
||
/// Finish parsing and return an owned request that can outlive the parser.
|
||
pub fn complete(self: *CommandParser, alloc: Allocator) Error!Request {
|
||
// Normalize bare single-byte verbs like `s` into `s;` so the parsed
|
||
// command always has the standard `verb;...` layout.
|
||
if (self.data.items.len == 1) try self.data.append(self.alloc, ';');
|
||
|
||
const raw = try self.data.toOwnedSlice(alloc);
|
||
|
||
// Ownership of the buffered bytes has moved to `raw`, so clear the
|
||
// array list before we build the final command value.
|
||
self.data = .empty;
|
||
errdefer alloc.free(raw);
|
||
return try Request.parse(alloc, raw);
|
||
}
|
||
};
|
||
|
||
/// Parsed glyph APC request with the verb classified eagerly.
|
||
pub const Request = union(enum) {
|
||
/// Support query (bare `s` verb, no options).
|
||
support,
|
||
|
||
/// Codepoint coverage query.
|
||
query: Query,
|
||
|
||
/// Glyph registration request.
|
||
register: Register,
|
||
|
||
/// Registration clear request.
|
||
clear: Clear,
|
||
|
||
/// Query verb payload with lazily-decoded options.
|
||
pub const Query = struct {
|
||
raw: []const u8,
|
||
|
||
/// Initialize a query command from owned raw command bytes.
|
||
pub fn init(raw: []const u8) Query {
|
||
return .{ .raw = raw };
|
||
}
|
||
|
||
/// Options recognized for the glyph query request.
|
||
pub const Option = enum {
|
||
/// Target Unicode codepoint encoded in hexadecimal.
|
||
cp,
|
||
|
||
/// Return the decoded Zig type for a query option.
|
||
pub fn Type(comptime self: Option) type {
|
||
return switch (self) {
|
||
.cp => u21,
|
||
};
|
||
}
|
||
|
||
/// Return the wire-format option key for this query option.
|
||
fn key(comptime self: Option) []const u8 {
|
||
return @tagName(self);
|
||
}
|
||
|
||
/// Read and decode a query option from the raw option string.
|
||
pub fn read(comptime self: Option, raw: []const u8) ?self.Type() {
|
||
const value = optionValue(raw, self.key()) orelse return null;
|
||
return switch (self) {
|
||
.cp => std.fmt.parseInt(u21, value, 16) catch null,
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Lazily decode a query option on demand.
|
||
pub fn get(self: Query, comptime option: Option) ?option.Type() {
|
||
return option.read(self.rawOptions());
|
||
}
|
||
|
||
/// Return the raw option portion of a valid query command.
|
||
fn rawOptions(self: Query) []const u8 {
|
||
assert(self.raw.len >= 2);
|
||
assert(self.raw[0] == 'q');
|
||
assert(self.raw[1] == ';');
|
||
return self.raw[2..];
|
||
}
|
||
};
|
||
|
||
/// Register verb payload with lazily-decoded options and optional base64 data.
|
||
pub const Register = struct {
|
||
raw: []const u8,
|
||
payload_idx: usize,
|
||
|
||
/// Initialize a register command from owned raw command bytes.
|
||
pub fn init(raw: []const u8) ?Register {
|
||
if (raw.len < 2) return null;
|
||
if (raw[0] != 'r') return null;
|
||
if (raw[1] != ';') return null;
|
||
const payload_idx = std.mem.lastIndexOfScalar(u8, raw, ';') orelse return null;
|
||
if (payload_idx <= 1) return null;
|
||
|
||
return .{
|
||
.raw = raw,
|
||
.payload_idx = payload_idx,
|
||
};
|
||
}
|
||
|
||
/// Options recognized for the glyph register verb.
|
||
pub const Option = enum {
|
||
/// Target Unicode codepoint encoded in hexadecimal.
|
||
cp,
|
||
|
||
/// Glyph payload format.
|
||
fmt,
|
||
|
||
/// Requested reply verbosity for registration.
|
||
reply,
|
||
|
||
/// Units-per-em for the glyph coordinate system.
|
||
upm,
|
||
|
||
/// Authored advance width in units-per-em units.
|
||
aw,
|
||
|
||
/// Authored line height in units-per-em units.
|
||
lh,
|
||
|
||
/// Unicode cell width for terminal layout.
|
||
width,
|
||
|
||
/// Glyph scale policy.
|
||
size,
|
||
|
||
/// Glyph placement within the render span.
|
||
@"align",
|
||
|
||
/// Fractional insets from the render span edges.
|
||
pad,
|
||
|
||
/// Return the decoded Zig type for a register option.
|
||
pub fn Type(comptime self: Option) type {
|
||
return switch (self) {
|
||
.cp => u21,
|
||
.fmt => Format,
|
||
.reply => Reply,
|
||
.upm => u32,
|
||
.aw => u32,
|
||
.lh => u32,
|
||
.width => Width,
|
||
.size => Size,
|
||
.@"align" => Align,
|
||
.pad => Pad,
|
||
};
|
||
}
|
||
|
||
/// Return the protocol default value for this option, if any.
|
||
pub fn default(comptime self: Option) ?self.Type() {
|
||
return switch (self) {
|
||
.cp => null,
|
||
.fmt => .glyf,
|
||
.reply => .all,
|
||
.upm => 1000,
|
||
.aw => null,
|
||
.lh => null,
|
||
.width => .narrow,
|
||
.size => .height,
|
||
.@"align" => .{},
|
||
.pad => .{},
|
||
};
|
||
}
|
||
|
||
/// Return the wire-format option key for this register option.
|
||
fn key(comptime self: Option) []const u8 {
|
||
return @tagName(self);
|
||
}
|
||
|
||
/// Read and decode a register option from the raw option string.
|
||
pub fn read(comptime self: Option, raw: []const u8) ?self.Type() {
|
||
const value = optionValue(raw, self.key()) orelse return null;
|
||
return switch (self) {
|
||
.cp => std.fmt.parseInt(u21, value, 16) catch null,
|
||
.fmt => Format.init(value),
|
||
.reply => Reply.init(value) orelse .all,
|
||
.upm => std.fmt.parseInt(u32, value, 10) catch null,
|
||
.aw => std.fmt.parseInt(u32, value, 10) catch null,
|
||
.lh => std.fmt.parseInt(u32, value, 10) catch null,
|
||
.width => Width.init(value),
|
||
.size => Size.init(value),
|
||
.@"align" => Align.init(value),
|
||
.pad => Pad.init(value),
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Lazily decode a register option on demand, applying protocol
|
||
/// defaults when the option is omitted.
|
||
pub fn get(self: Register, comptime option: Option) ?option.Type() {
|
||
const raw = self.rawOptions();
|
||
if (optionValue(raw, option.key()) == null) {
|
||
return switch (option) {
|
||
.aw, .lh => self.get(.upm),
|
||
else => option.default(),
|
||
};
|
||
}
|
||
return option.read(raw);
|
||
}
|
||
|
||
/// Return the base64 payload carried by a register request.
|
||
///
|
||
/// If no payload is present, this returns an empty slice. The returned
|
||
/// bytes may still be invalid base64; this function only exposes the raw
|
||
/// payload segment and does not validate or decode it.
|
||
pub fn payload(self: Register) []const u8 {
|
||
assert(self.raw.len >= 2);
|
||
assert(self.raw[0] == 'r');
|
||
assert(self.raw[1] == ';');
|
||
return if (self.payload_idx == self.raw.len)
|
||
""
|
||
else
|
||
self.raw[self.payload_idx + 1 ..];
|
||
}
|
||
|
||
/// Errors that can occur while decoding a register glyph payload.
|
||
pub const DecodeError = Allocator.Error || error{
|
||
/// The decoded payload exceeds the protocol limit.
|
||
PayloadTooLarge,
|
||
|
||
/// The payload could not be decoded or parsed as the declared format.
|
||
MalformedPayload,
|
||
|
||
/// The glyf payload is composite, which the protocol forbids.
|
||
CompositeUnsupported,
|
||
|
||
/// The glyf payload contains hinting instructions, which the
|
||
/// protocol forbids.
|
||
HintingUnsupported,
|
||
};
|
||
|
||
/// Decode this request's base64 glyf payload into an owned outline.
|
||
pub fn decodeGlyfPayload(self: Register, alloc: Allocator) DecodeError!Glyf.Outline {
|
||
// Prep base64 decoding, initial validation.
|
||
const Decoder = std.base64.standard.Decoder;
|
||
const payload_bytes = self.payload();
|
||
const size = Decoder.calcSizeForSlice(payload_bytes) catch
|
||
return error.MalformedPayload;
|
||
if (size > max_payload_size) return error.PayloadTooLarge;
|
||
|
||
// Max payload size is reasonable for stack and its likely
|
||
// we'll have stack space. We don't use much stack space in
|
||
// the future function calls either, so try a stack allocator
|
||
// here and fallback to heap as necessary.
|
||
var data_stack = std.heap.stackFallback(
|
||
max_payload_size,
|
||
alloc,
|
||
);
|
||
const data_alloc = data_stack.get();
|
||
const data = try data_alloc.alloc(u8, size);
|
||
defer data_alloc.free(data);
|
||
|
||
// Base64 decode
|
||
Decoder.decode(data, payload_bytes) catch
|
||
return error.MalformedPayload;
|
||
|
||
// Glyf.Entry borrows from `data`, but only for the duration of the
|
||
// decode call below. Glyf.Entry.decode returns an owned Outline, so
|
||
// it is safe to free `data` before returning that outline.
|
||
const glyf_entry = Glyf.Entry.init(data) catch return error.MalformedPayload;
|
||
return glyf_entry.decode(alloc) catch |err| switch (err) {
|
||
error.OutOfMemory => error.OutOfMemory,
|
||
// Unsupported fields
|
||
error.CompositeNotSupported => error.CompositeUnsupported,
|
||
error.InstructionsNotSupported => error.HintingUnsupported,
|
||
// Various semantic issues
|
||
error.EndOfStream,
|
||
error.EndPointsOutOfOrder,
|
||
error.TooManyPoints,
|
||
error.CoordinateOverflow,
|
||
=> error.MalformedPayload,
|
||
};
|
||
}
|
||
|
||
/// Return the raw option portion of a valid register command.
|
||
fn rawOptions(self: Register) []const u8 {
|
||
assert(self.raw.len >= 2);
|
||
assert(self.raw[0] == 'r');
|
||
assert(self.raw[1] == ';');
|
||
assert(self.payload_idx >= 2);
|
||
assert(self.payload_idx <= self.raw.len);
|
||
return self.raw[2..self.payload_idx];
|
||
}
|
||
};
|
||
|
||
/// Clear verb payload with lazily-decoded options.
|
||
pub const Clear = struct {
|
||
raw: []const u8,
|
||
|
||
/// Initialize a clear command from owned raw command bytes.
|
||
pub fn init(raw: []const u8) Clear {
|
||
return .{ .raw = raw };
|
||
}
|
||
|
||
/// Options recognized for the glyph clear request.
|
||
pub const Option = enum {
|
||
/// Target Unicode codepoint encoded in hexadecimal.
|
||
cp,
|
||
|
||
/// Return the decoded Zig type for a clear option.
|
||
pub fn Type(comptime self: Option) type {
|
||
return switch (self) {
|
||
.cp => u21,
|
||
};
|
||
}
|
||
|
||
/// Return the wire-format option key for this clear option.
|
||
fn key(comptime self: Option) []const u8 {
|
||
return @tagName(self);
|
||
}
|
||
|
||
/// Read and decode a clear option from the raw option string.
|
||
pub fn read(comptime self: Option, raw: []const u8) ?self.Type() {
|
||
const value = optionValue(raw, self.key()) orelse return null;
|
||
return switch (self) {
|
||
.cp => std.fmt.parseInt(u21, value, 16) catch null,
|
||
};
|
||
}
|
||
|
||
/// Return whether the option is present in the raw option string,
|
||
/// independent of whether its value can be decoded.
|
||
pub fn present(comptime self: Option, raw: []const u8) bool {
|
||
return optionValue(raw, self.key()) != null;
|
||
}
|
||
};
|
||
|
||
/// Lazily decode a clear option on demand.
|
||
pub fn get(self: Clear, comptime option: Option) ?option.Type() {
|
||
return option.read(self.rawOptions());
|
||
}
|
||
|
||
/// Return whether a clear option was provided, even if malformed.
|
||
pub fn has(self: Clear, comptime option: Option) bool {
|
||
return option.present(self.rawOptions());
|
||
}
|
||
|
||
/// Return the raw option portion of a valid clear command.
|
||
fn rawOptions(self: Clear) []const u8 {
|
||
assert(self.raw.len >= 2);
|
||
assert(self.raw[0] == 'c');
|
||
assert(self.raw[1] == ';');
|
||
return self.raw[2..];
|
||
}
|
||
};
|
||
|
||
/// Parse an owned glyph APC payload into its eagerly-classified request
|
||
/// form.
|
||
///
|
||
/// The raw format here is strict on its requirements to avoid
|
||
/// edge cases: it must contain the request AND the request must
|
||
/// end in a semicolon (even if there are no options). The spec itself
|
||
/// does not require this but we artificially insert it in our parser
|
||
/// to simplify parsing later.
|
||
pub fn parse(alloc: Allocator, raw: []const u8) error{InvalidFormat}!Request {
|
||
if (raw.len < 2) return error.InvalidFormat;
|
||
if (raw[1] != ';') return error.InvalidFormat;
|
||
|
||
return switch (raw[0]) {
|
||
's' => {
|
||
alloc.free(raw);
|
||
return .support;
|
||
},
|
||
'q' => .{ .query = .init(raw) },
|
||
'r' => .{ .register = Register.init(raw) orelse return error.InvalidFormat },
|
||
'c' => .{ .clear = .init(raw) },
|
||
else => error.InvalidFormat,
|
||
};
|
||
}
|
||
|
||
/// Free the raw bytes retained by any request variant.
|
||
pub fn deinit(self: *Request, alloc: Allocator) void {
|
||
switch (self.*) {
|
||
.support => {},
|
||
inline else => |*cmd| if (cmd.raw.len > 0) alloc.free(cmd.raw),
|
||
}
|
||
}
|
||
};
|
||
|
||
/// Glyph payload formats named by the protocol.
|
||
pub const Format = enum {
|
||
/// TrueType simple glyph outline data.
|
||
glyf,
|
||
|
||
/// OpenType COLR version 0 layered color glyph data.
|
||
colrv0,
|
||
|
||
/// OpenType COLR version 1 paint graph glyph data.
|
||
colrv1,
|
||
|
||
/// Parse a glyph payload format name.
|
||
pub fn init(value: []const u8) ?Format {
|
||
return std.meta.stringToEnum(Format, value);
|
||
}
|
||
};
|
||
|
||
/// Register command reply verbosity.
|
||
pub const Reply = enum(u2) {
|
||
/// Suppress both success and failure replies.
|
||
none = 0,
|
||
|
||
/// Emit replies for both success and failure cases.
|
||
all = 1,
|
||
|
||
/// Emit replies only for failure cases.
|
||
failures = 2,
|
||
|
||
/// Parse the register command reply mode from its single-digit encoding.
|
||
pub fn init(value: []const u8) ?Reply {
|
||
if (value.len != 1) return null;
|
||
return switch (value[0]) {
|
||
'0' => .none,
|
||
'1' => .all,
|
||
'2' => .failures,
|
||
else => null,
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Register command width override for terminal layout.
|
||
pub const Width = enum(u2) {
|
||
/// One terminal cell.
|
||
narrow = 1,
|
||
|
||
/// Two terminal cells.
|
||
wide = 2,
|
||
|
||
/// Parse the register command width from its single-digit encoding.
|
||
pub fn init(value: []const u8) ?Width {
|
||
if (value.len != 1) return null;
|
||
return switch (value[0]) {
|
||
'1' => .narrow,
|
||
'2' => .wide,
|
||
else => null,
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Register command glyph scale policy.
|
||
pub const Size = enum {
|
||
height,
|
||
advance,
|
||
contain,
|
||
cover,
|
||
stretch,
|
||
|
||
/// Parse a glyph scale policy name.
|
||
pub fn init(value: []const u8) ?Size {
|
||
return std.meta.stringToEnum(Size, value);
|
||
}
|
||
};
|
||
|
||
/// Register command glyph placement within the render span.
|
||
pub const Align = struct {
|
||
horizontal: Horizontal = .center,
|
||
vertical: Vertical = .center,
|
||
|
||
pub const Horizontal = enum {
|
||
start,
|
||
center,
|
||
end,
|
||
|
||
fn init(value: []const u8) ?Horizontal {
|
||
return std.meta.stringToEnum(Horizontal, value);
|
||
}
|
||
};
|
||
|
||
pub const Vertical = enum {
|
||
start,
|
||
center,
|
||
end,
|
||
baseline,
|
||
|
||
fn init(value: []const u8) ?Vertical {
|
||
return std.meta.stringToEnum(Vertical, value);
|
||
}
|
||
};
|
||
|
||
/// Parse an align value in `<horizontal>,<vertical>` form.
|
||
pub fn init(value: []const u8) ?Align {
|
||
var it = std.mem.splitScalar(u8, value, ',');
|
||
const horizontal = Horizontal.init(it.next() orelse return null) orelse return null;
|
||
const vertical = Vertical.init(it.next() orelse return null) orelse return null;
|
||
if (it.next() != null) return null;
|
||
|
||
return .{
|
||
.horizontal = horizontal,
|
||
.vertical = vertical,
|
||
};
|
||
}
|
||
};
|
||
|
||
/// Register command fractional insets from the render span edges.
|
||
pub const Pad = struct {
|
||
top: f64 = 0,
|
||
right: f64 = 0,
|
||
bottom: f64 = 0,
|
||
left: f64 = 0,
|
||
|
||
/// Parse a pad value in `<top>,<right>,<bottom>,<left>` form.
|
||
pub fn init(value: []const u8) ?Pad {
|
||
var it = std.mem.splitScalar(u8, value, ',');
|
||
const top = parseFraction(it.next() orelse return null) orelse return null;
|
||
const right = parseFraction(it.next() orelse return null) orelse return null;
|
||
const bottom = parseFraction(it.next() orelse return null) orelse return null;
|
||
const left = parseFraction(it.next() orelse return null) orelse return null;
|
||
if (it.next() != null) return null;
|
||
|
||
// Glyph Protocol §8.5.2: "If `l + r ≥ 1` or `t + b ≥ 1`
|
||
// the terminal MUST treat the request as if `pad=0,0,0,0`."
|
||
if (left + right >= 1 or top + bottom >= 1) return .{};
|
||
|
||
return .{
|
||
.top = top,
|
||
.right = right,
|
||
.bottom = bottom,
|
||
.left = left,
|
||
};
|
||
}
|
||
|
||
/// Parse one pad component from the spec's `0.0`–`1.0` fractional range.
|
||
/// Top/bottom fractions are relative to cell height; left/right fractions
|
||
/// are relative to render span width.
|
||
fn parseFraction(value: []const u8) ?f64 {
|
||
const result = std.fmt.parseFloat(f64, value) catch return null;
|
||
if (!(result >= 0 and result <= 1)) return null;
|
||
return result;
|
||
}
|
||
};
|
||
|
||
/// Find the last occurrence of `key=value` for a lazily-parsed option list.
|
||
fn optionValue(raw: []const u8, comptime key: []const u8) ?[]const u8 {
|
||
var remaining = raw;
|
||
var result: ?[]const u8 = null;
|
||
while (remaining.len > 0) {
|
||
// Options are semicolon-delimited, so each loop peels off one segment
|
||
// and checks whether it matches the requested key.
|
||
const len = std.mem.indexOfScalar(u8, remaining, ';') orelse remaining.len;
|
||
const full = remaining[0..len];
|
||
|
||
if (std.mem.indexOfScalar(u8, full, '=')) |eql_idx| {
|
||
if (std.mem.eql(u8, full[0..eql_idx], key)) {
|
||
result = full[eql_idx + 1 ..];
|
||
}
|
||
}
|
||
|
||
if (len == remaining.len) break;
|
||
remaining = remaining[len + 1 ..];
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
fn testParse(alloc: Allocator, data: []const u8) CommandParser.Error!Request {
|
||
var parser = CommandParser.init(alloc, 1024 * 1024);
|
||
defer parser.deinit();
|
||
for (data) |byte| try parser.feed(byte);
|
||
return try parser.complete(alloc);
|
||
}
|
||
|
||
test "support command" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "s");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .support);
|
||
}
|
||
|
||
test "query command" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "q;cp=E0A0");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .query);
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.query.get(.cp).?);
|
||
}
|
||
|
||
test "register command with payload" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=e0a0;fmt=glyf;upm=1000;reply=2;QQ==",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.register.get(.cp).?);
|
||
try testing.expectEqual(Format.glyf, cmd.register.get(.fmt).?);
|
||
try testing.expectEqual(@as(u32, 1000), cmd.register.get(.upm).?);
|
||
try testing.expectEqual(Reply.failures, cmd.register.get(.reply).?);
|
||
try testing.expectEqualStrings("QQ==", cmd.register.payload());
|
||
}
|
||
|
||
test "register command with sizing and placement options" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=e0a0;upm=2048;aw=1024;lh=1536;width=2;size=contain;align=end,baseline;pad=0.1,0.2,0.3,0.4;QQ==",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u32, 2048), cmd.register.get(.upm).?);
|
||
try testing.expectEqual(@as(u32, 1024), cmd.register.get(.aw).?);
|
||
try testing.expectEqual(@as(u32, 1536), cmd.register.get(.lh).?);
|
||
try testing.expectEqual(Width.wide, cmd.register.get(.width).?);
|
||
try testing.expectEqual(Size.contain, cmd.register.get(.size).?);
|
||
try testing.expectEqual(Align{
|
||
.horizontal = .end,
|
||
.vertical = .baseline,
|
||
}, cmd.register.get(.@"align").?);
|
||
try testing.expectEqual(Pad{
|
||
.top = 0.1,
|
||
.right = 0.2,
|
||
.bottom = 0.3,
|
||
.left = 0.4,
|
||
}, cmd.register.get(.pad).?);
|
||
try testing.expectEqualStrings("QQ==", cmd.register.payload());
|
||
}
|
||
|
||
test "register option defaults" {
|
||
const testing = std.testing;
|
||
const Option = Request.Register.Option;
|
||
|
||
try testing.expect(Option.cp.default() == null);
|
||
try testing.expectEqual(Format.glyf, Option.fmt.default().?);
|
||
try testing.expectEqual(@as(u32, 1000), Option.upm.default().?);
|
||
try testing.expect(Option.aw.default() == null);
|
||
try testing.expect(Option.lh.default() == null);
|
||
try testing.expectEqual(Width.narrow, Option.width.default().?);
|
||
try testing.expectEqual(Size.height, Option.size.default().?);
|
||
try testing.expectEqual(Align{}, Option.@"align".default().?);
|
||
try testing.expectEqual(Pad{}, Option.pad.default().?);
|
||
try testing.expectEqual(Reply.all, Option.reply.default().?);
|
||
}
|
||
|
||
test "register command defaults" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;QQ==");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.register.get(.cp).?);
|
||
try testing.expectEqual(Format.glyf, cmd.register.get(.fmt).?);
|
||
try testing.expectEqual(@as(u32, 1000), cmd.register.get(.upm).?);
|
||
try testing.expectEqual(@as(u32, 1000), cmd.register.get(.aw).?);
|
||
try testing.expectEqual(@as(u32, 1000), cmd.register.get(.lh).?);
|
||
try testing.expectEqual(Width.narrow, cmd.register.get(.width).?);
|
||
try testing.expectEqual(Size.height, cmd.register.get(.size).?);
|
||
try testing.expectEqual(Align{}, cmd.register.get(.@"align").?);
|
||
try testing.expectEqual(Pad{}, cmd.register.get(.pad).?);
|
||
try testing.expectEqual(Reply.all, cmd.register.get(.reply).?);
|
||
}
|
||
|
||
test "register command aw and lh default to upm" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;upm=2048;QQ==");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u32, 2048), cmd.register.get(.aw).?);
|
||
try testing.expectEqual(@as(u32, 2048), cmd.register.get(.lh).?);
|
||
}
|
||
|
||
test "register command invalid sizing and placement options" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=e0a0;width=3;size=invalid;align=center,middle;pad=0,1.2,0,0;QQ==",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expect(cmd.register.get(.width) == null);
|
||
try testing.expect(cmd.register.get(.size) == null);
|
||
try testing.expect(cmd.register.get(.@"align") == null);
|
||
try testing.expect(cmd.register.get(.pad) == null);
|
||
}
|
||
|
||
test "register command degenerate padding defaults to no padding" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=e0a0;pad=0.4,0.2,0.6,0.1;QQ==",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(Pad{}, cmd.register.get(.pad).?);
|
||
}
|
||
|
||
test "register command invalid reply falls back to reply=1" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;reply=9;QQ==");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(Reply.all, cmd.register.get(.reply).?);
|
||
}
|
||
|
||
test "register command duplicate options use the last value" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;reply=1;reply=2;QQ==");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(Reply.failures, cmd.register.get(.reply).?);
|
||
}
|
||
|
||
test "register command with invalid payload" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=e0a0;fmt=glyf;%%%not-base64%%%",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.register.get(.cp).?);
|
||
try testing.expectEqual(Format.glyf, cmd.register.get(.fmt).?);
|
||
try testing.expectEqualStrings("%%%not-base64%%%", cmd.register.payload());
|
||
}
|
||
|
||
test "register command rejects missing payload separator" {
|
||
const testing = std.testing;
|
||
|
||
for ([_][]const u8{ "r", "r;cp=e0a0", "r;foo" }) |data| {
|
||
try testing.expectError(
|
||
error.InvalidFormat,
|
||
testParse(testing.allocator, data),
|
||
);
|
||
}
|
||
}
|
||
|
||
test "register decodes glyf payload" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;AAAAAAAAAAAAAA==");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
var outline = try cmd.register.decodeGlyfPayload(testing.allocator);
|
||
defer outline.deinit(testing.allocator);
|
||
|
||
try testing.expectEqual(@as(usize, 0), outline.points.len);
|
||
try testing.expectEqual(@as(usize, 0), outline.contours.len);
|
||
}
|
||
|
||
test "register rejects malformed glyf payload" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "r;cp=e0a0;%%%not-base64%%%");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expectError(error.MalformedPayload, cmd.register.decodeGlyfPayload(testing.allocator));
|
||
}
|
||
|
||
test "register response without payload" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(
|
||
testing.allocator,
|
||
"r;cp=E0A0;status=4;reason=out_of_namespace",
|
||
);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
// Register parsing is request-only, so the final segment is always treated
|
||
// as payload rather than as a response field.
|
||
try testing.expect(cmd == .register);
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.register.get(.cp).?);
|
||
try testing.expectEqualStrings("reason=out_of_namespace", cmd.register.payload());
|
||
}
|
||
|
||
test "clear command" {
|
||
const testing = std.testing;
|
||
|
||
var cmd = try testParse(testing.allocator, "c;cp=e0a0");
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .clear);
|
||
try testing.expect(cmd.clear.has(.cp));
|
||
try testing.expectEqual(@as(u21, 0xE0A0), cmd.clear.get(.cp).?);
|
||
}
|
||
|
||
test "clear command tracks malformed cp presence" {
|
||
const testing = std.testing;
|
||
|
||
for ([_][]const u8{ "c;cp=zz", "c;cp=", "c;cp=200000" }) |data| {
|
||
var cmd = try testParse(testing.allocator, data);
|
||
defer cmd.deinit(testing.allocator);
|
||
|
||
try testing.expect(cmd == .clear);
|
||
try testing.expect(cmd.clear.has(.cp));
|
||
try testing.expect(cmd.clear.get(.cp) == null);
|
||
}
|
||
}
|
||
|
||
test "invalid command" {
|
||
const testing = std.testing;
|
||
|
||
try testing.expectError(
|
||
error.InvalidFormat,
|
||
testParse(testing.allocator, "x"),
|
||
);
|
||
}
|