mirror of
https://github.com/Ed94/Odin.git
synced 2026-06-15 02:12:22 -07:00
Ginger Bill
500 lines
9.3 KiB
Odin
500 lines
9.3 KiB
Odin
import . "decimal.odin";
|
|
|
|
type IntFlag enum {
|
|
Prefix = 1<<0,
|
|
Plus = 1<<1,
|
|
Space = 1<<2,
|
|
}
|
|
|
|
|
|
proc parse_bool(s: string) -> (result: bool, ok: bool) {
|
|
match s {
|
|
case "1", "t", "T", "true", "TRUE", "True":
|
|
return true, true;
|
|
case "0", "f", "F", "false", "FALSE", "False":
|
|
return false, true;
|
|
}
|
|
return false, false;
|
|
}
|
|
|
|
proc _digit_value(r: rune) -> int {
|
|
var ri = int(r);
|
|
var v: int = 16;
|
|
match r {
|
|
case '0'..'9': v = ri-'0';
|
|
case 'a'..'z': v = ri-'a'+10;
|
|
case 'A'..'Z': v = ri-'A'+10;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
proc parse_i128(s: string) -> i128 {
|
|
var neg = false;
|
|
if len(s) > 1 {
|
|
match s[0] {
|
|
case '-':
|
|
neg = true;
|
|
s = s[1..];
|
|
case '+':
|
|
s = s[1..];
|
|
}
|
|
}
|
|
|
|
|
|
var base: i128 = 10;
|
|
if len(s) > 2 && s[0] == '0' {
|
|
match s[1] {
|
|
case 'b': base = 2; s = s[2..];
|
|
case 'o': base = 8; s = s[2..];
|
|
case 'd': base = 10; s = s[2..];
|
|
case 'z': base = 12; s = s[2..];
|
|
case 'x': base = 16; s = s[2..];
|
|
}
|
|
}
|
|
|
|
|
|
var value: i128;
|
|
for r in s {
|
|
if r == '_' {
|
|
continue;
|
|
}
|
|
|
|
var v = i128(_digit_value(r));
|
|
if v >= base {
|
|
break;
|
|
}
|
|
value *= base;
|
|
value += v;
|
|
}
|
|
|
|
return neg ? -value : value;
|
|
}
|
|
|
|
proc parse_u128(s: string) -> u128 {
|
|
var neg = false;
|
|
if len(s) > 1 && s[0] == '+' {
|
|
s = s[1..];
|
|
}
|
|
|
|
|
|
var base = u128(10);
|
|
if len(s) > 2 && s[0] == '0' {
|
|
match s[1] {
|
|
case 'b': base = 2; s = s[2..];
|
|
case 'o': base = 8; s = s[2..];
|
|
case 'd': base = 10; s = s[2..];
|
|
case 'z': base = 12; s = s[2..];
|
|
case 'x': base = 16; s = s[2..];
|
|
}
|
|
}
|
|
|
|
|
|
var value: u128;
|
|
for r in s {
|
|
if r == '_' {
|
|
continue;
|
|
}
|
|
|
|
var v = u128(_digit_value(r));
|
|
if v >= base {
|
|
break;
|
|
}
|
|
value *= base;
|
|
value += u128(v);
|
|
}
|
|
|
|
return neg ? -value : value;
|
|
}
|
|
|
|
|
|
proc parse_int(s: string) -> int {
|
|
return int(parse_i128(s));
|
|
}
|
|
proc parse_uint(s: string, base: int) -> uint {
|
|
return uint(parse_u128(s));
|
|
}
|
|
|
|
proc parse_f64(s: string) -> f64 {
|
|
var i = 0;
|
|
|
|
var sign: f64 = 1;
|
|
match s[i] {
|
|
case '-': i++; sign = -1;
|
|
case '+': i++;
|
|
}
|
|
|
|
var value: f64 = 0;
|
|
for ; i < len(s); i++ {
|
|
var r = rune(s[i]);
|
|
if r == '_' {
|
|
continue;
|
|
}
|
|
var v = _digit_value(r);
|
|
if v >= 10 {
|
|
break;
|
|
}
|
|
value *= 10;
|
|
value += f64(v);
|
|
}
|
|
|
|
if s[i] == '.' {
|
|
var pow10: f64 = 10;
|
|
i++;
|
|
|
|
for ; i < len(s); i++ {
|
|
var r = rune(s[i]);
|
|
if r == '_' {
|
|
continue;
|
|
}
|
|
var v = _digit_value(r);
|
|
if v >= 10 {
|
|
break;
|
|
}
|
|
value += f64(v)/pow10;
|
|
pow10 *= 10;
|
|
}
|
|
}
|
|
|
|
var frac = false;
|
|
var scale: f64 = 1;
|
|
|
|
if s[i] == 'e' || s[i] == 'E' {
|
|
i++;
|
|
|
|
match s[i] {
|
|
case '-': i++; frac = true;
|
|
case '+': i++;
|
|
}
|
|
|
|
var exp: u32 = 0;
|
|
for ; i < len(s); i++ {
|
|
var r = rune(s[i]);
|
|
if r == '_' {
|
|
continue;
|
|
}
|
|
var d = u32(_digit_value(r));
|
|
if d >= 10 {
|
|
break;
|
|
}
|
|
exp = exp * 10 + d;
|
|
}
|
|
if exp > 308 { exp = 308; }
|
|
|
|
for exp >= 50 { scale *= 1e50; exp -= 50; }
|
|
for exp >= 8 { scale *= 1e8; exp -= 8; }
|
|
for exp > 0 { scale *= 10; exp -= 1; }
|
|
}
|
|
|
|
return sign * (frac ? (value/scale) : (value*scale));
|
|
}
|
|
|
|
|
|
proc append_bool(buf: []u8, b: bool) -> string {
|
|
var s = b ? "true" : "false";
|
|
append(buf, ..[]u8(s));
|
|
return string(buf);
|
|
}
|
|
|
|
proc append_uint(buf: []u8, u: u64, base: int) -> string {
|
|
return append_bits(buf, u128(u), base, false, 8*size_of(uint), digits, 0);
|
|
}
|
|
proc append_int(buf: []u8, i: i64, base: int) -> string {
|
|
return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0);
|
|
}
|
|
proc itoa(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); }
|
|
|
|
proc append_float(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
|
|
return string(generic_ftoa(buf, f, fmt, prec, bit_size));
|
|
}
|
|
|
|
|
|
|
|
|
|
type DecimalSlice struct {
|
|
digits: []u8,
|
|
count: int,
|
|
decimal_point: int,
|
|
neg: bool,
|
|
}
|
|
|
|
type Float_Info struct {
|
|
mantbits: uint,
|
|
expbits: uint,
|
|
bias: int,
|
|
}
|
|
|
|
var (
|
|
_f16_info = Float_Info{10, 5, -15};
|
|
_f32_info = Float_Info{23, 8, -127};
|
|
_f64_info = Float_Info{52, 11, -1023};
|
|
)
|
|
|
|
proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
|
|
var bits: u64;
|
|
var flt: ^Float_Info;
|
|
match bit_size {
|
|
case 32:
|
|
bits = u64(transmute(u32, f32(val)));
|
|
flt = &_f32_info;
|
|
case 64:
|
|
bits = transmute(u64, val);
|
|
flt = &_f64_info;
|
|
case:
|
|
panic("strconv: invalid bit_size");
|
|
}
|
|
|
|
var neg = bits>>(flt.expbits+flt.mantbits) != 0;
|
|
var exp = int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
|
|
var mant = bits & (u64(1) << flt.mantbits - 1);
|
|
|
|
match exp {
|
|
case 1<<flt.expbits - 1:
|
|
var s: string;
|
|
if mant != 0 {
|
|
s = "NaN";
|
|
} else if neg {
|
|
s = "-Inf";
|
|
} else {
|
|
s = "+Inf";
|
|
}
|
|
append(buf, ..[]u8(s));
|
|
return buf;
|
|
|
|
case 0: // denormalized
|
|
exp++;
|
|
|
|
case:
|
|
mant |= u64(1) << flt.mantbits;
|
|
}
|
|
|
|
exp += flt.bias;
|
|
|
|
var d_: Decimal;
|
|
var d = &d_;
|
|
assign(d, mant);
|
|
shift(d, exp - int(flt.mantbits));
|
|
var digs: DecimalSlice;
|
|
var shortest = prec < 0;
|
|
if shortest {
|
|
round_shortest(d, mant, exp, flt);
|
|
digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
|
|
match fmt {
|
|
case 'e', 'E': prec = digs.count-1;
|
|
case 'f', 'F': prec = max(digs.count-digs.decimal_point, 0);
|
|
case 'g', 'G': prec = digs.count;
|
|
}
|
|
} else {
|
|
match fmt {
|
|
case 'e', 'E': round(d, prec+1);
|
|
case 'f', 'F': round(d, d.decimal_point+prec);
|
|
case 'g', 'G':
|
|
if prec == 0 {
|
|
prec = 1;
|
|
}
|
|
round(d, prec);
|
|
}
|
|
|
|
digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
|
|
}
|
|
return format_digits(buf, shortest, neg, digs, prec, fmt);
|
|
}
|
|
|
|
|
|
|
|
proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 {
|
|
match fmt {
|
|
case 'f', 'F':
|
|
append(buf, neg ? '-' : '+');
|
|
|
|
// integer, padded with zeros when needed
|
|
if digs.decimal_point > 0 {
|
|
var m = min(digs.count, digs.decimal_point);
|
|
append(buf, ..digs.digits[0..<m]);
|
|
for ; m < digs.decimal_point; m++ {
|
|
append(buf, '0');
|
|
}
|
|
} else {
|
|
append(buf, '0');
|
|
}
|
|
|
|
|
|
// fractional part
|
|
if prec > 0 {
|
|
append(buf, '.');
|
|
for i in 0..<prec {
|
|
var c: u8 = '0';
|
|
if var j = digs.decimal_point + i; 0 <= j && j < digs.count {
|
|
c = digs.digits[j];
|
|
}
|
|
append(buf, c);
|
|
}
|
|
}
|
|
|
|
return buf;
|
|
|
|
case 'e', 'E':
|
|
panic("strconv: e/E float printing is not yet supported");
|
|
return buf; // TODO
|
|
|
|
case 'g', 'G':
|
|
panic("strconv: g/G float printing is not yet supported");
|
|
return buf; // TODO
|
|
}
|
|
|
|
var c: [2]u8;
|
|
c[0] = '%';
|
|
c[1] = fmt;
|
|
append(buf, ..c[..]);
|
|
return buf;
|
|
}
|
|
|
|
proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
|
|
if mant == 0 { // If mantissa is zero, the number is zero
|
|
d.count = 0;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
10^(dp-nd) > 2^(exp-mantbits)
|
|
log2(10) * (dp-nd) > exp-mantbits
|
|
log(2) >~ 0.332
|
|
332*(dp-nd) >= 100*(exp-mantbits)
|
|
*/
|
|
var minexp = flt.bias+1;
|
|
if exp > minexp && 332*(d.decimal_point-d.count) >= 100*(exp - int(flt.mantbits)) {
|
|
// Number is already its shortest
|
|
return;
|
|
}
|
|
|
|
var upper_: Decimal; var upper = &upper_;
|
|
assign(upper, 2*mant - 1);
|
|
shift(upper, exp - int(flt.mantbits) - 1);
|
|
|
|
var mantlo: u64;
|
|
var explo: int;
|
|
if mant > 1<<flt.mantbits || exp == minexp {
|
|
mantlo = mant-1;
|
|
explo = exp;
|
|
} else {
|
|
mantlo = 2*mant - 1;
|
|
explo = exp-1;
|
|
}
|
|
var lower_: Decimal; var lower = &lower_;
|
|
assign(lower, 2*mantlo + 1);
|
|
shift(lower, explo - int(flt.mantbits) - 1);
|
|
|
|
var inclusive = mant%2 == 0;
|
|
|
|
for i in 0..<d.count {
|
|
var l: u8 = '0'; // lower digit
|
|
if i < lower.count {
|
|
l = lower.digits[i];
|
|
}
|
|
var m = d.digits[i]; // middle digit
|
|
var u: u8 = '0'; // upper digit
|
|
if i < upper.count {
|
|
u = upper.digits[i];
|
|
}
|
|
|
|
var ok_round_down = l != m || inclusive && i+1 == lower.count;
|
|
var ok_round_up = m != u && (inclusive || m+1 < u || i+1 < upper.count);
|
|
|
|
if (ok_round_down && ok_round_up) {
|
|
round(d, i+1);
|
|
return;
|
|
}
|
|
if (ok_round_down) {
|
|
round_down(d, i+1);
|
|
return;
|
|
}
|
|
if (ok_round_up) {
|
|
round_up(d, i+1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
const MAX_BASE = 32;
|
|
let digits = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
|
|
|
|
proc is_integer_negative(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
|
|
var neg = false;
|
|
if is_signed {
|
|
match bit_size {
|
|
case 8:
|
|
var i = i8(u);
|
|
neg = i < 0;
|
|
if neg { i = -i; }
|
|
u = u128(i);
|
|
case 16:
|
|
var i = i16(u);
|
|
neg = i < 0;
|
|
if neg { i = -i; }
|
|
u = u128(i);
|
|
case 32:
|
|
var i = i32(u);
|
|
neg = i < 0;
|
|
if neg { i = -i; }
|
|
u = u128(i);
|
|
case 64:
|
|
var i = i64(u);
|
|
neg = i < 0;
|
|
if neg { i = -i; }
|
|
u = u128(i);
|
|
case 128:
|
|
var i = i128(u);
|
|
neg = i < 0;
|
|
if neg { i = -i; }
|
|
u = u128(i);
|
|
case:
|
|
panic("is_integer_negative: Unknown integer size");
|
|
}
|
|
}
|
|
return u, neg;
|
|
}
|
|
|
|
proc append_bits(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
|
|
if base < 2 || base > MAX_BASE {
|
|
panic("strconv: illegal base passed to append_bits");
|
|
}
|
|
|
|
var a: [129]u8;
|
|
var i = len(a);
|
|
var u, neg = is_integer_negative(u_, is_signed, bit_size);
|
|
var b = u128(base);
|
|
for u >= b {
|
|
i--; a[i] = digits[uint(u % b)];
|
|
u /= b;
|
|
}
|
|
i--; a[i] = digits[uint(u % b)];
|
|
|
|
if flags&IntFlag.Prefix != 0 {
|
|
var ok = true;
|
|
match base {
|
|
case 2: i--; a[i] = 'b';
|
|
case 8: i--; a[i] = 'o';
|
|
case 10: i--; a[i] = 'd';
|
|
case 12: i--; a[i] = 'z';
|
|
case 16: i--; a[i] = 'x';
|
|
case: ok = false;
|
|
}
|
|
if ok {
|
|
i--; a[i] = '0';
|
|
}
|
|
}
|
|
|
|
if neg {
|
|
i--; a[i] = '-';
|
|
} else if flags&IntFlag.Plus != 0 {
|
|
i--; a[i] = '+';
|
|
} else if flags&IntFlag.Space != 0 {
|
|
i--; a[i] = ' ';
|
|
}
|
|
|
|
append(buf, ..a[i..]);
|
|
return string(buf);
|
|
}
|
|
|