281 lines
6.6 KiB
Zig
281 lines
6.6 KiB
Zig
const debug = @import("./debug.zig");
|
|
|
|
const io = @import("./io.zig");
|
|
|
|
const math = @import("./math.zig");
|
|
|
|
pub const DecimalFormat = struct {
|
|
delimiter: []const io.Byte,
|
|
positive_prefix: enum {none, plus, space},
|
|
|
|
const default = DecimalFormat{
|
|
.delimiter = "",
|
|
.positive_prefix = .none,
|
|
};
|
|
|
|
pub fn parse(self: DecimalFormat, utf8: []const io.Byte, comptime Decimal: type) ?Decimal {
|
|
if (utf8.len == 0) {
|
|
return null;
|
|
}
|
|
|
|
switch (@typeInfo(Decimal)) {
|
|
.Int => |int| {
|
|
var has_sign = switch (utf8[0]) {
|
|
'-', '+', ' ' => true,
|
|
else => false,
|
|
};
|
|
|
|
var result = @as(Decimal, 0);
|
|
|
|
for (@intFromBool(has_sign) .. utf8.len) |index| {
|
|
const radix = 10;
|
|
const code = utf8[index];
|
|
|
|
switch (code) {
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => {
|
|
const offset_code = math.checked_sub(code, '0') orelse return null;
|
|
|
|
result = math.checked_mul(result, radix) orelse return null;
|
|
result = math.checked_add(result, offset_code) orelse return null;
|
|
},
|
|
|
|
else => {
|
|
if (self.delimiter.len == 0 or !io.equals(self.delimiter, utf8[index ..])) {
|
|
return null;
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
switch (int.signedness) {
|
|
.signed => {
|
|
return result * @as(Decimal, if (has_sign and utf8[0] == '-') -1 else 1);
|
|
},
|
|
|
|
.unsigned => {
|
|
if (has_sign and utf8[0] == '-') {
|
|
return null;
|
|
}
|
|
|
|
return result;
|
|
},
|
|
}
|
|
},
|
|
|
|
.Float => {
|
|
var has_sign = switch (utf8[0]) {
|
|
'-', '+', ' ' => true,
|
|
else => false,
|
|
};
|
|
|
|
// "-"
|
|
if (has_sign and utf8.len == 1) {
|
|
return null;
|
|
}
|
|
|
|
const sign_offset = @intFromBool(has_sign);
|
|
var has_decimal = utf8[sign_offset] == '.';
|
|
|
|
// "-."
|
|
if (has_decimal and (utf8.len == 2)) {
|
|
return null;
|
|
}
|
|
|
|
var result = @as(Decimal, 0);
|
|
var factor = @as(Decimal, if (has_sign and utf8[0] == '-') -1 else 1);
|
|
|
|
for (utf8[sign_offset + @intFromBool(has_decimal) .. utf8.len]) |code| {
|
|
switch (code) {
|
|
'.' => {
|
|
if (has_decimal) {
|
|
return null;
|
|
}
|
|
|
|
has_decimal = true;
|
|
},
|
|
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => {
|
|
if (has_decimal) {
|
|
factor /= 10.0;
|
|
}
|
|
|
|
result = ((result * 10.0) + @as(Decimal, @floatFromInt(code - '0')));
|
|
},
|
|
|
|
else => return null,
|
|
}
|
|
}
|
|
|
|
return result * factor;
|
|
},
|
|
|
|
else => @compileError("`" ++ @typeName(Decimal) ++ "` cannot be formatted as a decimal string"),
|
|
}
|
|
}
|
|
|
|
pub fn print(self: DecimalFormat, writer: io.Writer, value: anytype) PrintError!void {
|
|
if (value == 0) {
|
|
return print_string(writer, switch (self.positive_prefix) {
|
|
.none => "0",
|
|
.plus => "+0",
|
|
.space => " 0",
|
|
});
|
|
}
|
|
|
|
const ValueType = @TypeOf(value);
|
|
|
|
switch (@typeInfo(ValueType)) {
|
|
.Int => |int| {
|
|
const radix = 10;
|
|
var buffer = [_]u8{0} ** (1 + @max(int.bits, 1));
|
|
var buffer_start = buffer.len - 1;
|
|
|
|
{
|
|
var decomposable_value = value;
|
|
|
|
while (decomposable_value != 0) : (buffer_start -= 1) {
|
|
buffer[buffer_start] = @intCast((decomposable_value % radix) + '0');
|
|
decomposable_value = (decomposable_value / radix);
|
|
}
|
|
}
|
|
|
|
if (int.signedness == .unsigned and value < 0) {
|
|
buffer[buffer_start] = '-';
|
|
} else {
|
|
switch (self.positive_prefix) {
|
|
.none => buffer_start += 1,
|
|
.plus => buffer[buffer_start] = '+',
|
|
.space => buffer[buffer_start] = ' ',
|
|
}
|
|
}
|
|
|
|
try print_string(writer, buffer[buffer_start ..]);
|
|
},
|
|
|
|
else => unformattableMessage(ValueType),
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const HexadecimalFormat = struct {
|
|
delimiter: []const u8 = "",
|
|
positive_prefix: enum {none, plus, space} = .none,
|
|
casing: enum {lower, upper} = .lower,
|
|
|
|
const default = HexadecimalFormat{
|
|
.delimiter = "",
|
|
.positive_prefix = .none,
|
|
.casing = .lower,
|
|
};
|
|
|
|
pub fn print(self: HexadecimalFormat, writer: io.Writer, value: anytype) PrintError!void {
|
|
// TODO: Implement.
|
|
_ = self;
|
|
_ = writer;
|
|
_ = value;
|
|
}
|
|
};
|
|
|
|
pub const PrintError = error {
|
|
PrintFailed,
|
|
PrintIncomplete,
|
|
};
|
|
|
|
pub fn print_string(writer: io.Writer, utf8: []const io.Byte) PrintError!void {
|
|
if ((writer.invoke(utf8) orelse return error.PrintFailed) != utf8.len) {
|
|
return error.PrintIncomplete;
|
|
}
|
|
}
|
|
|
|
pub fn print_formatted(writer: io.Writer, comptime format: []const u8, arguments: anytype) PrintError!void {
|
|
switch (@typeInfo(@TypeOf(arguments))) {
|
|
.Struct => |arguments_struct| {
|
|
comptime var arg_index = 0;
|
|
comptime var head = 0;
|
|
comptime var tail = 0;
|
|
|
|
inline while (tail < format.len) : (tail += 1) {
|
|
if (format[tail] == '{') {
|
|
if (tail > format.len) {
|
|
@compileError("expected an idenifier after opening `{`");
|
|
}
|
|
|
|
tail += 1;
|
|
|
|
switch (format[tail]) {
|
|
'{' => {
|
|
try print_string(writer, format[head .. (tail - 1)]);
|
|
|
|
tail += 1;
|
|
head = tail;
|
|
},
|
|
|
|
'}' => {
|
|
if (!arguments_struct.is_tuple) {
|
|
@compileError("all format specifiers must be named when using a named struct");
|
|
}
|
|
|
|
try print_string(writer, arguments[arg_index]);
|
|
|
|
arg_index += 1;
|
|
tail += 1;
|
|
head = tail;
|
|
},
|
|
|
|
else => {
|
|
if (arguments_struct.is_tuple) {
|
|
@compileError("format specifiers cannot be named when using a tuple struct");
|
|
}
|
|
|
|
try print_string(writer, format[head .. (tail - 1)]);
|
|
|
|
head = tail;
|
|
tail += 1;
|
|
|
|
if (tail >= format.len) {
|
|
@compileError("expected closing `}` or another `{` after opening `{`");
|
|
}
|
|
|
|
debug.assert(tail < format.len);
|
|
|
|
inline while (format[tail] != '}') {
|
|
tail += 1;
|
|
|
|
debug.assert(tail < format.len);
|
|
}
|
|
|
|
try print_value(writer, @field(arguments, format[head .. tail]));
|
|
|
|
tail += 1;
|
|
head = tail;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
else => @compileError("`arguments` must be a struct type"),
|
|
}
|
|
}
|
|
|
|
noinline fn print_value(writer: io.Writer, value: anytype) PrintError!void {
|
|
const Value = @TypeOf(value);
|
|
|
|
return switch (@typeInfo(Value)) {
|
|
.Int => DecimalFormat.default.print(writer, value),
|
|
.Float => DecimalFormat.default.print(writer, value),
|
|
|
|
.Pointer => |pointer| switch (pointer.size) {
|
|
.Many, .C => HexadecimalFormat.default.print(writer, @intFromPtr(value)),
|
|
.One => if (pointer.child == []const u8) print_string(writer, *value) else HexadecimalFormat.default.print(writer, @intFromPtr(value)),
|
|
.Slice => if (pointer.child == u8) print_string(writer, value) else @compileError(unformattableMessage(Value)),
|
|
},
|
|
|
|
else => @compileError(unformattableMessage(Value)),
|
|
};
|
|
}
|
|
|
|
fn unformattableMessage(comptime Value: type) []const u8 {
|
|
return "type `" ++ @typeName(Value) ++ "` is not formattable with this formatter";
|
|
}
|