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

Replace err != nil with or_return where appropriate

Browse Source
This commit is contained in:
gingerBill
2021-08-15 17:52:10 +01:00
parent b8661e0ae0
commit c27b8a71fd
8 changed files with 450 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/math/big/public.odin
+45 -46
View File
@@ -24,7 +24,7 @@ int_add :: proc(dest, a, b: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, a, b); err != nil { return err; }
internal_clear_if_uninitialized(dest, a, b) or_return;
/*
All parameters have been initialized.
*/
@@ -41,11 +41,11 @@ int_add_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
assert_if_nil(dest, a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return err; }
internal_clear_if_uninitialized(a) or_return;
/*
Grow destination as required.
*/
if err = grow(dest, a.used + 1); err != nil { return err; }
grow(dest, a.used + 1) or_return;
/*
All parameters have been initialized.
@@ -60,7 +60,7 @@ int_sub :: proc(dest, number, decrease: ^Int, allocator := context.allocator) ->
assert_if_nil(dest, number, decrease);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, number, decrease); err != nil { return err; }
internal_clear_if_uninitialized(dest, number, decrease) or_return;
/*
All parameters have been initialized.
*/
@@ -77,11 +77,11 @@ int_sub_digit :: proc(dest, a: ^Int, digit: DIGIT, allocator := context.allocato
assert_if_nil(dest, a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return err; }
internal_clear_if_uninitialized(a) or_return;
/*
Grow destination as required.
*/
if err = grow(dest, a.used + 1); err != nil { return err; }
grow(dest, a.used + 1) or_return;
/*
All parameters have been initialized.
@@ -97,11 +97,11 @@ int_halve :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Erro
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
/*
Grow destination as required.
*/
if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
if dest != src { grow(dest, src.used + 1) or_return }
return #force_inline internal_int_shr1(dest, src);
}
@@ -116,11 +116,11 @@ int_double :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Err
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
/*
Grow destination as required.
*/
if dest != src { if err = grow(dest, src.used + 1); err != nil { return err; } }
if dest != src { grow(dest, src.used + 1) or_return; }
return #force_inline internal_int_shl1(dest, src);
}
@@ -134,7 +134,7 @@ int_mul_digit :: proc(dest, src: ^Int, multiplier: DIGIT, allocator := context.a
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(src, dest); err != nil { return err; }
internal_clear_if_uninitialized(src, dest) or_return;
return #force_inline internal_int_mul_digit(dest, src, multiplier);
}
@@ -146,7 +146,7 @@ int_mul :: proc(dest, src, multiplier: ^Int, allocator := context.allocator) ->
assert_if_nil(dest, src, multiplier);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src, multiplier); err != nil { return err; }
internal_clear_if_uninitialized(dest, src, multiplier) or_return;
return #force_inline internal_int_mul(dest, src, multiplier);
}
@@ -166,7 +166,7 @@ int_divmod :: proc(quotient, remainder, numerator, denominator: ^Int, allocator
Early out if neither of the results is wanted.
*/
if quotient == nil && remainder == nil { return nil; }
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_divmod(quotient, remainder, numerator, denominator);
}
@@ -175,7 +175,7 @@ int_divmod_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocato
assert_if_nil(quotient, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator); err != nil { return 0, err; }
internal_clear_if_uninitialized(numerator) or_return;
return #force_inline internal_divmod(quotient, numerator, denominator);
}
@@ -185,7 +185,7 @@ int_div :: proc(quotient, numerator, denominator: ^Int, allocator := context.all
assert_if_nil(quotient, numerator, denominator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_divmod(quotient, nil, numerator, denominator);
}
@@ -194,11 +194,10 @@ int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocator :
assert_if_nil(quotient, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator); err != nil { return err; }
internal_clear_if_uninitialized(numerator) or_return;
remainder: DIGIT;
remainder, err = #force_inline internal_divmod(quotient, numerator, denominator);
return err;
_ = (#force_inline internal_divmod(quotient, numerator, denominator)) or_return;
return;
}
div :: proc { int_div, int_div_digit, };
@@ -211,7 +210,7 @@ int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.al
assert_if_nil(remainder, numerator, denominator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(numerator, denominator); err != nil { return err; }
internal_clear_if_uninitialized(numerator, denominator) or_return;
return #force_inline internal_int_mod(remainder, numerator, denominator);
}
@@ -229,7 +228,7 @@ int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := contex
assert_if_nil(remainder, number, addend);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, addend, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, addend, modulus) or_return;
return #force_inline internal_addmod(remainder, number, addend, modulus);
}
@@ -242,7 +241,7 @@ int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := cont
assert_if_nil(remainder, number, decrease);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, decrease, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, decrease, modulus) or_return;
return #force_inline internal_submod(remainder, number, decrease, modulus);
}
@@ -255,7 +254,7 @@ int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator :=
assert_if_nil(remainder, number, multiplicand);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, multiplicand, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, multiplicand, modulus) or_return;
return #force_inline internal_mulmod(remainder, number, multiplicand, modulus);
}
@@ -268,7 +267,7 @@ int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.alloca
assert_if_nil(remainder, number, modulus);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(number, modulus); err != nil { return err; }
internal_clear_if_uninitialized(number, modulus) or_return;
return #force_inline internal_sqrmod(remainder, number, modulus);
}
@@ -312,14 +311,14 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{};
defer internal_destroy(n_fac, k_fac, n_minus_k_fac);
if err = #force_inline internal_int_factorial(n_minus_k_fac, n - k); err != nil { return err; }
if err = #force_inline internal_int_factorial(k_fac, k); err != nil { return err; }
if err = #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac); err != nil { return err; }
(#force_inline internal_int_factorial(n_minus_k_fac, n - k)) or_return;
(#force_inline internal_int_factorial(k_fac, k)) or_return;
(#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac)) or_return;
if err = #force_inline internal_int_factorial(n_fac, n); err != nil { return err; }
if err = #force_inline internal_div(res, n_fac, k_fac); err != nil { return err; }
(#force_inline internal_int_factorial(n_fac, n)) or_return;
(#force_inline internal_div(res, n_fac, k_fac)) or_return;
return err;
return;
}
choose :: proc { int_choose_digit, };
@@ -331,7 +330,7 @@ int_gcd_lcm :: proc(res_gcd, res_lcm, a, b: ^Int, allocator := context.allocator
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_int_gcd_lcm(res_gcd, res_lcm, a, b);
}
gcd_lcm :: proc { int_gcd_lcm, };
@@ -359,8 +358,8 @@ int_mod_bits :: proc(remainder, numerator: ^Int, bits: int, allocator := context
assert_if_nil(remainder, numerator);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(remainder, numerator); err != nil { return err; }
if bits < 0 { return .Invalid_Argument; }
internal_clear_if_uninitialized(remainder, numerator) or_return;
if bits < 0 { return .Invalid_Argument; }
return #force_inline internal_int_mod_bits(remainder, numerator, bits);
}
@@ -375,7 +374,7 @@ int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) -> (res: i
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_int_log(a, base);
}
@@ -392,7 +391,7 @@ int_pow :: proc(dest, base: ^Int, power: int, allocator := context.allocator) ->
assert_if_nil(dest, base);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, base); err != nil { return err; }
internal_clear_if_uninitialized(dest, base) or_return;
return #force_inline internal_int_pow(dest, base, power);
}
@@ -420,7 +419,7 @@ int_sqrt :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error
assert_if_nil(dest, src);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_sqrt(dest, src);
}
@@ -446,7 +445,7 @@ int_root_n :: proc(dest, src: ^Int, n: int, allocator := context.allocator) -> (
/*
Initialize dest + src if needed.
*/
if err = internal_clear_if_uninitialized(dest, src); err != nil { return err; }
internal_clear_if_uninitialized(dest, src) or_return;
return #force_inline internal_int_root_n(dest, src, n);
}
@@ -466,7 +465,7 @@ int_is_zero :: proc(a: ^Int, allocator := context.allocator) -> (zero: bool, err
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_zero(a), nil;
}
@@ -475,7 +474,7 @@ int_is_positive :: proc(a: ^Int, allocator := context.allocator) -> (positive: b
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_positive(a), nil;
}
@@ -484,7 +483,7 @@ int_is_negative :: proc(a: ^Int, allocator := context.allocator) -> (negative: b
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_negative(a), nil;
}
@@ -493,7 +492,7 @@ int_is_even :: proc(a: ^Int, allocator := context.allocator) -> (even: bool, err
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_even(a), nil;
}
@@ -502,7 +501,7 @@ int_is_odd :: proc(a: ^Int, allocator := context.allocator) -> (odd: bool, err:
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_odd(a), nil;
}
@@ -515,7 +514,7 @@ int_is_power_of_two :: proc(a: ^Int, allocator := context.allocator) -> (res: bo
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return false, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_is_power_of_two(a), nil;
}
@@ -527,7 +526,7 @@ int_compare :: proc(a, b: ^Int, allocator := context.allocator) -> (comparison:
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return 0, err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_cmp(a, b), nil;
}
@@ -540,7 +539,7 @@ int_compare_digit :: proc(a: ^Int, b: DIGIT, allocator := context.allocator) ->
assert_if_nil(a);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a); err != nil { return 0, err; }
internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_cmp_digit(a, b), nil;
}
@@ -553,7 +552,7 @@ int_compare_magnitude :: proc(a, b: ^Int, allocator := context.allocator) -> (re
assert_if_nil(a, b);
context.allocator = allocator;
if err = internal_clear_if_uninitialized(a, b); err != nil { return 0, err; }
internal_clear_if_uninitialized(a, b) or_return;
return #force_inline internal_cmp_mag(a, b), nil;
}