ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-01 12:18:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove := with var and :: with const

Browse Source
This commit is contained in:
Ginger Bill
2017-06-12 11:48:12 +01:00
parent c2c935ba81
commit 8fafdb185c
31 changed files with 3264 additions and 3502 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/strconv.odin
+85 -85
View File
@@ -1,13 +1,13 @@
#import . "decimal.odin";
IntFlag :: enum {
const IntFlag = enum {
Prefix = 1<<0,
Plus = 1<<1,
Space = 1<<2,
}
parse_bool :: proc(s: string) -> (result: bool, ok: bool) {
const parse_bool = proc(s: string) -> (result: bool, ok: bool) {
match s {
case "1", "t", "T", "true", "TRUE", "True":
return true, true;
@@ -17,9 +17,9 @@ parse_bool :: proc(s: string) -> (result: bool, ok: bool) {
return false, false;
}
_digit_value :: proc(r: rune) -> (int) {
ri := int(r);
v: int = 16;
const _digit_value = proc(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;
@@ -28,8 +28,8 @@ _digit_value :: proc(r: rune) -> (int) {
return v;
}
parse_i128 :: proc(s: string) -> i128 {
neg := false;
const parse_i128 = proc(s: string) -> i128 {
var neg = false;
if len(s) > 1 {
match s[0] {
case '-':
@@ -41,7 +41,7 @@ parse_i128 :: proc(s: string) -> i128 {
}
base: i128 = 10;
var base: i128 = 10;
if len(s) > 2 && s[0] == '0' {
match s[1] {
case 'b': base = 2; s = s[2..];
@@ -53,13 +53,13 @@ parse_i128 :: proc(s: string) -> i128 {
}
value: i128;
var value: i128;
for r in s {
if r == '_' {
continue;
}
v := i128(_digit_value(r));
var v = i128(_digit_value(r));
if v >= base {
break;
}
@@ -70,14 +70,14 @@ parse_i128 :: proc(s: string) -> i128 {
return neg ? -value : value;
}
parse_u128 :: proc(s: string) -> u128 {
neg := false;
const parse_u128 = proc(s: string) -> u128 {
var neg = false;
if len(s) > 1 && s[0] == '+' {
s = s[1..];
}
base: = u128(10);
var base = u128(10);
if len(s) > 2 && s[0] == '0' {
match s[1] {
case 'b': base = 2; s = s[2..];
@@ -89,13 +89,13 @@ parse_u128 :: proc(s: string) -> u128 {
}
value: u128;
var value: u128;
for r in s {
if r == '_' {
continue;
}
v := u128(_digit_value(r));
var v = u128(_digit_value(r));
if v >= base {
break;
}
@@ -107,29 +107,29 @@ parse_u128 :: proc(s: string) -> u128 {
}
parse_int :: proc(s: string) -> int {
const parse_int = proc(s: string) -> int {
return int(parse_i128(s));
}
parse_uint :: proc(s: string, base: int) -> uint {
const parse_uint = proc(s: string, base: int) -> uint {
return uint(parse_u128(s));
}
parse_f64 :: proc(s: string) -> f64 {
i := 0;
const parse_f64 = proc(s: string) -> f64 {
var i = 0;
sign: f64 = 1;
var sign: f64 = 1;
match s[i] {
case '-': i++; sign = -1;
case '+': i++;
}
value: f64 = 0;
var value: f64 = 0;
for ; i < len(s); i++ {
r := rune(s[i]);
var r = rune(s[i]);
if r == '_' {
continue;
}
v := _digit_value(r);
var v = _digit_value(r);
if v >= 10 {
break;
}
@@ -138,15 +138,15 @@ parse_f64 :: proc(s: string) -> f64 {
}
if s[i] == '.' {
pow10: f64 = 10;
var pow10: f64 = 10;
i++;
for ; i < len(s); i++ {
r := rune(s[i]);
var r = rune(s[i]);
if r == '_' {
continue;
}
v := _digit_value(r);
var v = _digit_value(r);
if v >= 10 {
break;
}
@@ -155,8 +155,8 @@ parse_f64 :: proc(s: string) -> f64 {
}
}
frac := false;
scale: f64 = 1;
var frac = false;
var scale: f64 = 1;
if s[i] == 'e' || s[i] == 'E' {
i++;
@@ -166,13 +166,13 @@ parse_f64 :: proc(s: string) -> f64 {
case '+': i++;
}
exp: u32 = 0;
var exp: u32 = 0;
for ; i < len(s); i++ {
r := rune(s[i]);
var r = rune(s[i]);
if r == '_' {
continue;
}
d := u32(_digit_value(r));
var d = u32(_digit_value(r));
if d >= 10 {
break;
}
@@ -189,48 +189,48 @@ parse_f64 :: proc(s: string) -> f64 {
}
append_bool :: proc(buf: []u8, b: bool) -> string {
s := b ? "true" : "false";
const append_bool = proc(buf: []u8, b: bool) -> string {
var s = b ? "true" : "false";
append(buf, ..[]u8(s));
return string(buf);
}
append_uint :: proc(buf: []u8, u: u64, base: int) -> string {
const append_uint = proc(buf: []u8, u: u64, base: int) -> string {
return append_bits(buf, u128(u), base, false, 8*size_of(uint), digits, 0);
}
append_int :: proc(buf: []u8, i: i64, base: int) -> string {
const append_int = proc(buf: []u8, i: i64, base: int) -> string {
return append_bits(buf, u128(i), base, true, 8*size_of(int), digits, 0);
}
itoa :: proc(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); }
const itoa = proc(buf: []u8, i: int) -> string { return append_int(buf, i64(i), 10); }
append_float :: proc(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
const append_float = proc(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
return string(generic_ftoa(buf, f, fmt, prec, bit_size));
}
DecimalSlice :: struct {
const DecimalSlice = struct {
digits: []u8,
count: int,
decimal_point: int,
neg: bool,
}
Float_Info :: struct {
const Float_Info = struct {
mantbits: uint,
expbits: uint,
bias: int,
}
_f16_info := Float_Info{10, 5, -15};
_f32_info := Float_Info{23, 8, -127};
_f64_info := Float_Info{52, 11, -1023};
var _f16_info = Float_Info{10, 5, -15};
var _f32_info = Float_Info{23, 8, -127};
var _f64_info = Float_Info{52, 11, -1023};
generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
bits: u64;
flt: ^Float_Info;
const generic_ftoa = proc(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)));
@@ -242,13 +242,13 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
panic("strconv: invalid bit_size");
}
neg := bits>>(flt.expbits+flt.mantbits) != 0;
exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & (u64(1) << flt.mantbits - 1);
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:
s: string;
var s: string;
if mant != 0 {
s = "NaN";
} else if neg {
@@ -268,12 +268,12 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
exp += flt.bias;
d_: Decimal;
d := &d_;
var d_: Decimal;
var d = &d_;
assign(d, mant);
shift(d, exp - int(flt.mantbits));
digs: DecimalSlice;
shortest := prec < 0;
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};
@@ -300,14 +300,14 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 {
const format_digits = proc(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 {
m := min(digs.count, digs.decimal_point);
var m = min(digs.count, digs.decimal_point);
append(buf, ..digs.digits[0..<m]);
for ; m < digs.decimal_point; m++ {
append(buf, '0');
@@ -321,8 +321,8 @@ format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice,
if prec > 0 {
append(buf, '.');
for i in 0..<prec {
c: u8 = '0';
if j := digs.decimal_point + i; 0 <= j && j < digs.count {
var c: u8 = '0';
if var j = digs.decimal_point + i; 0 <= j && j < digs.count {
c = digs.digits[j];
}
append(buf, c);
@@ -340,14 +340,14 @@ format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice,
return buf; // TODO
}
c: [2]u8;
var c: [2]u8;
c[0] = '%';
c[1] = fmt;
append(buf, ..c[..]);
return buf;
}
round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
const round_shortest = proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
if mant == 0 { // If mantissa is zero, the number is zero
d.count = 0;
return;
@@ -359,18 +359,18 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
log(2) >~ 0.332
332*(dp-nd) >= 100*(exp-mantbits)
*/
minexp := flt.bias+1;
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;
}
upper_: Decimal; upper: = &upper_;
var upper_: Decimal; var upper = &upper_;
assign(upper, 2*mant - 1);
shift(upper, exp - int(flt.mantbits) - 1);
mantlo: u64;
explo: int;
var mantlo: u64;
var explo: int;
if mant > 1<<flt.mantbits || exp == minexp {
mantlo = mant-1;
explo = exp;
@@ -378,25 +378,25 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
mantlo = 2*mant - 1;
explo = exp-1;
}
lower_: Decimal; lower: = &lower_;
var lower_: Decimal; var lower = &lower_;
assign(lower, 2*mantlo + 1);
shift(lower, explo - int(flt.mantbits) - 1);
inclusive := mant%2 == 0;
var inclusive = mant%2 == 0;
for i in 0..<d.count {
l: u8 = '0'; // lower digit
var l: u8 = '0'; // lower digit
if i < lower.count {
l = lower.digits[i];
}
m := d.digits[i]; // middle digit
u: u8 = '0'; // upper digit
var m = d.digits[i]; // middle digit
var u: u8 = '0'; // upper digit
if i < upper.count {
u = upper.digits[i];
}
ok_round_down := l != m || inclusive && i+1 == lower.count;
ok_round_up := m != u && (inclusive || m+1 < u || i+1 < upper.count);
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);
@@ -414,36 +414,36 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
}
MAX_BASE :: 32;
immutable digits := "0123456789abcdefghijklmnopqrstuvwxyz";
const MAX_BASE = 32;
immutable var digits = "0123456789abcdefghijklmnopqrstuvwxyz";
is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
neg := false;
const is_integer_negative = proc(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
var neg = false;
if is_signed {
match bit_size {
case 8:
i := i8(u);
var i = i8(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 16:
i := i16(u);
var i = i16(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 32:
i := i32(u);
var i = i32(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 64:
i := i64(u);
var i = i64(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
case 128:
i := i128(u);
var i = i128(u);
neg = i < 0;
if neg { i = -i; }
u = u128(i);
@@ -454,15 +454,15 @@ is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigne
return u, neg;
}
append_bits :: proc(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: IntFlag) -> string {
const append_bits = proc(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");
}
a: [129]u8;
i := len(a);
u, neg := is_integer_negative(u_, is_signed, bit_size);
b := u128(base);
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;
@@ -470,7 +470,7 @@ append_bits :: proc(buf: []u8, u_: u128, base: int, is_signed: bool, bit_size: i
i--; a[i] = digits[uint(u % b)];
if flags&IntFlag.Prefix != 0 {
ok := true;
var ok = true;
match base {
case 2: i--; a[i] = 'b';
case 8: i--; a[i] = 'o';