mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
Refactoring, adding printf / printfn to all streams.
This commit is contained in:
Christoffer Lerno
committed by
Christoffer Lerno
Christoffer Lerno
parent
9a6d83f526
commit
4c081f59ff
667
lib/std/io/formatter_private.c3
Normal file
667
lib/std/io/formatter_private.c3
Normal file
@@ -0,0 +1,667 @@
|
||||
module std::io;
|
||||
|
||||
const char[16] XDIGITS_H = "0123456789ABCDEF";
|
||||
const char[16] XDIGITS_L = "0123456789abcdef";
|
||||
|
||||
fn usz! Formatter.adjust(&self, usz len) @local
|
||||
{
|
||||
if (!self.flags.left) return 0;
|
||||
return self.pad(' ', self.width, len);
|
||||
}
|
||||
|
||||
fn uint128! int_from_any(any arg, bool *is_neg) @private
|
||||
{
|
||||
*is_neg = false;
|
||||
if (arg.type.kindof == TypeKind.POINTER)
|
||||
{
|
||||
return (uint128)(uptr)*(void**)arg.ptr;
|
||||
}
|
||||
if (arg.type.kindof == TypeKind.DISTINCT)
|
||||
{
|
||||
return int_from_any(any { arg.ptr, arg.type.inner }, is_neg);
|
||||
}
|
||||
switch (arg)
|
||||
{
|
||||
case bool:
|
||||
return (uint128)*arg;
|
||||
case ichar:
|
||||
int val = *arg;
|
||||
return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
|
||||
case short:
|
||||
int val = *arg;
|
||||
return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
|
||||
case int:
|
||||
int val = *arg;
|
||||
return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
|
||||
case long:
|
||||
long val = *arg;
|
||||
return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
|
||||
case int128:
|
||||
int128 val = *arg;
|
||||
return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
|
||||
case char:
|
||||
return *arg;
|
||||
case ushort:
|
||||
return *arg;
|
||||
case uint:
|
||||
return *arg;
|
||||
case ulong:
|
||||
return *arg;
|
||||
case uint128:
|
||||
return *arg;
|
||||
case float:
|
||||
float f = *arg;
|
||||
return (uint128)((*is_neg = f < 0) ? -f : f);
|
||||
case double:
|
||||
double d = *arg;
|
||||
return (uint128)((*is_neg = d < 0) ? -d : d);
|
||||
default:
|
||||
return PrintFault.INVALID_ARGUMENT_TYPE?;
|
||||
}
|
||||
}
|
||||
|
||||
fn FloatType! float_from_any(any arg) @private
|
||||
{
|
||||
$if env::F128_SUPPORT:
|
||||
if (arg.type == float128.typeid) return (FloatType)*((float128*)arg.ptr);
|
||||
$endif
|
||||
$if env::F16_SUPPORT:
|
||||
if (arg.type == float16.typeid) return *((float16*)arg.ptr);
|
||||
$endif
|
||||
if (arg.type.kindof == TypeKind.DISTINCT)
|
||||
{
|
||||
return float_from_any(any { arg.ptr, arg.type.inner });
|
||||
}
|
||||
switch (arg)
|
||||
{
|
||||
case bool:
|
||||
return (FloatType)*arg;
|
||||
case ichar:
|
||||
return *arg;
|
||||
case short:
|
||||
return *arg;
|
||||
case int:
|
||||
return *arg;
|
||||
case long:
|
||||
return *arg;
|
||||
case int128:
|
||||
return *arg;
|
||||
case char:
|
||||
return *arg;
|
||||
case ushort:
|
||||
return *arg;
|
||||
case uint:
|
||||
return *arg;
|
||||
case ulong:
|
||||
return *arg;
|
||||
case uint128:
|
||||
return *arg;
|
||||
case float:
|
||||
return (FloatType)*arg;
|
||||
case double:
|
||||
return (FloatType)*arg;
|
||||
default:
|
||||
return PrintFault.INVALID_ARGUMENT_TYPE?;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Read a simple integer value, typically for formatting.
|
||||
*
|
||||
* @param [inout] len_ptr "the length remaining."
|
||||
* @param [in] buf "the buf to read from."
|
||||
* @param maxlen "the maximum len that can be read."
|
||||
* @return "The result of the atoi."
|
||||
**/
|
||||
fn uint simple_atoi(char* buf, usz maxlen, usz* len_ptr) @inline @private
|
||||
{
|
||||
uint i = 0;
|
||||
usz len = *len_ptr;
|
||||
while (len < maxlen)
|
||||
{
|
||||
char c = buf[len];
|
||||
if (!c.is_digit()) break;
|
||||
i = i * 10 + c - '0';
|
||||
len++;
|
||||
}
|
||||
*len_ptr = len;
|
||||
return i;
|
||||
}
|
||||
|
||||
fn usz! Formatter.out_substr(&self, String str) @private
|
||||
{
|
||||
usz l = conv::utf8_codepoints(str);
|
||||
uint prec = self.prec;
|
||||
if (self.flags.precision && l < prec) l = prec;
|
||||
usz index = 0;
|
||||
usz chars = str.len;
|
||||
char* ptr = str.ptr;
|
||||
while (index < chars)
|
||||
{
|
||||
char c = ptr[index];
|
||||
// Break if we have precision set and we ran out...
|
||||
if (c & 0xC0 != 0x80 && self.flags.precision && !prec--) break;
|
||||
self.out(c)!;
|
||||
index++;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
fn usz! Formatter.pad(&self, char c, isz width, isz len) @inline
|
||||
{
|
||||
isz delta = width - len;
|
||||
for (isz i = 0; i < delta; i++) self.out(c)!;
|
||||
return max(0, delta);
|
||||
}
|
||||
|
||||
fn char* fmt_u(uint128 x, char* s)
|
||||
{
|
||||
for (; x > ulong.max; x /= 10) *--s = '0' + (char)(x % 10);
|
||||
for (ulong y = (ulong)x; y; y /= 10) *--s = '0' + (char)(y % 10);
|
||||
return s;
|
||||
}
|
||||
|
||||
fn usz! Formatter.out_chars(&self, char[] s)
|
||||
{
|
||||
foreach (c : s) self.out(c)!;
|
||||
return s.len;
|
||||
}
|
||||
|
||||
enum FloatFormatting
|
||||
{
|
||||
FLOAT,
|
||||
EXPONENTIAL,
|
||||
ADAPTIVE,
|
||||
HEX
|
||||
}
|
||||
|
||||
fn usz! Formatter.etoa(&self, double y) => self.floatformat(EXPONENTIAL, y);
|
||||
fn usz! Formatter.ftoa(&self, double y) => self.floatformat(FLOAT, y);
|
||||
fn usz! Formatter.gtoa(&self, double y) => self.floatformat(ADAPTIVE, y);
|
||||
fn usz! Formatter.atoa(&self, double y) => self.floatformat(HEX, y);
|
||||
|
||||
fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @private
|
||||
{
|
||||
// This code is heavily based on musl's printf code
|
||||
const BUF_SIZE = (math::DOUBLE_MANT_DIG + 28) / 29 + 1
|
||||
+ (math::DOUBLE_MAX_EXP + math::DOUBLE_MANT_DIG + 28 + 8) / 9;
|
||||
uint[BUF_SIZE] big;
|
||||
bool is_neg = false;
|
||||
if (math::signbit(y))
|
||||
{
|
||||
is_neg = true;
|
||||
y = -y;
|
||||
}
|
||||
int pl = is_neg || self.flags.plus ? 1 : 0;
|
||||
// Print inf/nan
|
||||
if (!math::is_finite(y))
|
||||
{
|
||||
usz len;
|
||||
// Add padding
|
||||
if (!self.flags.left) len += self.pad(' ', self.width, 3 + pl)!;
|
||||
String s = self.flags.uppercase ? "INF" : "inf";
|
||||
if (y != y) s = self.flags.uppercase ? "NAN" : "nan";
|
||||
len += s.len;
|
||||
if (pl) len += self.out(is_neg ? '-' : '+')!;
|
||||
len += self.out_chars(s)!;
|
||||
if (self.flags.left) len += self.pad(' ', self.width, 3 + pl)!;
|
||||
return len;
|
||||
}
|
||||
// Rescale
|
||||
int e2;
|
||||
|
||||
y = math::frexp(y, &e2) * 2;
|
||||
if (y) e2--;
|
||||
char[12] ebuf0;
|
||||
char* ebuf = 12 + (char*)&ebuf0;
|
||||
char[9 + math::DOUBLE_MANT_DIG / 4] buf_array;
|
||||
char* buf = &buf_array;
|
||||
isz p = self.flags.precision ? self.prec : -1;
|
||||
if (formatting == HEX)
|
||||
{
|
||||
double round = 8.0;
|
||||
// 0x / 0X
|
||||
pl += 2;
|
||||
if (p > 0 && p < math::DOUBLE_MANT_DIG / 4 - 1)
|
||||
{
|
||||
int re = math::DOUBLE_MANT_DIG / 4 - 1 - (int)p;
|
||||
round *= 1 << (math::DOUBLE_MANT_DIG % 4);
|
||||
while (re--) round *= 16;
|
||||
if (is_neg)
|
||||
{
|
||||
y = -y;
|
||||
y -= round;
|
||||
y += round;
|
||||
y = -y;
|
||||
}
|
||||
else
|
||||
{
|
||||
y += round;
|
||||
y -= round;
|
||||
}
|
||||
}
|
||||
// Reverse print
|
||||
char* estr = fmt_u(e2 < 0 ? (int128)-e2 : (int128)e2, ebuf);
|
||||
if (estr == ebuf) *--estr = '0';
|
||||
*--estr = (e2 < 0 ? '-' : '+');
|
||||
*--estr = self.flags.uppercase ? 'P' : 'p';
|
||||
char* s = buf;
|
||||
char* xdigits = self.flags.uppercase ? &XDIGITS_H : &XDIGITS_L;
|
||||
do
|
||||
{
|
||||
int x = (int)y;
|
||||
*s++ = xdigits[x];
|
||||
y = 16 * (y - x);
|
||||
if (s - buf == 1 && (y || p > 0 || self.flags.hash)) *s++ = '.';
|
||||
} while (y);
|
||||
isz outlen = s - buf;
|
||||
isz explen = ebuf - estr;
|
||||
if (p > int.max - 2 - explen - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
usz len;
|
||||
usz l = p && outlen - 2 < p
|
||||
? p + 2 + explen
|
||||
: outlen + explen;
|
||||
if (!self.flags.left && !self.flags.zeropad) len += self.pad(' ', self.width, pl + l)!;
|
||||
if (is_neg || self.flags.plus) len += self.out(is_neg ? '-' : '+')!;
|
||||
len += self.out_chars(self.flags.uppercase ? "0X" : "0x")!;
|
||||
if (self.flags.zeropad) len += self.pad('0', self.width, pl + l)!;
|
||||
len += self.out_chars(buf[:outlen])!;
|
||||
len += self.pad('0', l - outlen - explen, 0)!;
|
||||
len += self.out_chars(estr[:explen])!;
|
||||
if (self.flags.left) len += self.pad(' ', self.width, pl + l)!;
|
||||
return len;
|
||||
}
|
||||
if (p < 0) p = 6;
|
||||
if (y)
|
||||
{
|
||||
y *= 0x1p28;
|
||||
e2 -= 28;
|
||||
}
|
||||
|
||||
uint* a, z, r;
|
||||
if (e2 < 0)
|
||||
{
|
||||
a = r = z = &big;
|
||||
}
|
||||
else
|
||||
{
|
||||
a = r = z = (uint*)&big + big.len - math::DOUBLE_MANT_DIG - 1;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
uint v = z++[0] = (uint)y;
|
||||
y = 1000000000 * (y - v);
|
||||
} while (y);
|
||||
|
||||
while (e2 > 0)
|
||||
{
|
||||
uint carry = 0;
|
||||
int sh = math::min(29, e2);
|
||||
for (uint* d = z - 1; d >= a; d--)
|
||||
{
|
||||
ulong x = (ulong)*d << sh + carry;
|
||||
*d = (uint)(x % 1000000000);
|
||||
carry = (uint)(x / 1000000000);
|
||||
}
|
||||
if (carry) *--a = carry;
|
||||
while (z > a && !z[-1]) z--;
|
||||
e2 -= sh;
|
||||
}
|
||||
|
||||
while (e2 < 0)
|
||||
{
|
||||
uint carry = 0;
|
||||
uint* b;
|
||||
int sh = math::min(9, -e2);
|
||||
int need = (int)(1 + (p + math::DOUBLE_MANT_DIG / 3u + 8) / 9);
|
||||
for (uint* d = a; d < z; d++)
|
||||
{
|
||||
// CHECK THIS
|
||||
uint rm = *d & ((1 << sh) - 1);
|
||||
*d = (*d >> sh) + carry;
|
||||
carry = (1000000000 >> sh) * rm;
|
||||
}
|
||||
if (!a[0]) a++;
|
||||
if (carry) z++[0] = carry;
|
||||
// Avoid (slow!) computation past requested precision
|
||||
b = formatting == FLOAT ? r : a;
|
||||
if (z - b > need) z = b + need;
|
||||
e2 += sh;
|
||||
}
|
||||
|
||||
int e;
|
||||
if (a < z)
|
||||
{
|
||||
for (int i = 10, e = (int)(9 * (r - a)); *a >= i; i *= 10, e++);
|
||||
}
|
||||
|
||||
// Perform rounding: j is precision after the radix (possibly neg)
|
||||
int j = (int)(p - (isz)(formatting == FLOAT ? 0 : e - (int)(formatting == ADAPTIVE && p)));
|
||||
if (j < 9 * (z - r - 1))
|
||||
{
|
||||
uint x;
|
||||
// We avoid C's broken division of negative numbers
|
||||
uint* d = r + 1 + ((j + 9 * math::DOUBLE_MAX_EXP) / 9 - math::DOUBLE_MAX_EXP);
|
||||
j += 9 * math::DOUBLE_MAX_EXP;
|
||||
j %= 9;
|
||||
int i;
|
||||
for (i = 10, j++; j < 9; i *= 10, j++);
|
||||
x = *d % i;
|
||||
// Are there any significant digits past j?
|
||||
if (x || (d + 1) != z)
|
||||
{
|
||||
double round = 2 / math::DOUBLE_EPSILON;
|
||||
double small;
|
||||
if (((*d / i) & 1) || (i == 1000000000 && d > a && (d[-1] & 1)))
|
||||
{
|
||||
round += 2;
|
||||
}
|
||||
switch
|
||||
{
|
||||
case x < i / 2:
|
||||
small = 0x0.8p0;
|
||||
case x == i / 2 && d + 1 == z:
|
||||
small = 0x1.0p0;
|
||||
default:
|
||||
small = 0x1.8p0;
|
||||
}
|
||||
if (pl && is_neg)
|
||||
{
|
||||
round *= -1;
|
||||
small *= -1;
|
||||
}
|
||||
*d -= x;
|
||||
// Decide whether to round by probing round+small
|
||||
if (round + small != round)
|
||||
{
|
||||
*d = *d + i;
|
||||
while (*d > 999999999)
|
||||
{
|
||||
*d-- = 0;
|
||||
if (d < a) *--a = 0;
|
||||
(*d)++;
|
||||
}
|
||||
for (i = 10, e = (int)(9 * (r - a)); *a >= i; i *= 10, e++);
|
||||
}
|
||||
}
|
||||
if (z > d + 1) z = d + 1;
|
||||
}
|
||||
for (; z>a && !z[-1]; z--);
|
||||
|
||||
if (formatting == ADAPTIVE)
|
||||
{
|
||||
if (!p) p++;
|
||||
if (p > e && e >= -4)
|
||||
{
|
||||
formatting = FLOAT;
|
||||
p -= (isz)e + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
formatting = EXPONENTIAL;
|
||||
p--;
|
||||
}
|
||||
if (!self.flags.hash)
|
||||
{
|
||||
// Count trailing zeros in last place
|
||||
if (z > a && z[-1])
|
||||
{
|
||||
for (int i = 10, j = 0; z[-1] % i == 0; i *= 10, j++);
|
||||
}
|
||||
else
|
||||
{
|
||||
j = 9;
|
||||
}
|
||||
if (formatting == FLOAT)
|
||||
{
|
||||
p = math::min(p, math::max((isz)0, 9 * (z - r - 1) - j));
|
||||
}
|
||||
else
|
||||
{
|
||||
p = math::min(p, math::max((isz)0, 9 * (z - r - 1) + e - j));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
if (p > int.max - 1 - (isz)(p || self.flags.hash)) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
int l = (int)(1 + p + (isz)(p || self.flags.hash));
|
||||
char* estr @noinit;
|
||||
if (formatting == FLOAT)
|
||||
{
|
||||
if (e > int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
if (e > 0) l += e;
|
||||
}
|
||||
else
|
||||
{
|
||||
estr = fmt_u((uint128)(e < 0 ? -e : e), ebuf);
|
||||
while (ebuf - estr < 2) (--estr)[0] = '0';
|
||||
*--estr = (e < 0 ? '-' : '+');
|
||||
*--estr = self.flags.uppercase ? 'E' : 'e';
|
||||
if (ebuf - estr > (isz)int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
l += (int)(ebuf - estr);
|
||||
}
|
||||
if (l > int.max - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
usz len;
|
||||
if (!self.flags.left && !self.flags.zeropad) len += self.pad(' ', self.width, pl + l)!;
|
||||
if (is_neg || self.flags.plus) len += self.out(is_neg ? '-' : '+')!;
|
||||
if (self.flags.zeropad) len += self.pad('0', self.width, pl + l)!;
|
||||
if (formatting == FLOAT)
|
||||
{
|
||||
if (a > r) a = r;
|
||||
uint* d = a;
|
||||
for (; d <= r; d++)
|
||||
{
|
||||
char* s = fmt_u(*d, buf + 9);
|
||||
switch
|
||||
{
|
||||
case d != a:
|
||||
while (s > buf) (--s)[0] = '0';
|
||||
case s == buf + 9:
|
||||
*--s = '0';
|
||||
}
|
||||
len += self.out_chars(s[:buf + 9 - s])!;
|
||||
}
|
||||
if (p || self.flags.hash) len += self.out('.')!;
|
||||
for (; d < z && p > 0; d++, p -= 9)
|
||||
{
|
||||
char* s = fmt_u(*d, buf + 9);
|
||||
while (s > buf) *--s = '0';
|
||||
len += self.out_chars(s[:math::min((isz)9, p)])!;
|
||||
}
|
||||
len += self.pad('0', p + 9, 9)!;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (z <= a) z = a + 1;
|
||||
for (uint* d = a; d < z && p >= 0; d++)
|
||||
{
|
||||
char* s = fmt_u(*d, buf + 9);
|
||||
if (s == buf + 9) (--s)[0] = '0';
|
||||
if (d != a)
|
||||
{
|
||||
while (s > buf) (--s)[0] = '0';
|
||||
}
|
||||
else
|
||||
{
|
||||
len += self.out(s++[0])!;
|
||||
if (p > 0 || self.flags.hash) len += self.out('.')!;
|
||||
}
|
||||
len += self.out_chars(s[:math::min(buf + 9 - s, p)])!;
|
||||
p -= buf + 9 - s;
|
||||
}
|
||||
len += self.pad('0', p + 18, 18)!;
|
||||
len += self.out_chars(estr[:ebuf - estr])!;
|
||||
}
|
||||
|
||||
if (self.flags.left) len += self.pad(' ', self.width, pl + l)!;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
fn usz! Formatter.ntoa(&self, uint128 value, bool negative, uint base) @private
|
||||
{
|
||||
char[PRINTF_NTOA_BUFFER_SIZE] buf @noinit;
|
||||
usz len;
|
||||
|
||||
// no hash for 0 values
|
||||
if (!value) self.flags.hash = false;
|
||||
|
||||
// write if precision != 0 or value is != 0
|
||||
if (!self.flags.precision || value)
|
||||
{
|
||||
char past_10 = (self.flags.uppercase ? 'A' : 'a') - 10;
|
||||
do
|
||||
{
|
||||
if (len >= PRINTF_NTOA_BUFFER_SIZE) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
char digit = (char)(value % base);
|
||||
buf[len++] = digit + (digit < 10 ? '0' : past_10);
|
||||
value /= base;
|
||||
}
|
||||
while (value);
|
||||
}
|
||||
return self.ntoa_format((String)buf[:PRINTF_NTOA_BUFFER_SIZE], len, negative, base);
|
||||
}
|
||||
|
||||
fn usz! Formatter.ntoa_format(&self, String buf, usz len, bool negative, uint base) @private
|
||||
{
|
||||
// pad leading zeros
|
||||
if (!self.flags.left)
|
||||
{
|
||||
if (self.width && self.flags.zeropad && (negative || self.flags.plus || self.flags.space)) self.width--;
|
||||
while (len < self.prec)
|
||||
{
|
||||
if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
buf[len++] = '0';
|
||||
}
|
||||
while (self.flags.zeropad && len < self.width)
|
||||
{
|
||||
if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
buf[len++] = '0';
|
||||
}
|
||||
}
|
||||
|
||||
// handle hash
|
||||
if (self.flags.hash && base != 10)
|
||||
{
|
||||
if (!self.flags.precision && len && len == self.prec && len == self.width)
|
||||
{
|
||||
len--;
|
||||
if (len) len--;
|
||||
}
|
||||
if (base != 10)
|
||||
{
|
||||
if (len + 1 >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
switch (base)
|
||||
{
|
||||
case 16:
|
||||
buf[len++] = self.flags.uppercase ? 'X' : 'x';
|
||||
case 8:
|
||||
buf[len++] = self.flags.uppercase ? 'O' : 'o';
|
||||
case 2:
|
||||
buf[len++] = self.flags.uppercase ? 'B' : 'b';
|
||||
default:
|
||||
unreachable();
|
||||
}
|
||||
buf[len++] = '0';
|
||||
}
|
||||
}
|
||||
|
||||
switch (true)
|
||||
{
|
||||
case negative:
|
||||
if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
buf[len++] = '-';
|
||||
case self.flags.plus:
|
||||
if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
buf[len++] = '+';
|
||||
case self.flags.space:
|
||||
if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
|
||||
buf[len++] = ' ';
|
||||
}
|
||||
if (len) self.out_reverse(buf[:len])!;
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
fn usz! Formatter.ntoa_any(&self, any arg, uint base) @private
|
||||
{
|
||||
bool is_neg;
|
||||
uint128 val = int_from_any(arg, &is_neg)!!;
|
||||
return self.ntoa(val, is_neg, base) @inline;
|
||||
}
|
||||
|
||||
fn usz! Formatter.out_char(&self, any arg) @private
|
||||
{
|
||||
usz len = 1;
|
||||
uint l = 1;
|
||||
// pre padding
|
||||
len += self.adjust(l)!;
|
||||
// char output
|
||||
Char32 c = types::any_to_int(arg, uint) ?? 0xFFFD;
|
||||
switch (true)
|
||||
{
|
||||
case c < 0x7f:
|
||||
self.out((char)c)!;
|
||||
case c < 0x7ff:
|
||||
self.out((char)(0xC0 | c >> 6))!;
|
||||
self.out((char)(0x80 | (c & 0x3F)))!;
|
||||
case c < 0xffff:
|
||||
self.out((char)(0xE0 | c >> 12))!;
|
||||
self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
|
||||
self.out((char)(0x80 | (c & 0x3F)))!;
|
||||
default:
|
||||
self.out((char)(0xF0 | c >> 18))!;
|
||||
self.out((char)(0x80 | (c >> 12 & 0x3F)))!;
|
||||
self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
|
||||
self.out((char)(0x80 | (c & 0x3F)))!;
|
||||
}
|
||||
len += self.adjust(l)!;
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
fn usz! Formatter.out_reverse(&self, char[] buf) @private
|
||||
{
|
||||
usz n;
|
||||
usz buffer_start_idx = self.idx;
|
||||
usz len = buf.len;
|
||||
// pad spaces up to given width
|
||||
if (!self.flags.zeropad)
|
||||
{
|
||||
n += self.adjust(len)!;
|
||||
}
|
||||
// reverse string
|
||||
while (len) n += self.out(buf[--len])!;
|
||||
|
||||
// append pad spaces up to given width
|
||||
n += self.adjust(self.idx - buffer_start_idx)!;
|
||||
return n;
|
||||
}
|
||||
|
||||
fn void! printf_advance_format(usz format_len, usz *index_ptr) @inline @private
|
||||
{
|
||||
usz val = ++(*index_ptr);
|
||||
if (val >= format_len) return FormattingFault.UNTERMINATED_FORMAT?;
|
||||
}
|
||||
|
||||
fn any! next_any(any* args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
|
||||
{
|
||||
if (*arg_index_ptr >= args_len) return FormattingFault.MISSING_ARG?;
|
||||
return args_ptr[(*arg_index_ptr)++];
|
||||
}
|
||||
|
||||
fn int! printf_parse_format_field(
|
||||
any* args_ptr, usz args_len, usz* args_index_ptr,
|
||||
char* format_ptr, usz format_len, usz* index_ptr) @inline @private
|
||||
{
|
||||
char c = format_ptr[*index_ptr];
|
||||
if (c.is_digit()) return simple_atoi(format_ptr, format_len, index_ptr);
|
||||
if (c != '*') return 0;
|
||||
printf_advance_format(format_len, index_ptr)!;
|
||||
any val = next_any(args_ptr, args_len, args_index_ptr)!;
|
||||
if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG?;
|
||||
uint! intval = types::any_to_int(val, int);
|
||||
return intval ?? FormattingFault.INVALID_WIDTH_ARG?;
|
||||
}
|
||||
Reference in New Issue
Block a user