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

Improve parsing for or_return; allow #force_inline foo() or_return;

Browse Source
This commit is contained in:
gingerBill
2021-08-16 11:58:50 +01:00
parent 4c306a6f99
commit e3fef2dade
7 changed files with 59 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/math/big/helpers.odin
+18 -18
View File
@@ -42,7 +42,7 @@ int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, allocator :
Check that `src` is usable and `dest` isn't immutable. Check that `src` is usable and `dest` isn't immutable.
*/ */
assert_if_nil(dest); assert_if_nil(dest);
(#force_inline internal_error_if_immutable(dest)) or_return; #force_inline internal_error_if_immutable(dest) or_return;
return #force_inline internal_int_set_from_integer(dest, src, minimize); return #force_inline internal_int_set_from_integer(dest, src, minimize);
} }
@@ -64,8 +64,8 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
assert_if_nil(dest, src); assert_if_nil(dest, src);
context.allocator = allocator; context.allocator = allocator;
(#force_inline internal_clear_if_uninitialized(src)) or_return; #force_inline internal_clear_if_uninitialized(src) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return; #force_inline internal_error_if_immutable(dest) or_return;
return #force_inline internal_int_copy(dest, src, minimize); return #force_inline internal_int_copy(dest, src, minimize);
} }
@@ -92,8 +92,8 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
assert_if_nil(dest, src); assert_if_nil(dest, src);
context.allocator = allocator; context.allocator = allocator;
(#force_inline internal_clear_if_uninitialized(src)) or_return; #force_inline internal_clear_if_uninitialized(src) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return; #force_inline internal_error_if_immutable(dest) or_return;
return #force_inline internal_int_abs(dest, src); return #force_inline internal_int_abs(dest, src);
} }
@@ -113,8 +113,8 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
assert_if_nil(dest, src); assert_if_nil(dest, src);
context.allocator = allocator; context.allocator = allocator;
(#force_inline internal_clear_if_uninitialized(src)) or_return; #force_inline internal_clear_if_uninitialized(src) or_return;
(#force_inline internal_error_if_immutable(dest)) or_return; #force_inline internal_error_if_immutable(dest) or_return;
return #force_inline internal_int_neg(dest, src); return #force_inline internal_int_neg(dest, src);
} }
@@ -134,7 +134,7 @@ int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.a
assert_if_nil(a); assert_if_nil(a);
context.allocator = allocator; context.allocator = allocator;
(#force_inline internal_clear_if_uninitialized(a)) or_return; #force_inline internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_int_bitfield_extract(a, offset, count); return #force_inline internal_int_bitfield_extract(a, offset, count);
} }
@@ -148,7 +148,7 @@ shrink :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a); assert_if_nil(a);
context.allocator = allocator; context.allocator = allocator;
(#force_inline internal_clear_if_uninitialized(a)) or_return; #force_inline internal_clear_if_uninitialized(a) or_return;
return #force_inline internal_shrink(a); return #force_inline internal_shrink(a);
} }
@@ -305,7 +305,7 @@ int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T,
Check that `a` is usable. Check that `a` is usable.
*/ */
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
return #force_inline internal_int_get(a, T); return #force_inline internal_int_get(a, T);
} }
get :: proc { int_get, }; get :: proc { int_get, };
@@ -315,7 +315,7 @@ int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err
Check that `a` is usable. Check that `a` is usable.
*/ */
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
return #force_inline internal_int_get_float(a); return #force_inline internal_int_get_float(a);
} }
@@ -327,7 +327,7 @@ count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err:
Check that `a` is usable. Check that `a` is usable.
*/ */
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
return #force_inline internal_count_bits(a), nil; return #force_inline internal_count_bits(a), nil;
} }
@@ -340,7 +340,7 @@ int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, e
Check that `a` is usable. Check that `a` is usable.
*/ */
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
return #force_inline internal_int_count_lsb(a); return #force_inline internal_int_count_lsb(a);
} }
@@ -398,7 +398,7 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
assert_if_nil(..args); assert_if_nil(..args);
for i in &args { for i in &args {
(#force_inline internal_clear_if_uninitialized_single(i, allocator)) or_return; #force_inline internal_clear_if_uninitialized_single(i, allocator) or_return;
} }
return err; return err;
} }
@@ -425,7 +425,7 @@ int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err
integers := integers; integers := integers;
for a in &integers { for a in &integers {
(#force_inline internal_clear(a, true, allocator)) or_return; #force_inline internal_clear(a, true, allocator) or_return;
} }
return nil; return nil;
} }
@@ -440,7 +440,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
Check that `src` is usable and `dest` isn't immutable. Check that `src` is usable and `dest` isn't immutable.
*/ */
assert_if_nil(dest, src); assert_if_nil(dest, src);
(#force_inline internal_clear_if_uninitialized(src)) or_return; #force_inline internal_clear_if_uninitialized(src) or_return;
digits = min(digits, len(src.digit), len(dest.digit)); digits = min(digits, len(src.digit), len(dest.digit));
return #force_inline internal_copy_digits(dest, src, digits); return #force_inline internal_copy_digits(dest, src, digits);
@@ -454,7 +454,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
*/ */
clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) { clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
for a.used > 0 && a.digit[a.used - 1] == 0 { for a.used > 0 && a.digit[a.used - 1] == 0 {
a.used -= 1; a.used -= 1;
@@ -472,7 +472,7 @@ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
*/ */
int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) { int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) {
assert_if_nil(a); assert_if_nil(a);
(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return; #force_inline internal_clear_if_uninitialized(a, allocator) or_return;
size_in_bits := internal_count_bits(a); size_in_bits := internal_count_bits(a);
core/math/big/internal.odin
+9 -9
View File
@@ -852,7 +852,7 @@ internal_div :: proc { internal_int_div, };
Asssumes quotient, numerator and denominator to have been initialized and not to be nil. Asssumes quotient, numerator and denominator to have been initialized and not to be nil.
*/ */
internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) { internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
(#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator)) or_return; #force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return;
if remainder.used == 0 || denominator.sign == remainder.sign { return nil; } if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
@@ -864,7 +864,7 @@ internal_mod :: proc{ internal_int_mod, };
remainder = (number + addend) % modulus. remainder = (number + addend) % modulus.
*/ */
internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) { internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
(#force_inline internal_add(remainder, number, addend, allocator)) or_return; #force_inline internal_add(remainder, number, addend, allocator) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator); return #force_inline internal_mod(remainder, remainder, modulus, allocator);
} }
internal_addmod :: proc { internal_int_addmod, }; internal_addmod :: proc { internal_int_addmod, };
@@ -873,7 +873,7 @@ internal_addmod :: proc { internal_int_addmod, };
remainder = (number - decrease) % modulus. remainder = (number - decrease) % modulus.
*/ */
internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) { internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
(#force_inline internal_sub(remainder, number, decrease, allocator)) or_return; #force_inline internal_sub(remainder, number, decrease, allocator) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator); return #force_inline internal_mod(remainder, remainder, modulus, allocator);
} }
internal_submod :: proc { internal_int_submod, }; internal_submod :: proc { internal_int_submod, };
@@ -882,7 +882,7 @@ internal_submod :: proc { internal_int_submod, };
remainder = (number * multiplicand) % modulus. remainder = (number * multiplicand) % modulus.
*/ */
internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) { internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
(#force_inline internal_mul(remainder, number, multiplicand, allocator)) or_return; #force_inline internal_mul(remainder, number, multiplicand, allocator) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator); return #force_inline internal_mod(remainder, remainder, modulus, allocator);
} }
internal_mulmod :: proc { internal_int_mulmod, }; internal_mulmod :: proc { internal_int_mulmod, };
@@ -891,7 +891,7 @@ internal_mulmod :: proc { internal_int_mulmod, };
remainder = (number * number) % modulus. remainder = (number * number) % modulus.
*/ */
internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) { internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
(#force_inline internal_sqr(remainder, number, allocator)) or_return; #force_inline internal_sqr(remainder, number, allocator) or_return;
return #force_inline internal_mod(remainder, remainder, modulus, allocator); return #force_inline internal_mod(remainder, remainder, modulus, allocator);
} }
internal_sqrmod :: proc { internal_int_sqrmod, }; internal_sqrmod :: proc { internal_int_sqrmod, };
@@ -914,7 +914,7 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
return #force_inline internal_set(res, _factorial_table[n]); return #force_inline internal_set(res, _factorial_table[n]);
} }
(#force_inline internal_set(res, _factorial_table[i - 1])) or_return; #force_inline internal_set(res, _factorial_table[i - 1]) or_return;
for { for {
if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n { if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n {
return err; return err;
@@ -1629,7 +1629,7 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
internal_set :: proc { internal_int_set_from_integer, internal_int_copy }; internal_set :: proc { internal_int_set_from_integer, internal_int_copy };
internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int) -> (err: Error) { internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int) -> (err: Error) {
(#force_inline internal_error_if_immutable(dest)) or_return; #force_inline internal_error_if_immutable(dest) or_return;
/* /*
If dest == src, do nothing If dest == src, do nothing
@@ -2436,7 +2436,7 @@ internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context
/* /*
Resize `quotient` to accomodate extra digits. Resize `quotient` to accomodate extra digits.
*/ */
(#force_inline internal_grow(quotient, quotient.used + digits)) or_return; #force_inline internal_grow(quotient, quotient.used + digits) or_return;
/* /*
Increment the used by the shift amount then copy upwards. Increment the used by the shift amount then copy upwards.
@@ -2534,7 +2534,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
digits += 1; digits += 1;
} }
(#force_inline internal_grow(dest, digits)) or_return; #force_inline internal_grow(dest, digits) or_return;
for i := 0; i < digits; i += 1 { for i := 0; i < digits; i += 1 {
dest.digit[i] = int_random_digit(r) & _MASK; dest.digit[i] = int_random_digit(r) & _MASK;
core/math/big/prime.odin
+1 -1
View File
@@ -22,7 +22,7 @@ int_prime_is_divisible :: proc(a: ^Int, allocator := context.allocator) -> (res:
internal_clear_if_uninitialized(a) or_return; internal_clear_if_uninitialized(a) or_return;
for prime in _private_prime_table { for prime in _private_prime_table {
rem := (#force_inline int_mod_digit(a, prime)) or_return; rem := #force_inline int_mod_digit(a, prime) or_return;
if rem == 0 { if rem == 0 {
return true, nil; return true, nil;
} }
core/math/big/private.odin
+4 -4
View File
@@ -1268,17 +1268,17 @@ _private_int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) -
} }
low = high; low = high;
(#force_inline internal_copy(bracket_low, bracket_high)) or_return; #force_inline internal_copy(bracket_low, bracket_high) or_return;
high <<= 1; high <<= 1;
(#force_inline internal_sqr(bracket_high, bracket_high)) or_return; #force_inline internal_sqr(bracket_high, bracket_high) or_return;
} }
for (high - low) > 1 { for (high - low) > 1 {
mid := (high + low) >> 1; mid := (high + low) >> 1;
(#force_inline internal_pow(t, bi_base, mid - low)) or_return; #force_inline internal_pow(t, bi_base, mid - low) or_return;
(#force_inline internal_mul(bracket_mid, bracket_low, t)) or_return; #force_inline internal_mul(bracket_mid, bracket_low, t) or_return;
mc := #force_inline internal_cmp(a, bracket_mid); mc := #force_inline internal_cmp(a, bracket_mid);
switch mc { switch mc {
core/math/big/public.odin
+6 -6
View File
@@ -196,7 +196,7 @@ int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocator :
internal_clear_if_uninitialized(numerator) or_return; internal_clear_if_uninitialized(numerator) or_return;
_ = (#force_inline internal_divmod(quotient, numerator, denominator)) or_return; _ = #force_inline internal_divmod(quotient, numerator, denominator) or_return;
return; return;
} }
div :: proc { int_div, int_div_digit, }; div :: proc { int_div, int_div_digit, };
@@ -311,12 +311,12 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{}; n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{};
defer internal_destroy(n_fac, k_fac, n_minus_k_fac); defer internal_destroy(n_fac, k_fac, n_minus_k_fac);
(#force_inline internal_int_factorial(n_minus_k_fac, n - k)) or_return; #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_int_factorial(k_fac, k) or_return;
(#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac)) or_return; #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac) or_return;
(#force_inline internal_int_factorial(n_fac, n)) or_return; #force_inline internal_int_factorial(n_fac, n) or_return;
(#force_inline internal_div(res, n_fac, k_fac)) or_return; #force_inline internal_div(res, n_fac, k_fac) or_return;
return; return;
} }
src/check_stmt.cpp
-15
View File
@@ -1456,21 +1456,6 @@ bool all_operands_valid(Array<Operand> const &operands) {
return true; return true;
} }
Ast *strip_or_return_expr(Ast *node) {
for (;;) {
if (node == nullptr) {
return node;
}
if (node->kind == Ast_OrReturnExpr) {
node = node->OrReturnExpr.expr;
} else if (node->kind == Ast_ParenExpr) {
node = node->ParenExpr.expr;
} else {
return node;
}
}
}
void check_stmt_internal(CheckerContext *ctx, Ast *node, u32 flags) { void check_stmt_internal(CheckerContext *ctx, Ast *node, u32 flags) {
u32 mod_flags = flags & (~Stmt_FallthroughAllowed); u32 mod_flags = flags & (~Stmt_FallthroughAllowed);
switch (node->kind) { switch (node->kind) {
src/parser.cpp
+21 -6
View File
@@ -1698,6 +1698,22 @@ Ast *unselector_expr(Ast *node) {
return node; return node;
} }
Ast *strip_or_return_expr(Ast *node) {
for (;;) {
if (node == nullptr) {
return node;
}
if (node->kind == Ast_OrReturnExpr) {
node = node->OrReturnExpr.expr;
} else if (node->kind == Ast_ParenExpr) {
node = node->ParenExpr.expr;
} else {
return node;
}
}
}
Ast *parse_value(AstFile *f); Ast *parse_value(AstFile *f);
Array<Ast *> parse_element_list(AstFile *f) { Array<Ast *> parse_element_list(AstFile *f) {
@@ -1916,7 +1932,7 @@ bool ast_on_same_line(Ast *x, Ast *y) {
Ast *parse_force_inlining_operand(AstFile *f, Token token) { Ast *parse_force_inlining_operand(AstFile *f, Token token) {
Ast *expr = parse_unary_expr(f, false); Ast *expr = parse_unary_expr(f, false);
Ast *e = unparen_expr(expr); Ast *e = strip_or_return_expr(expr);
if (e->kind != Ast_ProcLit && e->kind != Ast_CallExpr) { if (e->kind != Ast_ProcLit && e->kind != Ast_CallExpr) {
syntax_error(expr, "%.*s must be followed by a procedure literal or call, got %.*s", LIT(token.string), LIT(ast_strings[expr->kind])); syntax_error(expr, "%.*s must be followed by a procedure literal or call, got %.*s", LIT(token.string), LIT(ast_strings[expr->kind]));
return ast_bad_expr(f, token, f->curr_token); return ast_bad_expr(f, token, f->curr_token);
@@ -2801,6 +2817,10 @@ Ast *parse_atom_expr(AstFile *f, Ast *operand, bool lhs) {
operand = ast_deref_expr(f, operand, expect_token(f, Token_Pointer)); operand = ast_deref_expr(f, operand, expect_token(f, Token_Pointer));
break; break;
case Token_or_return:
operand = ast_or_return_expr(f, operand, expect_token(f, Token_or_return));
break;
case Token_OpenBrace: case Token_OpenBrace:
if (!lhs && is_literal_type(operand) && f->expr_level >= 0) { if (!lhs && is_literal_type(operand) && f->expr_level >= 0) {
operand = parse_literal_value(f, operand); operand = parse_literal_value(f, operand);
@@ -2895,7 +2915,6 @@ i32 token_precedence(AstFile *f, TokenKind t) {
case Token_if: case Token_if:
case Token_when: case Token_when:
case Token_or_else: case Token_or_else:
case Token_or_return:
return 1; return 1;
case Token_Ellipsis: case Token_Ellipsis:
case Token_RangeFull: case Token_RangeFull:
@@ -2954,8 +2973,6 @@ Ast *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) {
switch (op.kind) { switch (op.kind) {
case Token_if: case Token_if:
case Token_when: case Token_when:
case Token_or_else:
case Token_or_return:
if (prev.pos.line < op.pos.line) { if (prev.pos.line < op.pos.line) {
// NOTE(bill): Check to see if the `if` or `when` is on the same line of the `lhs` condition // NOTE(bill): Check to see if the `if` or `when` is on the same line of the `lhs` condition
goto loop_end; goto loop_end;
@@ -2989,8 +3006,6 @@ Ast *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) {
Ast *x = expr; Ast *x = expr;
Ast *y = parse_expr(f, lhs); Ast *y = parse_expr(f, lhs);
expr = ast_or_else_expr(f, x, op, y); expr = ast_or_else_expr(f, x, op, y);
} else if (op.kind == Token_or_return) {
expr = ast_or_return_expr(f, expr, op);
} else { } else {
Ast *right = parse_binary_expr(f, false, prec+1); Ast *right = parse_binary_expr(f, false, prec+1);
if (right == nullptr) { if (right == nullptr) {