mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
341 lines
7.5 KiB
Plaintext
341 lines
7.5 KiB
Plaintext
module std::io;
|
|
import std::collections::map;
|
|
import libc;
|
|
|
|
// It is vitally important that the formatter doesn't do any allocations,
|
|
// or it ceases to be useful in constrained environments.
|
|
|
|
const int PRINTF_NTOA_BUFFER_SIZE = 256;
|
|
|
|
interface Printable
|
|
{
|
|
fn String to_constant_string() @optional;
|
|
fn usz? to_format(Formatter* formatter) @optional;
|
|
}
|
|
|
|
faultdef BUFFER_EXCEEDED, INTERNAL_BUFFER_EXCEEDED, INVALID_FORMAT, NOT_ENOUGH_ARGUMENTS, INVALID_ARGUMENT;
|
|
|
|
alias OutputFn = fn void?(void* buffer, char c);
|
|
alias FloatType = double;
|
|
|
|
|
|
macro bool is_struct_with_default_print($Type)
|
|
{
|
|
return ($Type.kindof == STRUCT ||| $Type.kindof == BITSTRUCT)
|
|
&&& !$defined($Type.to_format)
|
|
&&& !$defined($Type.to_constant_string);
|
|
}
|
|
|
|
<*
|
|
Introspect a struct and print it to a formatter
|
|
|
|
@require $kindof(value) == STRUCT || $kindof(value) == BITSTRUCT : `This macro is only valid on macros`
|
|
*>
|
|
macro usz? struct_to_format(value, Formatter* f, bool $force_dump)
|
|
{
|
|
var $Type = $typeof(value);
|
|
usz total = f.print("{ ")!;
|
|
$foreach $i, $member : $Type.membersof:
|
|
$if $i > 0:
|
|
total += f.print(", ")!;
|
|
$endif
|
|
$if $member.nameof != "":
|
|
total += f.printf("%s: ", $member.nameof)!;
|
|
$endif
|
|
$if ($force_dump &&& ($member.typeid.kindof == STRUCT || $member.typeid.kindof == BITSTRUCT)) |||
|
|
is_struct_with_default_print($member.typeid):
|
|
total += struct_to_format($member.get(value), f, $force_dump)!;
|
|
$else
|
|
total += f.printf("%s", $member.get(value))!;
|
|
$endif
|
|
$endforeach
|
|
return total + f.print(" }");
|
|
}
|
|
|
|
fn usz? ReflectedParam.to_format(&self, Formatter* f) @dynamic
|
|
{
|
|
return f.printf("[Parameter '%s']", self.name);
|
|
}
|
|
|
|
fn usz? Formatter.printf(&self, String format, args...)
|
|
{
|
|
return self.vprintf(format, args) @inline;
|
|
}
|
|
|
|
struct Formatter
|
|
{
|
|
void *data;
|
|
OutputFn out_fn;
|
|
struct
|
|
{
|
|
PrintFlags flags;
|
|
uint width;
|
|
uint prec;
|
|
fault first_fault;
|
|
}
|
|
}
|
|
|
|
bitstruct PrintFlags : uint
|
|
{
|
|
bool zeropad;
|
|
bool left;
|
|
bool plus;
|
|
bool space;
|
|
bool hash;
|
|
bool uppercase;
|
|
bool precision;
|
|
}
|
|
|
|
fn void Formatter.init(&self, OutputFn out_fn, void* data = null)
|
|
{
|
|
*self = { .data = data, .out_fn = out_fn};
|
|
}
|
|
|
|
|
|
|
|
fn usz? Formatter.print_with_function(&self, Printable arg)
|
|
{
|
|
if (&arg.to_format)
|
|
{
|
|
PrintFlags old = self.flags;
|
|
uint old_width = self.width;
|
|
uint old_prec = self.prec;
|
|
defer
|
|
{
|
|
self.flags = old;
|
|
self.width = old_width;
|
|
self.prec = old_prec;
|
|
}
|
|
if (!arg) return formatter_out_substr(self, "(null)");
|
|
return arg.to_format(self);
|
|
}
|
|
if (&arg.to_constant_string)
|
|
{
|
|
PrintFlags old = self.flags;
|
|
uint old_width = self.width;
|
|
uint old_prec = self.prec;
|
|
defer
|
|
{
|
|
self.flags = old;
|
|
self.width = old_width;
|
|
self.prec = old_prec;
|
|
}
|
|
if (!arg) return formatter_out_substr(self, "(null)");
|
|
return formatter_out_substr(self, arg.to_constant_string());
|
|
}
|
|
return NOT_FOUND~;
|
|
}
|
|
|
|
|
|
fn void? out_null_fn(void* data @unused, char c @unused) @private
|
|
{
|
|
}
|
|
|
|
macro usz? @report_fault(Formatter* f, $fault)
|
|
{
|
|
(void)formatter_out_substr(f, $fault);
|
|
return INVALID_FORMAT~;
|
|
}
|
|
|
|
macro usz? @wrap_bad(Formatter* f, #action)
|
|
{
|
|
usz? len = #action;
|
|
if (catch err = len)
|
|
{
|
|
switch (err)
|
|
{
|
|
case BUFFER_EXCEEDED:
|
|
case INTERNAL_BUFFER_EXCEEDED:
|
|
return f.first_err(err)~;
|
|
default:
|
|
err = f.first_err(INVALID_ARGUMENT);
|
|
formatter_out_substr(f, "<INVALID>")!;
|
|
return err~;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
|
|
fn usz? Formatter.vprintf(&self, String format, any[] anys)
|
|
{
|
|
self.first_fault = {};
|
|
if (!self.out_fn)
|
|
{
|
|
// use null output function
|
|
self.out_fn = &out_null_fn;
|
|
}
|
|
usz total_len;
|
|
usz format_len = format.len;
|
|
usz variant_index = 0;
|
|
for (usz i = 0; i < format_len; i++)
|
|
{
|
|
// format specifier? %[flags][width][.precision][length]
|
|
char c = format[i];
|
|
if (c != '%')
|
|
{
|
|
// no
|
|
total_len += self.print_char(c)!;
|
|
continue;
|
|
}
|
|
i++;
|
|
if (i >= format_len) return @report_fault(self, "%ERR");
|
|
c = format[i];
|
|
if (c == '%')
|
|
{
|
|
total_len += self.print_char(c)!;
|
|
continue;
|
|
}
|
|
// evaluate flags
|
|
self.flags = {};
|
|
while FLAG_EVAL: (true)
|
|
{
|
|
switch (c)
|
|
{
|
|
case '0': self.flags.zeropad = true;
|
|
case '-': self.flags.left = true;
|
|
case '+': self.flags.plus = true;
|
|
case ' ': self.flags.space = true;
|
|
case '#': self.flags.hash = true;
|
|
default: break FLAG_EVAL;
|
|
}
|
|
if (++i >= format_len) return @report_fault(self, "%ERR");
|
|
c = format[i];
|
|
}
|
|
// evaluate width field
|
|
int? w = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i);
|
|
if (catch w) return @report_fault(self, "%ERR");
|
|
c = format[i];
|
|
if (w < 0)
|
|
{
|
|
self.flags.left = true;
|
|
w = -w;
|
|
}
|
|
self.width = (uint)w;
|
|
// evaluate precision field
|
|
self.prec = 0;
|
|
if (c == '.')
|
|
{
|
|
self.flags.precision = true;
|
|
if (++i >= format_len) return @report_fault(self, "<BAD FORMAT>");
|
|
int? prec = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i);
|
|
if (catch prec) return @report_fault(self, "<BAD FORMAT>");
|
|
self.prec = (uint)(prec < 0 ? 0 : prec);
|
|
c = format[i];
|
|
}
|
|
|
|
// evaluate specifier
|
|
uint base = 0;
|
|
if (variant_index >= anys.len)
|
|
{
|
|
self.first_err(NOT_ENOUGH_ARGUMENTS);
|
|
total_len += formatter_out_substr(self, "<MISSING>")!;
|
|
continue;
|
|
}
|
|
any current = anys[variant_index++];
|
|
switch (c)
|
|
{
|
|
case 'd':
|
|
base = 10;
|
|
self.flags.hash = false;
|
|
case 'X' :
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'x' :
|
|
base = 16;
|
|
case 'O':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'o' :
|
|
base = 8;
|
|
case 'B':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'b' :
|
|
base = 2;
|
|
case 'A':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'a':
|
|
total_len += @wrap_bad(self, formatter_atoa(self, float_from_any(current)))!;
|
|
continue;
|
|
case 'F' :
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'f':
|
|
total_len += @wrap_bad(self, formatter_ftoa(self, float_from_any(current)))!;
|
|
continue;
|
|
case 'E':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'e':
|
|
total_len += @wrap_bad(self, formatter_etoa(self, float_from_any(current)))!;
|
|
continue;
|
|
case 'G':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'g':
|
|
total_len += @wrap_bad(self, formatter_gtoa(self, float_from_any(current)))!;
|
|
continue;
|
|
case 'c':
|
|
total_len += formatter_out_char(self, current)!;
|
|
continue;
|
|
case 'H':
|
|
self.flags.uppercase = true;
|
|
nextcase;
|
|
case 'h':
|
|
total_len += formatter_out_hex_buffer(self, current)!;
|
|
continue;
|
|
case 's':
|
|
total_len += formatter_out_str_pad(self, current)!;
|
|
continue;
|
|
case 'p':
|
|
self.flags.zeropad = true;
|
|
self.flags.hash = true;
|
|
base = 16;
|
|
default:
|
|
self.first_err(INVALID_FORMAT);
|
|
total_len += formatter_out_substr(self, "<BAD FORMAT>")!;
|
|
continue;
|
|
}
|
|
if (base != 10)
|
|
{
|
|
self.flags.plus = false;
|
|
self.flags.space = false;
|
|
}
|
|
// ignore '0' flag when precision is given
|
|
if (self.flags.precision) self.flags.zeropad = false;
|
|
|
|
bool is_neg;
|
|
total_len += @wrap_bad(self, formatter_ntoa(self, int_from_any(current, &is_neg), is_neg, base))!;
|
|
}
|
|
|
|
if (self.first_fault) return self.first_fault~;
|
|
return total_len;
|
|
}
|
|
|
|
fn usz? Formatter.out(&self, char c) @deprecated("Use print_char") => self.print_char(c);
|
|
|
|
fn usz? Formatter.print_char(&self, char c)
|
|
{
|
|
if (catch err = self.out_fn(self.data, c))
|
|
{
|
|
if (self.first_fault) return self.first_fault~;
|
|
self.first_fault = err;
|
|
return err~;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
fn usz? Formatter.print(&self, String str)
|
|
{
|
|
if (!self.out_fn)
|
|
{
|
|
// use null output function
|
|
self.out_fn = &out_null_fn;
|
|
}
|
|
foreach (c : str) self.print_char(c)!;
|
|
return str.len;
|
|
}
|