From 28583bfff88ff1378a0e71030701071dcfd37462 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sun, 2 Dec 2018 18:01:03 +0000 Subject: [PATCH] Change procedure group syntax from `proc[]` to `proc{}`; deprecate `proc[]` (raises warning currently) --- core/bits/bits.odin | 20 +++++++++---------- core/math/math.odin | 44 ++++++++++++++++++++--------------------- core/mem/alloc.odin | 8 ++++---- core/mem/mem.odin | 2 +- core/mem/raw.odin | 2 +- core/runtime/core.odin | 28 +++++++++++++------------- examples/demo/demo.odin | 20 ++++++++----------- src/check_expr.cpp | 4 ++-- src/parser.cpp | 25 ++++++++++++++++++++++- 9 files changed, 85 insertions(+), 68 deletions(-) diff --git a/core/bits/bits.odin b/core/bits/bits.odin index 38a639efa..51f24b1bf 100644 --- a/core/bits/bits.odin +++ b/core/bits/bits.odin @@ -66,7 +66,7 @@ byte_swap_int :: proc(i: int) -> int { } } -byte_swap :: proc[ +byte_swap :: proc{ byte_swap_u16, byte_swap_u32, byte_swap_u64, @@ -75,7 +75,7 @@ byte_swap :: proc[ byte_swap_i64, byte_swap_uint, byte_swap_int, -]; +}; count_zeros8 :: proc(i: u8) -> u8 { return 8 - count_ones8(i); } count_zeros16 :: proc(i: u16) -> u16 { return 16 - count_ones16(i); } @@ -150,13 +150,13 @@ overflowing_add_int :: proc(lhs, rhs: int) -> (int, bool) { } } -overflowing_add :: proc[ +overflowing_add :: proc{ overflowing_add_u8, overflowing_add_i8, overflowing_add_u16, overflowing_add_i16, overflowing_add_u32, overflowing_add_i32, overflowing_add_u64, overflowing_add_i64, overflowing_add_uint, overflowing_add_int, -]; +}; foreign { @(link_name="llvm.usub.with.overflow.i8") overflowing_sub_u8 :: proc(lhs, rhs: u8) -> (u8, bool) --- @@ -187,13 +187,13 @@ overflowing_sub_int :: proc(lhs, rhs: int) -> (int, bool) { } } -overflowing_sub :: proc[ +overflowing_sub :: proc{ overflowing_sub_u8, overflowing_sub_i8, overflowing_sub_u16, overflowing_sub_i16, overflowing_sub_u32, overflowing_sub_i32, overflowing_sub_u64, overflowing_sub_i64, overflowing_sub_uint, overflowing_sub_int, -]; +}; foreign { @@ -225,13 +225,13 @@ overflowing_mul_int :: proc(lhs, rhs: int) -> (int, bool) { } } -overflowing_mul :: proc[ +overflowing_mul :: proc{ overflowing_mul_u8, overflowing_mul_i8, overflowing_mul_u16, overflowing_mul_i16, overflowing_mul_u32, overflowing_mul_i32, overflowing_mul_u64, overflowing_mul_i64, overflowing_mul_uint, overflowing_mul_int, -]; +}; is_power_of_two_u8 :: proc(i: u8) -> bool { return i > 0 && (i & (i-1)) == 0; } is_power_of_two_i8 :: proc(i: i8) -> bool { return i > 0 && (i & (i-1)) == 0; } @@ -244,10 +244,10 @@ is_power_of_two_i64 :: proc(i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0; } is_power_of_two_int :: proc(i: int) -> bool { return i > 0 && (i & (i-1)) == 0; } -is_power_of_two :: proc[ +is_power_of_two :: proc{ is_power_of_two_u8, is_power_of_two_i8, is_power_of_two_u16, is_power_of_two_i16, is_power_of_two_u32, is_power_of_two_i32, is_power_of_two_u64, is_power_of_two_i64, is_power_of_two_uint, is_power_of_two_int, -] +}; diff --git a/core/math/math.odin b/core/math/math.odin index daad97e5c..9e38c6549 100644 --- a/core/math/math.odin +++ b/core/math/math.odin @@ -63,7 +63,7 @@ foreign _ { log_f64 :: proc(x: f64) -> f64 ---; } -log :: proc[log_f32, log_f64]; +log :: proc{log_f32, log_f64}; tan_f32 :: proc "c" (θ: f32) -> f32 { return sin(θ)/cos(θ); } tan_f64 :: proc "c" (θ: f64) -> f64 { return sin(θ)/cos(θ); } @@ -94,31 +94,31 @@ copy_sign_f64 :: proc(x, y: f64) -> f64 { } -sqrt :: proc[sqrt_f32, sqrt_f64]; -sin :: proc[sin_f32, sin_f64]; -cos :: proc[cos_f32, cos_f64]; -tan :: proc[tan_f32, tan_f64]; -pow :: proc[pow_f32, pow_f64]; -fmuladd :: proc[fmuladd_f32, fmuladd_f64]; -sign :: proc[sign_f32, sign_f64]; -copy_sign :: proc[copy_sign_f32, copy_sign_f64]; +sqrt :: proc{sqrt_f32, sqrt_f64}; +sin :: proc{sin_f32, sin_f64}; +cos :: proc{cos_f32, cos_f64}; +tan :: proc{tan_f32, tan_f64}; +pow :: proc{pow_f32, pow_f64}; +fmuladd :: proc{fmuladd_f32, fmuladd_f64}; +sign :: proc{sign_f32, sign_f64}; +copy_sign :: proc{copy_sign_f32, copy_sign_f64}; round_f32 :: proc(x: f32) -> f32 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); } round_f64 :: proc(x: f64) -> f64 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); } -round :: proc[round_f32, round_f64]; +round :: proc{round_f32, round_f64}; floor_f32 :: proc(x: f32) -> f32 { return x >= 0 ? f32(i64(x)) : f32(i64(x-0.5)); } // TODO: Get accurate versions floor_f64 :: proc(x: f64) -> f64 { return x >= 0 ? f64(i64(x)) : f64(i64(x-0.5)); } // TODO: Get accurate versions -floor :: proc[floor_f32, floor_f64]; +floor :: proc{floor_f32, floor_f64}; ceil_f32 :: proc(x: f32) -> f32 { return x < 0 ? f32(i64(x)) : f32(i64(x+1)); }// TODO: Get accurate versions ceil_f64 :: proc(x: f64) -> f64 { return x < 0 ? f64(i64(x)) : f64(i64(x+1)); }// TODO: Get accurate versions -ceil :: proc[ceil_f32, ceil_f64]; +ceil :: proc{ceil_f32, ceil_f64}; remainder_f32 :: proc(x, y: f32) -> f32 { return x - round(x/y) * y; } remainder_f64 :: proc(x, y: f64) -> f64 { return x - round(x/y) * y; } -remainder :: proc[remainder_f32, remainder_f64]; +remainder :: proc{remainder_f32, remainder_f64}; mod_f32 :: proc(x, y: f32) -> f32 { result: f32; @@ -138,7 +138,7 @@ mod_f64 :: proc(x, y: f64) -> f64 { } return copy_sign(result, x); } -mod :: proc[mod_f32, mod_f64]; +mod :: proc{mod_f32, mod_f64}; @@ -148,19 +148,17 @@ to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU; } -mul :: proc[ +mul :: proc{ mat3_mul, mat4_mul, mat4_mul_vec4, quat_mul, quat_mulf, -]; +}; -div :: proc[ - quat_div, quat_divf, -]; +div :: proc{quat_div, quat_divf}; -inverse :: proc[mat4_inverse, quat_inverse]; -dot :: proc[vec_dot, quat_dot]; -cross :: proc[cross2, cross3]; +inverse :: proc{mat4_inverse, quat_inverse}; +dot :: proc{vec_dot, quat_dot}; +cross :: proc{cross2, cross3}; vec_dot :: proc(a, b: $T/[$N]$E) -> E { res: E; @@ -361,7 +359,7 @@ scale_f32 :: proc(m: Mat4, s: f32) -> Mat4 { return m; } -scale :: proc[scale_vec3, scale_f32]; +scale :: proc{scale_vec3, scale_f32}; look_at :: proc(eye, centre, up: Vec3) -> Mat4 { diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index 589afb17b..9b7df9e1a 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -74,13 +74,13 @@ delete_map :: proc(m: $T/map[$K]$V, loc := #caller_location) { } -delete :: proc[ +delete :: proc{ delete_string, delete_cstring, delete_dynamic_array, delete_slice, delete_map, -]; +}; new :: inline proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> ^T { @@ -122,13 +122,13 @@ make_map :: proc($T: typeid/map[$K]$E, auto_cast cap: int = 16, allocator := con return m; } -make :: proc[ +make :: proc{ make_slice, make_dynamic_array, make_dynamic_array_len, make_dynamic_array_len_cap, make_map, -]; +}; diff --git a/core/mem/mem.odin b/core/mem/mem.odin index 271d30531..f06428cea 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -5,7 +5,7 @@ foreign _ { @(link_name = "llvm.bswap.i32") swap32 :: proc(b: u32) -> u32 ---; @(link_name = "llvm.bswap.i64") swap64 :: proc(b: u64) -> u64 ---; } -swap :: proc[swap16, swap32, swap64]; +swap :: proc{swap16, swap32, swap64}; diff --git a/core/mem/raw.odin b/core/mem/raw.odin index 0fb45d6a0..5f22f4b3c 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -46,6 +46,6 @@ raw_dynamic_array_data :: inline proc(a: $T/[dynamic]$E) -> ^E { return cast(^E)(^Raw_Dynamic_Array)(&a).data; } -raw_data :: proc[raw_string_data, raw_slice_data, raw_dynamic_array_data]; +raw_data :: proc{raw_string_data, raw_slice_data, raw_dynamic_array_data}; diff --git a/core/runtime/core.odin b/core/runtime/core.odin index 679fee1b0..47ec903fc 100644 --- a/core/runtime/core.odin +++ b/core/runtime/core.odin @@ -401,44 +401,44 @@ ordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_locati @(builtin) -clear :: proc[clear_dynamic_array, clear_map]; +clear :: proc{clear_dynamic_array, clear_map}; @(builtin) -reserve :: proc[reserve_dynamic_array, reserve_map]; +reserve :: proc{reserve_dynamic_array, reserve_map}; @(builtin) -resize :: proc[resize_dynamic_array]; +resize :: proc{resize_dynamic_array}; @(builtin) -new :: proc[mem.new]; +new :: proc{mem.new}; @(builtin) -new_clone :: proc[mem.new_clone]; +new_clone :: proc{mem.new_clone}; @(builtin) -free :: proc[mem.free]; +free :: proc{mem.free}; @(builtin) -free_all :: proc[mem.free_all]; +free_all :: proc{mem.free_all}; @(builtin) -delete :: proc[ +delete :: proc{ mem.delete_string, mem.delete_cstring, mem.delete_dynamic_array, mem.delete_slice, mem.delete_map, -]; +}; @(builtin) -make :: proc[ +make :: proc{ mem.make_slice, mem.make_dynamic_array, mem.make_dynamic_array_len, mem.make_dynamic_array_len_cap, mem.make_map, -]; +}; @@ -508,7 +508,7 @@ append_elems :: proc(array: ^$T/[dynamic]$E, args: ..E, loc := #caller_location) } return len(array); } -@(builtin) append :: proc[append_elem, append_elems]; +@(builtin) append :: proc{append_elem, append_elems}; @@ -616,8 +616,8 @@ excl_bit_set :: inline proc(s: ^$S/bit_set[$E; $U], other: S) -> S { return s^; } -@(builtin) incl :: proc[incl_elem, incl_elems, incl_bit_set]; -@(builtin) excl :: proc[excl_elem, excl_elems, excl_bit_set]; +@(builtin) incl :: proc{incl_elem, incl_elems, incl_bit_set}; +@(builtin) excl :: proc{excl_elem, excl_elems, excl_bit_set}; diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin index b1aa4e12d..9fc6db2a8 100644 --- a/examples/demo/demo.odin +++ b/examples/demo/demo.odin @@ -56,7 +56,7 @@ general_stuff :: proc() { /* * Remove *_val_of built-in procedures * size_of, align_of, offset_of - * type_of, type_info_of + * type_of, type_info_of, typeid_of */ { // `expand_to_tuple` built-in procedure @@ -108,6 +108,9 @@ general_stuff :: proc() { My_Struct :: struct{x: int}; #assert(My_Struct != struct{x: int}); + + My_Struct2 :: My_Struct; + #assert(My_Struct2 == My_Struct); } { @@ -213,6 +216,7 @@ union_type :: proc() { case Monster: if e.is_robot do fmt.println("Robotic"); if e.is_zombie do fmt.println("Grrrr!"); + fmt.println("I'm a monster"); } } @@ -371,7 +375,6 @@ parametric_polymorphism :: proc() { return make(T, len); } - // Only allow types that are specializations of `Table` allocate :: proc(table: ^$T/Table, capacity: int) { c := context; @@ -509,7 +512,7 @@ parametric_polymorphism :: proc() { fmt.printf("Generating an array of type %v from the value %v of type %v\n", typeid_of(type_of(res)), N, typeid_of(I)); for i in 0..N-1 { - res[i] = i*i; + res[i] = T(i*i); } return; } @@ -666,11 +669,6 @@ using_enum :: proc() { f2 := C; fmt.println(f0, f1, f2); fmt.println(len(Foo)); - - // Non-comparsion operations are not allowed with enum - // You must convert to an integer if you want to do this - // x := f0 + f1; - y := int(f0) + int(f1); } explicit_procedure_overloading :: proc() { @@ -692,7 +690,7 @@ explicit_procedure_overloading :: proc() { return x; } - add :: proc[add_ints, add_floats, add_numbers]; + add :: proc{add_ints, add_floats, add_numbers}; add(int(1), int(2)); add(f32(1), f32(2)); @@ -738,7 +736,6 @@ complete_switch :: proc() { } } - cstring_example :: proc() { W :: "Hellope"; X :: cstring(W); @@ -801,7 +798,7 @@ bit_set_type :: proc() { } { x: bit_set['A'..'Z']; - assert(size_of(x) == size_of(u32)); + #assert(size_of(x) == size_of(u32)); y: bit_set[0..8; u16]; fmt.println(typeid_of(type_of(x))); // bit_set[A..Z] fmt.println(typeid_of(type_of(y))); // bit_set[0..8; u16] @@ -820,7 +817,6 @@ bit_set_type :: proc() { b := Letters{'A', 'B', 'C', 'D', 'F'}; c := Letters{'A', 'B'}; - assert(a <= b); // 'a' is a subset of 'b' assert(b >= a); // 'b' is a superset of 'a' assert(a < b); // 'a' is a strict subset of 'b' diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 5f23615d0..86ff4f0cd 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -6543,12 +6543,12 @@ gbString write_expr_to_string(gbString str, Ast *node) { case_end; case_ast_node(pg, ProcGroup, node); - str = gb_string_appendc(str, "proc["); + str = gb_string_appendc(str, "proc{"); for_array(i, pg->args) { if (i > 0) str = gb_string_appendc(str, ", "); str = write_expr_to_string(str, pg->args[i]); } - str = gb_string_append_rune(str, ']'); + str = gb_string_append_rune(str, '}'); case_end; case_ast_node(pl, ProcLit, node); diff --git a/src/parser.cpp b/src/parser.cpp index e64c42ed5..bce0260cb 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -1742,8 +1742,31 @@ Ast *parse_operand(AstFile *f, bool lhs) { case Token_proc: { Token token = expect_token(f, Token_proc); - if (f->curr_token.kind == Token_OpenBracket) { // ProcGroup + if (f->curr_token.kind == Token_OpenBrace) { // ProcGroup + Token open = expect_token(f, Token_OpenBrace); + + auto args = array_make(heap_allocator()); + + while (f->curr_token.kind != Token_CloseBrace && + f->curr_token.kind != Token_EOF) { + Ast *elem = parse_expr(f, false); + array_add(&args, elem); + + if (!allow_token(f, Token_Comma)) { + break; + } + } + + Token close = expect_token(f, Token_CloseBrace); + + if (args.count == 0) { + syntax_error(token, "Expected a least 1 argument in a procedure group"); + } + + return ast_proc_group(f, token, open, close, args); + } else if (f->curr_token.kind == Token_OpenBracket) { // ProcGroup Token open = expect_token(f, Token_OpenBracket); + warning(open, "Procedure groups using [] are now deprecated, please use {} instead"); auto args = array_make(heap_allocator());