From c1e720a49b3dedf5ad8f0b4b2b444bf3f160834f Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Sun, 1 Oct 2017 17:09:57 +0100 Subject: [PATCH] `match` to `switch`; Optional semicolons after "import" statements --- core/_preload.odin | 28 ++-- core/_soft_numbers.odin | 2 +- core/atomics.odin | 2 +- core/decimal.odin | 2 +- core/fmt.odin | 66 +++++----- core/hash.odin | 8 +- core/mem.odin | 8 +- core/opengl.odin | 12 +- core/os_linux.odin | 6 +- core/os_windows.odin | 12 +- core/os_x.odin | 6 +- core/sort.odin | 6 +- core/strconv.odin | 30 ++--- core/strings.odin | 2 +- core/sync_linux.odin | 4 +- core/sync_windows.odin | 6 +- core/sys/wgl.odin | 6 +- core/sys/windows.odin | 10 +- core/thread.odin | 2 +- core/types.odin | 2 +- core/utf16.odin | 2 +- core/utf8.odin | 2 +- examples/demo.odin | 8 +- src/check_decl.cpp | 9 +- src/check_expr.cpp | 199 ++++++++++++++++++++-------- src/check_stmt.cpp | 78 ++++++----- src/checker.cpp | 122 +++++++---------- src/common.cpp | 18 ++- src/exact_value.cpp | 42 ++++-- src/ir.cpp | 283 +++++++++++++++++++++++++--------------- src/parser.cpp | 97 ++++++++------ src/ssa.cpp | 10 +- src/tokenizer.cpp | 2 +- 33 files changed, 641 insertions(+), 451 deletions(-) diff --git a/core/_preload.odin b/core/_preload.odin index 3a921e750..43eb598d2 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -1,9 +1,9 @@ -#shared_global_scope; +#shared_global_scope -import "core:os.odin"; -import "core:fmt.odin"; // TODO(bill): Remove the need for `fmt` here -import "core:utf8.odin"; -import "core:raw.odin"; +import "core:os.odin" +import "core:fmt.odin" // TODO(bill): Remove the need for `fmt` here +import "core:utf8.odin" +import "core:raw.odin" // Naming Conventions: // In general, Ada_Case for types and snake_case for values @@ -43,7 +43,6 @@ Type_Info_Enum_Value :: union { f32, f64, }; - // Variant Types Type_Info_Named :: struct #ordered {name: string, base: ^Type_Info}; Type_Info_Integer :: struct #ordered {signed: bool}; @@ -106,7 +105,6 @@ Type_Info_Bit_Field :: struct #ordered { Type_Info :: struct #ordered { -// Fields size: int, align: int, @@ -217,7 +215,7 @@ type_info_base :: proc(info: ^Type_Info) -> ^Type_Info { if info == nil do return nil; base := info; - match i in base.variant { + switch i in base.variant { case Type_Info_Named: base = i.base; } return base; @@ -228,7 +226,7 @@ type_info_base_without_enum :: proc(info: ^Type_Info) -> ^Type_Info { if info == nil do return nil; base := info; - match i in base.variant { + switch i in base.variant { case Type_Info_Named: base = i.base; case Type_Info_Enum: base = i.base; } @@ -444,9 +442,9 @@ __get_map_header :: proc(m: ^$T/map[$K]$V) -> __Map_Header #cc_contextless { __get_map_key :: proc(key: $K) -> __Map_Key #cc_contextless { map_key: __Map_Key; ti := type_info_base_without_enum(type_info_of(K)); - match _ in ti.variant { + switch _ in ti.variant { case Type_Info_Integer: - match 8*size_of(key) { + switch 8*size_of(key) { case 8: map_key.hash = u128(( ^u8)(&key)^); case 16: map_key.hash = u128(( ^u16)(&key)^); case 32: map_key.hash = u128(( ^u32)(&key)^); @@ -459,7 +457,7 @@ __get_map_key :: proc(key: $K) -> __Map_Key #cc_contextless { case Type_Info_Pointer: map_key.hash = u128(uint((^rawptr)(&key)^)); case Type_Info_Float: - match 8*size_of(key) { + switch 8*size_of(key) { case 32: map_key.hash = u128((^u32)(&key)^); case 64: map_key.hash = u128((^u64)(&key)^); case: panic("Unhandled float size"); @@ -575,7 +573,7 @@ default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, old_memory: rawptr, old_size: int, flags: u64) -> rawptr { using Allocator_Mode; - match mode { + switch mode { case Alloc: return os.heap_alloc(size); @@ -626,7 +624,7 @@ panic :: proc(message := "", using location := #caller_location) #cc_contextless __string_eq :: proc(a, b: string) -> bool #cc_contextless { - match { + switch { case len(a) != len(b): return false; case len(a) == 0: return true; case &a[0] == &b[0]: return true; @@ -731,7 +729,7 @@ __mem_copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #cc_con __mem_compare :: proc(a, b: ^u8, n: int) -> int #cc_contextless { for i in 0..n { - match { + switch { case (a+i)^ < (b+i)^: return -1; case (a+i)^ > (b+i)^: return +1; } diff --git a/core/_soft_numbers.odin b/core/_soft_numbers.odin index 023c6a6de..6daabf74e 100644 --- a/core/_soft_numbers.odin +++ b/core/_soft_numbers.odin @@ -1,4 +1,4 @@ -#shared_global_scope; +#shared_global_scope __multi3 :: proc(a, b: u128) -> u128 #cc_c #link_name "__multi3" { bits_in_dword_2 :: size_of(i64) * 4; diff --git a/core/atomics.odin b/core/atomics.odin index 6f1f395fa..5118e6447 100644 --- a/core/atomics.odin +++ b/core/atomics.odin @@ -2,7 +2,7 @@ // Inline vs external file? when ODIN_OS == "windows" { - import win32 "core:sys/windows.odin"; + import win32 "core:sys/windows.odin" } _ :: compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version diff --git a/core/decimal.odin b/core/decimal.odin index 0a00ae5aa..480655385 100644 --- a/core/decimal.odin +++ b/core/decimal.odin @@ -171,7 +171,7 @@ shift :: proc(a: ^Decimal, k: int) { uint_size :: 8*size_of(uint); max_shift :: uint_size-4; - match { + switch { case a.count == 0: // no need to update case k > 0: diff --git a/core/fmt.odin b/core/fmt.odin index fc6249afd..d99aa2031 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -1,9 +1,9 @@ -import "core:os.odin"; -import "core:mem.odin"; -import "core:utf8.odin"; -import "core:types.odin"; -import "core:strconv.odin"; -import "core:raw.odin"; +import "core:os.odin" +import "core:mem.odin" +import "core:utf8.odin" +import "core:types.odin" +import "core:strconv.odin" +import "core:raw.odin" _BUFFER_SIZE :: 1<<12; @@ -36,14 +36,14 @@ Fmt_Info :: struct { string_buffer_data :: proc(buf: ^String_Buffer) -> []u8 { - match b in buf { + switch b in buf { case []u8: return b[..]; case [dynamic]u8: return b[..]; } return nil; } string_buffer_data :: proc(buf: String_Buffer) -> []u8 { - match b in buf { + switch b in buf { case []u8: return b[..]; case [dynamic]u8: return b[..]; } @@ -58,13 +58,13 @@ write_string :: proc(buf: ^String_Buffer, s: string) { write_bytes(buf, cast([]u8)s); } write_bytes :: proc(buf: ^String_Buffer, data: []u8) { - match b in buf { + switch b in buf { case []u8: append(b, ...data); case [dynamic]u8: append(b, ...data); } } write_byte :: proc(buf: ^String_Buffer, data: u8) { - match b in buf { + switch b in buf { case []u8: append(b, data); case [dynamic]u8: append(b, data); } @@ -179,11 +179,11 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) { return; } - match info in ti.variant { + switch info in ti.variant { case Type_Info_Named: write_string(buf, info.name); case Type_Info_Integer: - match { + switch { case ti == type_info_of(int): write_string(buf, "int"); case ti == type_info_of(uint): write_string(buf, "uint"); case: @@ -194,13 +194,13 @@ write_type :: proc(buf: ^String_Buffer, ti: ^Type_Info) { case Type_Info_Rune: write_string(buf, "rune"); case Type_Info_Float: - match ti.size { + switch ti.size { case 2: write_string(buf, "f16"); case 4: write_string(buf, "f32"); case 8: write_string(buf, "f64"); } case Type_Info_Complex: - match ti.size { + switch ti.size { case 4: write_string(buf, "complex32"); case 8: write_string(buf, "complex64"); case 16: write_string(buf, "complex128"); @@ -388,7 +388,7 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) { if arg_index < len(args) { arg := args[arg_index]; arg.type_info = type_info_base(arg.type_info); - match i in arg { + switch i in arg { case int: num = i; case i8: num = int(i); case i16: num = int(i); @@ -423,7 +423,7 @@ fmt_bad_verb :: proc(using fi: ^Fmt_Info, verb: rune) { } fmt_bool :: proc(using fi: ^Fmt_Info, b: bool, verb: rune) { - match verb { + switch verb { case 't', 'v': s := "false"; if b do s = "true"; @@ -475,7 +475,7 @@ _fmt_int :: proc(fi: ^Fmt_Info, u: u128, base: int, is_signed: bool, bit_size: i } } - match base { + switch base { case 2, 8, 10, 12, 16: break; case: @@ -493,7 +493,7 @@ _fmt_int :: proc(fi: ^Fmt_Info, u: u128, base: int, is_signed: bool, bit_size: i if fi.hash && fi.zero { c: u8; - match base { + switch base { case 2: c = 'b'; case 8: c = 'o'; case 10: c = 'd'; @@ -517,7 +517,7 @@ __DIGITS_LOWER := "0123456789abcdefx"; __DIGITS_UPPER := "0123456789ABCDEFX"; fmt_rune :: proc(fi: ^Fmt_Info, r: rune, verb: rune) { - match verb { + switch verb { case 'c', 'r', 'v': write_rune(fi.buf, r); case: @@ -526,7 +526,7 @@ fmt_rune :: proc(fi: ^Fmt_Info, r: rune, verb: rune) { } fmt_int :: proc(fi: ^Fmt_Info, u: u128, is_signed: bool, bit_size: int, verb: rune) { - match verb { + switch verb { case 'v': _fmt_int(fi, u, 10, is_signed, bit_size, __DIGITS_LOWER); case 'b': _fmt_int(fi, u, 2, is_signed, bit_size, __DIGITS_LOWER); case 'o': _fmt_int(fi, u, 8, is_signed, bit_size, __DIGITS_LOWER); @@ -568,7 +568,7 @@ _pad :: proc(fi: ^Fmt_Info, s: string) { } fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) { - match verb { + switch verb { // case 'e', 'E', 'f', 'F', 'g', 'G', 'v': // case 'f', 'F', 'v': @@ -611,7 +611,7 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) { } } fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) { - match verb { + switch verb { case 's', 'v': write_string(fi.buf, s); @@ -633,7 +633,7 @@ fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) { } fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) { - match verb { + switch verb { case 'p', 'v': // Okay case: @@ -650,7 +650,7 @@ fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) { enum_value_to_string :: proc(v: any) -> (string, bool) { v.type_info = type_info_base(v.type_info); - match e in v.type_info.variant { + switch e in v.type_info.variant { case: return "", false; case Type_Info_Enum: get_str :: proc(i: $T, e: Type_Info_Enum) -> (string, bool) { @@ -673,7 +673,7 @@ enum_value_to_string :: proc(v: any) -> (string, bool) { } a := any{v.data, type_info_base(e.base)}; - match v in a { + switch v in a { case rune: return get_str(v, e); case i8: return get_str(v, e); case i16: return get_str(v, e); @@ -716,10 +716,10 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - match e in v.type_info.variant { + switch e in v.type_info.variant { case: fmt_bad_verb(fi, verb); case Type_Info_Enum: - match verb { + switch verb { case: fmt_bad_verb(fi, verb); case 'd', 'f': fmt_arg(fi, any{v.data, type_info_base(e.base)}, verb); @@ -738,9 +738,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - match info in v.type_info.variant { + switch info in v.type_info.variant { case Type_Info_Named: - match b in info.base.variant { + switch b in info.base.variant { case Type_Info_Struct: if verb != 'v' { fmt_bad_verb(fi, verb); @@ -939,7 +939,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { } fmt_complex :: proc(fi: ^Fmt_Info, c: complex128, bits: int, verb: rune) { - match verb { + switch verb { case 'f', 'F', 'v': r, i := real(c), imag(c); fmt_float(fi, r, bits/2, verb); @@ -972,7 +972,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) { if verb == 'T' { ti := arg.type_info; - match a in arg { + switch a in arg { case ^Type_Info: ti = a; } write_type(fi.buf, ti); @@ -982,7 +982,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) { base_arg := arg; base_arg.type_info = type_info_base(base_arg.type_info); - match a in base_arg { + switch a in base_arg { case any: fmt_arg(fi, a, verb); case bool: fmt_bool(fi, a, verb); case rune: fmt_rune(fi, a, verb); @@ -1073,7 +1073,7 @@ sbprintf :: proc(b: ^String_Buffer, fmt: string, args: ...any) -> string { i += 1; prefix_loop: for ; i < end; i += 1 { - match fmt[i] { + switch fmt[i] { case '+': fi.plus = true; case '-': diff --git a/core/hash.odin b/core/hash.odin index d523a04e1..37cb25ed5 100644 --- a/core/hash.odin +++ b/core/hash.odin @@ -1,4 +1,4 @@ -import "core:mem.odin"; +import "core:mem.odin" adler32 :: proc(data: []u8) -> u32 { ADLER_CONST :: 65521; @@ -80,7 +80,7 @@ murmur32 :: proc(data: []u8) -> u32 { tail := data[nblocks*4 ..]; k1: u32; - match len(tail)&3 { + switch len(tail)&3 { case 3: k1 ~= u32(tail[2]) << 16; fallthrough; @@ -127,7 +127,7 @@ murmur64 :: proc(data: []u8) -> u64 { h *= m; } - match len(data)&7 { + switch len(data)&7 { case 7: h ~= u64(data[6]) << 48; fallthrough; case 6: h ~= u64(data[5]) << 40; fallthrough; case 5: h ~= u64(data[4]) << 32; fallthrough; @@ -186,7 +186,7 @@ murmur64 :: proc(data: []u8) -> u64 { // TODO(bill): Fix this #no_bounds_check data8 := slice_to_bytes(data32[i..])[..3]; - match len { + switch len { case 3: h2 ~= u32(data8[2]) << 16; fallthrough; diff --git a/core/mem.odin b/core/mem.odin index b2e05131c..2be976b2a 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -1,4 +1,4 @@ -import "core:raw.odin"; +import "core:raw.odin" foreign __llvm_core { swap :: proc(b: u16) -> u16 #link_name "llvm.bswap.i16" ---; @@ -137,7 +137,7 @@ arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, using Allocator_Mode; arena := cast(^Arena)allocator_data; - match mode { + switch mode { case Alloc: total_size := size + alignment; @@ -200,7 +200,7 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int { WORD_SIZE :: size_of(int); MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants? - match info in type_info.variant { + switch info in type_info.variant { case Type_Info_Named: return align_of_type_info(info.base); case Type_Info_Integer: @@ -252,7 +252,7 @@ align_formula :: proc(size, align: int) -> int { size_of_type_info :: proc(type_info: ^Type_Info) -> int { WORD_SIZE :: size_of(int); - match info in type_info.variant { + switch info in type_info.variant { case Type_Info_Named: return size_of_type_info(info.base); case Type_Info_Integer: diff --git a/core/opengl.odin b/core/opengl.odin index 60a8bc1a4..96f5a977f 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -1,12 +1,12 @@ -when ODIN_OS == "windows" do foreign_system_library lib "opengl32.lib"; -when ODIN_OS == "linux" do foreign_system_library lib "gl"; - when ODIN_OS == "windows" { - import win32 "core:sys/windows.odin"; - import "core:sys/wgl.odin"; + foreign_system_library lib "opengl32.lib" + import win32 "core:sys/windows.odin" + import "core:sys/wgl.odin" +} else when ODIN_OS == "linux" { + foreign_system_library lib "gl" } -export "core:opengl_constants.odin"; +export "core:opengl_constants.odin" _ := compile_assert(ODIN_OS != "osx"); diff --git a/core/os_linux.odin b/core/os_linux.odin index 3a4a8d6cf..954c41f27 100644 --- a/core/os_linux.odin +++ b/core/os_linux.odin @@ -1,7 +1,7 @@ -foreign_system_library dl "dl"; -foreign_system_library libc "c"; +foreign_system_library dl "dl" +foreign_system_library libc "c" -import "core:strings.odin"; +import "core:strings.odin" Handle :: i32; File_Time :: u64; diff --git a/core/os_windows.odin b/core/os_windows.odin index cfe0e10d2..e8b22a0e4 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -1,5 +1,5 @@ -import win32 "core:sys/windows.odin"; -import "core:mem.odin"; +import win32 "core:sys/windows.odin" +import "core:mem.odin" Handle :: int; File_Time :: u64; @@ -60,7 +60,7 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errn if len(path) == 0 do return INVALID_HANDLE, ERROR_FILE_NOT_FOUND; access: u32; - match mode & (O_RDONLY|O_WRONLY|O_RDWR) { + switch mode & (O_RDONLY|O_WRONLY|O_RDWR) { case O_RDONLY: access = win32.FILE_GENERIC_READ; case O_WRONLY: access = win32.FILE_GENERIC_WRITE; case O_RDWR: access = win32.FILE_GENERIC_READ | win32.FILE_GENERIC_WRITE; @@ -82,7 +82,7 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errn } create_mode: u32; - match { + switch { case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL): create_mode = win32.CREATE_NEW; case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC): @@ -156,7 +156,7 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) { seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { w: u32; - match whence { + switch whence { case 0: w = win32.FILE_BEGIN; case 1: w = win32.FILE_CURRENT; case 2: w = win32.FILE_END; @@ -272,7 +272,7 @@ _alloc_command_line_arguments :: proc() -> []string { i, j := 0, 0; for str[j] != 0 { - match { + switch { case str[j] < 0x80: if i+1 > len do return ""; buf[i] = u8(str[j]); i += 1; diff --git a/core/os_x.odin b/core/os_x.odin index 1f41bd884..1dfadb589 100644 --- a/core/os_x.odin +++ b/core/os_x.odin @@ -1,7 +1,7 @@ -foreign_system_library dl "dl"; -foreign_system_library libc "c"; +foreign_system_library dl "dl" +foreign_system_library libc "c" -import "core:strings.odin"; +import "core:strings.odin" Handle :: i32; File_Time :: u64; diff --git a/core/sort.odin b/core/sort.odin index 91514d3e3..d58d0cf99 100644 --- a/core/sort.odin +++ b/core/sort.odin @@ -187,7 +187,7 @@ merge_sort :: proc(array: $A/[]$T) { compare_ints :: proc(a, b: int) -> int { - match delta := a - b; { + switch delta := a - b; { case delta < 0: return -1; case delta > 0: return +1; } @@ -195,14 +195,14 @@ compare_ints :: proc(a, b: int) -> int { } compare_f32s :: proc(a, b: f32) -> int { - match delta := a - b; { + switch delta := a - b; { case delta < 0: return -1; case delta > 0: return +1; } return 0; } compare_f64s :: proc(a, b: f64) -> int { - match delta := a - b; { + switch delta := a - b; { case delta < 0: return -1; case delta > 0: return +1; } diff --git a/core/strconv.odin b/core/strconv.odin index b75e1fe2b..c48ce5d72 100644 --- a/core/strconv.odin +++ b/core/strconv.odin @@ -1,4 +1,4 @@ -using import "core:decimal.odin"; +using import "core:decimal.odin" Int_Flag :: enum { Prefix = 1<<0, @@ -8,7 +8,7 @@ Int_Flag :: enum { parse_bool :: proc(s: string) -> (result: bool = false, ok: bool) { - match s { + switch s { case "1", "t", "T", "true", "TRUE", "True": return true, true; case "0", "f", "F", "false", "FALSE", "False": @@ -20,7 +20,7 @@ parse_bool :: proc(s: string) -> (result: bool = false, ok: bool) { _digit_value :: proc(r: rune) -> int { ri := int(r); v: int = 16; - match r { + switch r { case '0'...'9': v = ri-'0'; case 'a'...'z': v = ri-'a'+10; case 'A'...'Z': v = ri-'A'+10; @@ -31,7 +31,7 @@ _digit_value :: proc(r: rune) -> int { parse_i128 :: proc(s: string) -> i128 { neg := false; if len(s) > 1 { - match s[0] { + switch s[0] { case '-': neg = true; s = s[1..]; @@ -43,7 +43,7 @@ parse_i128 :: proc(s: string) -> i128 { base: i128 = 10; if len(s) > 2 && s[0] == '0' { - match s[1] { + switch s[1] { case 'b': base = 2; s = s[2..]; case 'o': base = 8; s = s[2..]; case 'd': base = 10; s = s[2..]; @@ -80,7 +80,7 @@ parse_u128 :: proc(s: string) -> u128 { base := u128(10); if len(s) > 2 && s[0] == '0' { - match s[1] { + switch s[1] { case 'b': base = 2; s = s[2..]; case 'o': base = 8; s = s[2..]; case 'd': base = 10; s = s[2..]; @@ -115,7 +115,7 @@ parse_f64 :: proc(s: string) -> f64 { i := 0; sign: f64 = 1; - match s[i] { + switch s[i] { case '-': i += 1; sign = -1; case '+': i += 1; } @@ -153,7 +153,7 @@ parse_f64 :: proc(s: string) -> f64 { i += 1; if i < len(s) { - match s[i] { + switch s[i] { case '-': i += 1; frac = true; case '+': i += 1; } @@ -223,7 +223,7 @@ _f64_info := FloatInfo{52, 11, -1023}; generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 { bits: u64; flt: ^FloatInfo; - match bit_size { + switch bit_size { case 32: bits = u64(transmute(u32)f32(val)); flt = &_f32_info; @@ -238,7 +238,7 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 exp := int(bits>>flt.mantbits) & (1< []u8 if shortest { round_shortest(d, mant, exp, flt); digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point}; - match fmt { + switch 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 { + switch fmt { case 'e', 'E': round(d, prec+1); case 'f', 'F': round(d, d.decimal_point+prec); case 'g', 'G': @@ -293,7 +293,7 @@ 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 { - match fmt { + switch fmt { case 'f', 'F': append(&buf, neg ? '-' : '+'); @@ -410,7 +410,7 @@ digits := "0123456789abcdefghijklmnopqrstuvwxyz"; is_integer_negative :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) { neg := false; if is_signed { - match bit_size { + switch bit_size { case 8: i := i8(u); neg = i < 0; @@ -456,7 +456,7 @@ append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: in if flags&Int_Flag.Prefix != 0 { ok := true; - match base { + switch base { case 2: i-=1; a[i] = 'b'; case 8: i-=1; a[i] = 'o'; case 10: i-=1; a[i] = 'd'; diff --git a/core/strings.odin b/core/strings.odin index f2588da78..e51fcb345 100644 --- a/core/strings.odin +++ b/core/strings.odin @@ -1,4 +1,4 @@ -import "core:mem.odin"; +import "core:mem.odin" new_string :: proc(s: string) -> string { c := make([]u8, len(s)+1); diff --git a/core/sync_linux.odin b/core/sync_linux.odin index 0df140efe..74f5cdc21 100644 --- a/core/sync_linux.odin +++ b/core/sync_linux.odin @@ -1,5 +1,5 @@ -import "core:atomics.odin"; -import "core:os.odin"; +import "core:atomics.odin" +import "core:os.odin" Semaphore :: struct { // _handle: win32.Handle, diff --git a/core/sync_windows.odin b/core/sync_windows.odin index a6a88e246..22d441b66 100644 --- a/core/sync_windows.odin +++ b/core/sync_windows.odin @@ -1,5 +1,7 @@ -when ODIN_OS == "windows" do import win32 "core:sys/windows.odin"; -import "core:atomics.odin"; +when ODIN_OS == "windows" { + import win32 "core:sys/windows.odin"; +} +import "core:atomics.odin" Semaphore :: struct { _handle: win32.Handle, diff --git a/core/sys/wgl.odin b/core/sys/wgl.odin index 2191018d5..1f2699458 100644 --- a/core/sys/wgl.odin +++ b/core/sys/wgl.odin @@ -1,5 +1,7 @@ -when ODIN_OS == "windows" do foreign_system_library "opengl32.lib"; -using import "core:sys/windows.odin"; +when ODIN_OS == "windows" { + foreign_system_library "opengl32.lib" +} +using import "core:sys/windows.odin" CONTEXT_MAJOR_VERSION_ARB :: 0x2091; diff --git a/core/sys/windows.odin b/core/sys/windows.odin index cfab08229..59bf6141f 100644 --- a/core/sys/windows.odin +++ b/core/sys/windows.odin @@ -1,9 +1,9 @@ when ODIN_OS == "windows" { - foreign_system_library "kernel32.lib"; - foreign_system_library "user32.lib"; - foreign_system_library "gdi32.lib"; - foreign_system_library "winmm.lib"; - foreign_system_library "shell32.lib"; + foreign_system_library "kernel32.lib" + foreign_system_library "user32.lib" + foreign_system_library "gdi32.lib" + foreign_system_library "winmm.lib" + foreign_system_library "shell32.lib" } Handle :: rawptr; diff --git a/core/thread.odin b/core/thread.odin index 51d4b2da4..6a8058d53 100644 --- a/core/thread.odin +++ b/core/thread.odin @@ -1,7 +1,7 @@ _ :: compile_assert(ODIN_OS == "windows"); when ODIN_OS == "windows" { - import win32 "core:sys/windows.odin"; + import win32 "core:sys/windows.odin" } Thread_Proc :: #type proc(^Thread) -> int; diff --git a/core/types.odin b/core/types.odin index 796b0c13b..f8db67463 100644 --- a/core/types.odin +++ b/core/types.odin @@ -1,6 +1,6 @@ is_signed :: proc(info: ^Type_Info) -> bool { if info == nil do return false; - match i in type_info_base(info).variant { + switch i in type_info_base(info).variant { case Type_Info_Integer: return i.signed; case Type_Info_Float: return true; } diff --git a/core/utf16.odin b/core/utf16.odin index def44c8e8..b8caededd 100644 --- a/core/utf16.odin +++ b/core/utf16.odin @@ -35,7 +35,7 @@ encode :: proc(d: []u16, s: []rune) { n = 0; for r in s { - match r { + switch r { case 0.._surr1, _surr3.._surr_self: d[n] = u16(r); n += 1; diff --git a/core/utf8.odin b/core/utf8.odin index 71358f68d..95a340cad 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -254,7 +254,7 @@ rune_count :: proc(s: []u8) -> int { rune_size :: proc(r: rune) -> int { - match { + switch { case r < 0: return -1; case r <= 1<<7 - 1: return 1; case r <= 1<<11 - 1: return 2; diff --git a/examples/demo.odin b/examples/demo.odin index a744d7234..33bd29099 100644 --- a/examples/demo.odin +++ b/examples/demo.odin @@ -150,7 +150,7 @@ union_type :: proc() { val = nil; - match v in val { + switch v in val { case int: fmt.println("int", v); case bool: fmt.println("bool", v); case: fmt.println("nil"); @@ -171,7 +171,7 @@ union_type :: proc() { val = nil; - match v in val { + switch v in val { case int: fmt.println("int", v); case bool: fmt.println("bool", v); case: fmt.println("nil"); @@ -218,7 +218,7 @@ union_type :: proc() { entity := new_entity(Monster); - match e in entity.derived { + switch e in entity.derived { case Frog: fmt.println("Ribbit"); case Monster: @@ -262,7 +262,7 @@ union_type :: proc() { entity := new_entity(Monster); - match e in entity.derived { + switch e in entity.derived { case Frog: fmt.println("Ribbit"); case Monster: diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 2ef825083..401722148 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -234,7 +234,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, d->type_expr = d->init_expr; check_type_decl(c, e, d->type_expr, named_type); return; - } break; + } // NOTE(bill): Check to see if the expression it to be aliases #if 1 @@ -446,6 +446,13 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { error(e->token, "Procedure `main` cannot have a custom calling convention"); } pt->calling_convention = ProcCC_Contextless; + if (d->scope->is_init) { + if (c->info.entry_point != nullptr) { + error(e->token, "Redeclaration of the entry pointer procedure `main`"); + } else { + c->info.entry_point = e; + } + } } if (is_inline && is_no_inline) { diff --git a/src/check_expr.cpp b/src/check_expr.cpp index d559f3eeb..c5dc436b2 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -2469,7 +2469,8 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) { if (sz > 8 && build_context.word_size < 8) { new_type = make_type_pointer(a, original_type); } - } break; + break; + } case Type_Pointer: break; case Type_Proc: break; // NOTE(bill): Just a pointer @@ -2495,7 +2496,9 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) { new_type = make_type_pointer(a, original_type); break; } - } break; + + break; + } } } else if (build_context.ODIN_OS == "linux" || build_context.ODIN_OS == "osx") { @@ -2508,7 +2511,9 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) { if (sz > 8 && build_context.word_size < 8) { new_type = make_type_pointer(a, original_type); } - } break; + + break; + } case Type_Pointer: break; case Type_Proc: break; // NOTE(bill): Just a pointer @@ -2528,7 +2533,9 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) { if (8*size > 16) { new_type = make_type_pointer(a, original_type); } - } break; + + break; + } } } else { // IMPORTANT TODO(bill): figure out the ABI settings for Linux, OSX etc. for @@ -2579,7 +2586,9 @@ Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type) { case 64: new_type = t_u64; break; #endif } - } break; + + break; + } } } else if (build_context.ODIN_OS == "linux") { @@ -3031,26 +3040,29 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) switch (e->kind) { case_ast_node(i, Ident, e); + Operand o = {}; check_ident(c, &o, e, named_type, nullptr, false); + gbString err_str; switch (o.mode) { case Addressing_Invalid: break; - case Addressing_Type: { + case Addressing_Type: *type = o.type; return true; - } break; - case Addressing_NoValue: { - gbString err_str = expr_to_string(e); + + case Addressing_NoValue: + err_str = expr_to_string(e); error(e, "`%s` used as a type", err_str); gb_string_free(err_str); - } break; - default: { - gbString err_str = expr_to_string(e); + break; + + default: + err_str = expr_to_string(e); error(e, "`%s` used as a type when not a type", err_str); gb_string_free(err_str); - } break; + break; } case_end; @@ -3104,6 +3116,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) Operand o = {}; check_selector(c, &o, e, nullptr); + gbString err_str; switch (o.mode) { case Addressing_Invalid: break; @@ -3111,16 +3124,16 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type) GB_ASSERT(o.type != nullptr); *type = o.type; return true; - case Addressing_NoValue: { - gbString err_str = expr_to_string(e); + case Addressing_NoValue: + err_str = expr_to_string(e); error(e, "`%s` used as a type", err_str); gb_string_free(err_str); - } break; - default: { - gbString err_str = expr_to_string(e); + break; + default: + err_str = expr_to_string(e); error(e, "`%s` is not a type", err_str); gb_string_free(err_str); - } break; + break; } case_end; @@ -3533,7 +3546,8 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type if (out_value) *out_value = exact_binary_operator_value(Token_Add, real, exact_value_make_imag(imag)); return true; } - } break; + break; + } case Basic_UntypedComplex: return true; @@ -3724,9 +3738,9 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) { case Token_Lt: case Token_Gt: case Token_LtEq: - case Token_GtEq: { + case Token_GtEq: defined = is_type_ordered(x->type); - } break; + break; } if (!defined) { @@ -4176,7 +4190,9 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { if (xt) error_operand_not_expression(x); if (yt) error_operand_not_expression(y); } - } break; + + break; + } default: check_expr(c, x, be->left); @@ -4522,7 +4538,9 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level convert_untyped_error(c, operand, target_type); return; } - } break; + + break; + } case Type_Union: if (!is_operand_nil(*operand) && !is_operand_undef(*operand)) { @@ -5112,7 +5130,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = t_source_code_location; operand->mode = Addressing_Value; - } break; + + break; + } case BuiltinProc_len: case BuiltinProc_cap: { @@ -5159,7 +5179,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = mode; operand->value = value; operand->type = type; - } break; + + break; + } #if 0 case BuiltinProc_new: { @@ -5173,7 +5195,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } operand->mode = Addressing_Value; operand->type = make_type_pointer(c->allocator, type); - } break; + + break; + } #endif #if 0 case BuiltinProc_new_slice: { @@ -5212,7 +5236,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Value; operand->type = make_type_slice(c->allocator, type); - } break; + + break; + } #endif case BuiltinProc_make: { // proc make(Type, len: int) -> Type @@ -5268,7 +5294,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Value; operand->type = type; - } break; + + break; + } #if 0 case BuiltinProc_free: { @@ -5299,7 +5327,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_NoValue; - } break; + + break; + } #endif @@ -5329,7 +5359,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = nullptr; operand->mode = Addressing_NoValue; - } break; + + break; + } #endif #if 0 case BuiltinProc_clear: { @@ -5345,7 +5377,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = nullptr; operand->mode = Addressing_NoValue; - } break; + + break; + } #endif #if 0 case BuiltinProc_append: { @@ -5394,7 +5428,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } operand->mode = Addressing_Value; operand->type = t_int; - } break; + + break; + } #endif #if 0 case BuiltinProc_delete: { @@ -5426,7 +5462,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } operand->mode = Addressing_NoValue; - } break; + + break; + } #endif @@ -5447,7 +5485,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Constant; operand->value = exact_value_i64(type_size_of(c->allocator, t)); operand->type = t_untyped_integer; - } break; + + break; + } case BuiltinProc_align_of: { // proc align_of(Type or expr) -> untyped int @@ -5466,7 +5506,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Constant; operand->value = exact_value_i64(type_align_of(c->allocator, t)); operand->type = t_untyped_integer; - } break; + + break; + } case BuiltinProc_offset_of: { @@ -5511,7 +5553,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Constant; operand->value = exact_value_i64(type_offset_of_from_selection(c->allocator, type, sel)); operand->type = t_untyped_integer; - } break; + + break; + } case BuiltinProc_type_of: @@ -5557,7 +5601,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->mode = Addressing_Value; operand->type = t_type_info_ptr; - } break; + + break; + } case BuiltinProc_compile_assert: // proc compile_assert(cond: bool) -> bool @@ -5630,7 +5676,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Type *elem_type = vector_type->Vector.elem; operand->type = make_type_vector(c->allocator, elem_type, arg_count); operand->mode = Addressing_Value; - } break; + + break; + } case BuiltinProc_complex: { // proc complex(real, imag: float_type) -> complex_type @@ -5689,7 +5737,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case Basic_UntypedFloat: operand->type = t_untyped_complex; break; default: GB_PANIC("Invalid type"); break; } - } break; + + break; + } case BuiltinProc_real: case BuiltinProc_imag: { @@ -5733,7 +5783,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case Basic_UntypedComplex: x->type = t_untyped_float; break; default: GB_PANIC("Invalid type"); break; } - } break; + + break; + } case BuiltinProc_conj: { // proc conj(x: type) -> type @@ -5755,7 +5807,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - } break; + +break; + } #if 0 case BuiltinProc_slice_ptr: { @@ -5799,7 +5853,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } operand->type = make_type_slice(c->allocator, ptr_type->Pointer.elem); operand->mode = Addressing_Value; - } break; + + break; + } case BuiltinProc_slice_to_bytes: { // proc slice_to_bytes(a: []T) -> []u8 @@ -5813,7 +5869,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = t_u8_slice; operand->mode = Addressing_Value; - } break; + + break; + } #endif case BuiltinProc_expand_to_tuple: { Type *type = base_type(operand->type); @@ -5834,7 +5892,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = tuple; operand->mode = Addressing_Value; - } break; + + break; + } case BuiltinProc_min: { // proc min(a, b: ordered) -> ordered @@ -5900,7 +5960,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } } - } break; + +break; + } case BuiltinProc_max: { // proc min(a, b: ordered) -> ordered @@ -5968,7 +6030,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } } - } break; + +break; + } case BuiltinProc_abs: { // proc abs(n: numeric) -> numeric @@ -5991,7 +6055,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id f64 r = operand->value.value_complex.real; f64 i = operand->value.value_complex.imag; operand->value = exact_value_float(gb_sqrt(r*r + i*i)); - } break; + + break; + } default: GB_PANIC("Invalid numeric constant"); break; @@ -6004,7 +6070,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = base_complex_elem_type(operand->type); } GB_ASSERT(!is_type_complex(operand->type)); - } break; + + break; + } case BuiltinProc_clamp: { // proc clamp(a, min, max: ordered) -> ordered @@ -6092,7 +6160,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } } - } break; + + break; + } #if 0 case BuiltinProc_transmute: { @@ -6143,7 +6213,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id o->mode = Addressing_Value; o->type = t; - } break; + + break; + } #endif } @@ -7103,7 +7175,9 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { if (operand->mode != Addressing_Invalid) { check_cast(c, operand, t); } - } break; + + break; + } } } return Expr_Expr; @@ -7330,7 +7404,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t switch (r) { case 'i': t = t_untyped_complex; break; } - } break; + + break; + } default: GB_PANIC("Unknown literal"); break; } o->mode = Addressing_Constant; @@ -7663,7 +7739,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } } } - } break; + break; + } case Type_Slice: case Type_Array: @@ -7740,7 +7817,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (t->kind == Type_Array && is_to_be_determined_array_count) { t->Array.count = max; } - } break; + + break; + } case Type_Basic: { if (!is_type_any(t)) { @@ -7819,7 +7898,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } } } - } break; + + break; + } case Type_Map: { if (cl->elems.count == 0) { @@ -7844,7 +7925,9 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t check_assignment(c, o, t->Map.value, str_lit("map literal")); } } - } break; + + break; + } default: { if (cl->elems.count == 0) { @@ -7855,7 +7938,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t error(node, "Invalid compound literal type `%s`", str); gb_string_free(str); return kind; - } break; + } } if (is_constant) { diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index b4cb91025..0d8a4fb24 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -138,10 +138,10 @@ bool check_is_terminating(AstNode *node) { return false; case_end; - case_ast_node(ms, MatchStmt, node); + case_ast_node(ss, SwitchStmt, node); bool has_default = false; - for_array(i, ms->body->BlockStmt.stmts) { - AstNode *clause = ms->body->BlockStmt.stmts[i]; + for_array(i, ss->body->BlockStmt.stmts) { + AstNode *clause = ss->body->BlockStmt.stmts[i]; ast_node(cc, CaseClause, clause); if (cc->list.count == 0) { has_default = true; @@ -154,10 +154,10 @@ bool check_is_terminating(AstNode *node) { return has_default; case_end; - case_ast_node(ms, TypeMatchStmt, node); + case_ast_node(ss, TypeSwitchStmt, node); bool has_default = false; - for_array(i, ms->body->BlockStmt.stmts) { - AstNode *clause = ms->body->BlockStmt.stmts[i]; + for_array(i, ss->body->BlockStmt.stmts) { + AstNode *clause = ss->body->BlockStmt.stmts[i]; ast_node(cc, CaseClause, clause); if (cc->list.count == 0) { has_default = true; @@ -309,7 +309,9 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) { } } } - } break; + + break; + } default: { if (lhs.expr->kind == AstNode_SelectorExpr) { @@ -332,7 +334,9 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) { error(lhs.expr, "Cannot assign to `%s`", str); } gb_string_free(str); - } break; + + break; + } } check_assignment(c, rhs, assignment_type, str_lit("assignment")); @@ -490,7 +494,9 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo } else { error(us->token, "`using` can be only applied to enum type entities"); } - } break; + + break; + } case Entity_ImportName: { Scope *scope = e->ImportName.scope; @@ -511,7 +517,9 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo return false; } } - } break; + + break; + } case Entity_Variable: { Type *t = base_type(type_deref(e->type)); @@ -538,7 +546,9 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo error(us->token, "`using` can only be applied to variables of type struct or raw_union"); return false; } - } break; + + break; + } case Entity_Constant: error(us->token, "`using` cannot be applied to a constant"); @@ -583,7 +593,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { gbString str = type_to_string(operand.type); error(node, "`%s` is not an expression", str); gb_string_free(str); - } break; + + break; + } case Addressing_NoValue: return; default: { @@ -605,7 +617,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { gbString expr_str = expr_to_string(operand.expr); error(node, "Expression is not used: `%s`", expr_str); gb_string_free(expr_str); - } break; + + break; + } } case_end; @@ -695,7 +709,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { error(as->lhs[0], "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); } - } break; + + break; + } default: { // a += 1; // Single-sided @@ -723,7 +739,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } // NOTE(bill): Only use the first one will be used check_assignment_variable(c, &operand, as->lhs[0]); - } break; + + break; + } } case_end; @@ -1161,18 +1179,18 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_close_scope(c); case_end; - case_ast_node(ms, MatchStmt, node); + case_ast_node(ss, SwitchStmt, node); Operand x = {}; mod_flags |= Stmt_BreakAllowed; check_open_scope(c, node); - check_label(c, ms->label); // TODO(bill): What should the label's "scope" be? + check_label(c, ss->label); // TODO(bill): What should the label's "scope" be? - if (ms->init != nullptr) { - check_stmt(c, ms->init, 0); + if (ss->init != nullptr) { + check_stmt(c, ss->init, 0); } - if (ms->tag != nullptr) { - check_expr(c, &x, ms->tag); + if (ss->tag != nullptr) { + check_expr(c, &x, ss->tag); check_assignment(c, &x, nullptr, str_lit("match expression")); } else { x.mode = Addressing_Constant; @@ -1180,7 +1198,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { x.value = exact_value_bool(true); Token token = {}; - token.pos = ast_node_token(ms->body).pos; + token.pos = ast_node_token(ss->body).pos; token.string = str_lit("true"); x.expr = ast_ident(c->curr_ast_file, token); } @@ -1194,7 +1212,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // NOTE(bill): Check for multiple defaults AstNode *first_default = nullptr; - ast_node(bs, BlockStmt, ms->body); + ast_node(bs, BlockStmt, ss->body); for_array(i, bs->stmts) { AstNode *stmt = bs->stmts[i]; AstNode *default_stmt = nullptr; @@ -1365,22 +1383,22 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_close_scope(c); case_end; - case_ast_node(ms, TypeMatchStmt, node); + case_ast_node(ss, TypeSwitchStmt, node); Operand x = {}; mod_flags |= Stmt_BreakAllowed; check_open_scope(c, node); - check_label(c, ms->label); // TODO(bill): What should the label's "scope" be? + check_label(c, ss->label); // TODO(bill): What should the label's "scope" be? MatchTypeKind match_type_kind = MatchType_Invalid; - if (ms->tag->kind != AstNode_AssignStmt) { - error(ms->tag, "Expected an `in` assignment for this type match statement"); + if (ss->tag->kind != AstNode_AssignStmt) { + error(ss->tag, "Expected an `in` assignment for this type match statement"); break; } - ast_node(as, AssignStmt, ms->tag); - Token as_token = ast_node_token(ms->tag); + ast_node(as, AssignStmt, ss->tag); + Token as_token = ast_node_token(ss->tag); if (as->lhs.count != 1) { syntax_error(as_token, "Expected 1 name before `in`"); break; @@ -1406,7 +1424,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // NOTE(bill): Check for multiple defaults AstNode *first_default = nullptr; - ast_node(bs, BlockStmt, ms->body); + ast_node(bs, BlockStmt, ss->body); for_array(i, bs->stmts) { AstNode *stmt = bs->stmts[i]; AstNode *default_stmt = nullptr; diff --git a/src/checker.cpp b/src/checker.cpp index 30bf65418..eeac82b6e 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -448,8 +448,9 @@ struct CheckerInfo { Map type_info_map; // Key: Type * isize type_info_count; + Scope * init_scope; Entity * entry_point; - PtrSet minimum_dependency_map; + PtrSet minimum_dependency_set; }; @@ -1293,7 +1294,7 @@ void add_type_info_type(Checker *c, Type *t) { add_type_info_type(c, bt); switch (bt->kind) { - case Type_Basic: { + case Type_Basic: switch (bt->Basic.kind) { case Basic_string: add_type_info_type(c, t_u8_ptr); @@ -1313,7 +1314,7 @@ void add_type_info_type(Checker *c, Type *t) { add_type_info_type(c, t_f64); break; } - } break; + break; case Type_Pointer: add_type_info_type(c, bt->Pointer.elem); @@ -1352,7 +1353,7 @@ void add_type_info_type(Checker *c, Type *t) { } break; - case Type_Struct: { + case Type_Struct: if (bt->Struct.scope != nullptr) { for_array(i, bt->Struct.scope->elements.entries) { Entity *e = bt->Struct.scope->elements.entries[i].value; @@ -1363,14 +1364,14 @@ void add_type_info_type(Checker *c, Type *t) { Entity *f = bt->Struct.fields[i]; add_type_info_type(c, f->type); } - } break; + break; - case Type_Map: { + case Type_Map: generate_map_internal_types(c->allocator, bt); add_type_info_type(c, bt->Map.key); add_type_info_type(c, bt->Map.value); add_type_info_type(c, bt->Map.generated_struct_type); - } break; + break; case Type_Tuple: for_array(i, bt->Tuple.variables) { @@ -1457,7 +1458,7 @@ void add_dependency_to_map(PtrSet *map, CheckerInfo *info, Entity *ent } } -PtrSet generate_minimum_dependency_map(CheckerInfo *info, Entity *start) { +PtrSet generate_minimum_dependency_set(CheckerInfo *info, Entity *start) { PtrSet map = {}; // Key: Entity * ptr_set_init(&map, heap_allocator()); @@ -2360,7 +2361,9 @@ void add_import_dependency_node(Checker *c, AstNode *decl, Mapelse_stmt, M); break; @@ -2839,17 +2842,15 @@ void check_import_entities(Checker *c) { }; - if (path.count > 0) { - Scope *s = path[path.count-1]; - Token token = mt(s); - error(token, "Cyclic importation of `%.*s`", LIT(token.string)); - for (isize i = 0; i < path.count; i++) { - gb_printf_err("\t`%.*s` refers to\n", LIT(token.string)); - s = path[i]; - token = mt(s); - } - gb_printf_err("\t`%.*s`\n", LIT(token.string)); + Scope *s = path[path.count-1]; + Token token = mt(s); + error(token, "Cyclic importation of `%.*s`", LIT(token.string)); + for (isize i = 0; i < path.count; i++) { + gb_printf_err("\t`%.*s` refers to\n", LIT(token.string)); + s = path[i]; + token = mt(s); } + gb_printf_err("\t`%.*s`\n", LIT(token.string)); } } @@ -3059,11 +3060,14 @@ void check_parsed_files(Checker *c) { for_array(i, c->parser->files) { AstFile *f = c->parser->files[i]; Scope *scope = create_scope_from_file(c, f); - f->decl_info = make_declaration_info(c->allocator, f->scope, c->context.decl); HashKey key = hash_string(f->tokenizer.fullpath); map_set(&c->file_scopes, key, scope); map_set(&c->info.files, key, f); + + if (scope->is_init) { + c->info.init_scope = scope; + } } // Collect Entities @@ -3077,7 +3081,7 @@ void check_parsed_files(Checker *c) { check_import_entities(c); check_all_global_entities(c); - init_preload(c); // NOTE(bill): This could be setup previously through the use of `type_info(_of_val)` + init_preload(c); // NOTE(bill): This could be setup previously through the use of `type_info_of` // Check procedure bodies // NOTE(bill): Nested procedures bodies will be added to this "queue" @@ -3112,25 +3116,12 @@ void check_parsed_files(Checker *c) { check_proc_body(c, pi->token, pi->decl, pi->type, pi->body); } - { - for_array(i, c->info.entities.entries) { - auto *entry = &c->info.entities.entries[i]; - Entity *e = cast(Entity *)entry->key.ptr; - String name = e->token.string; - if (e->kind == Entity_Procedure && !e->scope->is_global) { - if (e->scope->is_init && name == "main") { - c->info.entry_point = e; - break; - } - } - } - c->info.minimum_dependency_map = generate_minimum_dependency_map(&c->info, c->info.entry_point); - } + c->info.minimum_dependency_set = generate_minimum_dependency_set(&c->info, c->info.entry_point); + // Calculate initialization order of global variables calculate_global_init_order(c); - // Add untyped expression values for_array(i, c->info.untyped.entries) { auto *entry = &c->info.untyped.entries[i]; @@ -3148,8 +3139,6 @@ void check_parsed_files(Checker *c) { // TODO(bill): Check for unused imports (and remove) or even warn/err // TODO(bill): Any other checks? - -#if 1 // Add "Basic" type information for (isize i = 0; i < gb_count_of(basic_types)-1; i++) { Type *t = &basic_types[i]; @@ -3158,53 +3147,34 @@ void check_parsed_files(Checker *c) { } } - /* - for (isize i = 0; i < gb_count_of(basic_type_aliases)-1; i++) { - Type *t = &basic_type_aliases[i]; - if (t->Basic.size > 0) { - add_type_info_type(c, t); - } - } - */ -#endif - - // NOTE(bill): Check for illegal cyclic type declarations for_array(i, c->info.definitions.entries) { Entity *e = c->info.definitions.entries[i].value; - if (e->kind == Entity_TypeName) { - if (e->type != nullptr) { - // i64 size = type_size_of(c->sizes, c->allocator, e->type); - i64 align = type_align_of(c->allocator, e->type); - if (align > 0) { - add_type_info_type(c, e->type); - } + if (e->kind == Entity_TypeName && e->type != nullptr) { + // i64 size = type_size_of(c->sizes, c->allocator, e->type); + i64 align = type_align_of(c->allocator, e->type); + if (align > 0) { + add_type_info_type(c, e->type); } } } - // gb_printf_err("Count: %td\n", c->info.type_info_count++); - if (!build_context.is_dll) { - for_array(i, c->file_scopes.entries) { - Scope *s = c->file_scopes.entries[i].value; - if (s->is_init) { - Entity *e = current_scope_lookup_entity(s, str_lit("main")); - if (e == nullptr) { - Token token = {}; - if (s->file->tokens.count > 0) { - token = s->file->tokens[0]; - } else { - token.pos.file = s->file->tokenizer.fullpath; - token.pos.line = 1; - token.pos.column = 1; - } - - error(token, "Undefined entry point procedure `main`"); - } - - break; + Scope *s = c->info.init_scope; + GB_ASSERT(s != nullptr); + GB_ASSERT(s->is_init); + Entity *e = current_scope_lookup_entity(s, str_lit("main")); + if (e == nullptr) { + Token token = {}; + if (s->file->tokens.count > 0) { + token = s->file->tokens[0]; + } else { + token.pos.file = s->file->tokenizer.fullpath; + token.pos.line = 1; + token.pos.column = 1; } + + error(token, "Undefined entry point procedure `main`"); } } } diff --git a/src/common.cpp b/src/common.cpp index 441cdda34..ef2b5f68d 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -50,16 +50,19 @@ GB_ALLOCATOR_PROC(heap_allocator_proc) { if (flags & gbAllocatorFlag_ClearToZero) { gb_zero_size(ptr, size); } - } break; + break; + } case gbAllocation_Free: { free(old_memory); - } break; + break; + } case gbAllocation_Resize: { // ptr = realloc(old_memory, size); ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment); - } break; + break; + } #else // TODO(bill): *nix version that's decent case gbAllocation_Alloc: { @@ -68,15 +71,18 @@ GB_ALLOCATOR_PROC(heap_allocator_proc) { if (flags & gbAllocatorFlag_ClearToZero) { gb_zero_size(ptr, size); } - } break; + break; + } case gbAllocation_Free: { free(old_memory); - } break; + break; + } case gbAllocation_Resize: { ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment); - } break; + break; + } #endif case gbAllocation_FreeAll: diff --git a/src/exact_value.cpp b/src/exact_value.cpp index 070dffc6a..4f9f1e40f 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -270,7 +270,8 @@ ExactValue exact_value_to_integer(ExactValue v) { if (f == v.value_float) { return exact_value_i128(i); } - } break; + break; + } case ExactValue_Pointer: return exact_value_i64(cast(i64)cast(intptr)v.value_pointer); @@ -352,7 +353,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) case ExactValue_Complex: return v; } - } break; + break; + } case Token_Sub: { switch (v.kind) { @@ -374,7 +376,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) return exact_value_complex(-real, -imag); } } - } break; + break; + } case Token_Xor: { i128 i = I128_ZERO; @@ -396,7 +399,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) } return exact_value_i128(i); - } break; + break; + } case Token_Not: { switch (v.kind) { @@ -404,7 +408,8 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) case ExactValue_Bool: return exact_value_bool(!v.value_bool); } - } break; + break; + } } failure: @@ -521,7 +526,8 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) } return exact_value_i128(c); - } break; + break; + } case ExactValue_Float: { f64 a = x.value_float; @@ -533,7 +539,8 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) case Token_Quo: return exact_value_float(a / b); default: goto error; } - } break; + break; + } case ExactValue_Complex: { y = exact_value_to_complex(y); @@ -560,11 +567,13 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) f64 s = c*c + d*d; real = (a*c + b*d)/s; imag = (b*c - a*d)/s; - } break; + break; + } default: goto error; } return exact_value_complex(real, imag); - } break; + break; + } case ExactValue_String: { if (op != Token_Add) goto error; @@ -577,7 +586,8 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) gb_memmove(data, sx.text, sx.len); gb_memmove(data+sx.len, sy.text, sy.len); return exact_value_string(make_string(data, len)); - } break; + break; + } } error:; // NOTE(bill): MSVC accepts this??? apparently you cannot declare variables immediately after labels... @@ -620,7 +630,8 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) { case Token_Gt: return a > b; case Token_GtEq: return a >= b; } - } break; + break; + } case ExactValue_Float: { f64 a = x.value_float; @@ -633,7 +644,8 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) { case Token_Gt: return cmp_f64(a, b) > 0; case Token_GtEq: return cmp_f64(a, b) >= 0; } - } break; + break; + } case ExactValue_Complex: { f64 a = x.value_complex.real; @@ -644,7 +656,8 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) { case Token_CmpEq: return cmp_f64(a, c) == 0 && cmp_f64(b, d) == 0; case Token_NotEq: return cmp_f64(a, c) != 0 || cmp_f64(b, d) != 0; } - } break; + break; + } case ExactValue_String: { String a = x.value_string; @@ -658,7 +671,8 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) { case Token_Gt: return a > b; case Token_GtEq: return a >= b; } - } break; + break; + } case ExactValue_Type: switch (op) { diff --git a/src/ir.cpp b/src/ir.cpp index 4901de4ca..673cb5a54 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -19,7 +19,7 @@ struct irModule { String layout; // String triple; - PtrSet min_dep_map; + PtrSet min_dep_set; Map values; // Key: Entity * Map members; // Key: String Map entity_names; // Key: Entity * of the typename @@ -623,7 +623,7 @@ Type *ir_instr_type(irInstr *instr) { return pt; } return nullptr; - } break; + } } return nullptr; } @@ -741,7 +741,8 @@ Array *ir_value_referrers(irValue *v) { case irInstr_Local: return &i->Local.referrers; } - } break; + break; + } } return nullptr; @@ -2107,7 +2108,8 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue * irValue *z = ir_emit_arith(proc, Token_Mul, b, c, ft); irValue *w = ir_emit_arith(proc, Token_Mul, a, d, ft); imag = ir_emit_arith(proc, Token_Add, z, w, ft); - } break; + break; + } case Token_Quo: { irValue *s1 = ir_emit_arith(proc, Token_Mul, c, c, ft); irValue *s2 = ir_emit_arith(proc, Token_Mul, d, d, ft); @@ -2122,7 +2124,8 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue * irValue *w = ir_emit_arith(proc, Token_Mul, a, d, ft); imag = ir_emit_arith(proc, Token_Sub, z, w, ft); imag = ir_emit_arith(proc, Token_Quo, imag, s, ft); - } break; + break; + } } ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), real); @@ -2473,7 +2476,8 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) { case 0: result_type = ft; break; case 1: result_type = ft; break; } - } break; + break; + } } break; case Type_Struct: @@ -2509,7 +2513,8 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) { case 0: result_type = gst->Struct.fields[0]->type; break; case 1: result_type = gst->Struct.fields[1]->type; break; } - } break; + break; + } default: GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(ir_type(s)), index); @@ -2558,7 +2563,8 @@ irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) { type = t_type_info_ptr; } e = ir_emit_struct_ep(proc, e, index); - } break; + break; + } case Basic_string: e = ir_emit_struct_ep(proc, e, index); @@ -2924,12 +2930,14 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { irValue **args = gb_alloc_array(a, irValue *, 1); args[0] = value; return ir_emit_global_call(proc, "__gnu_h2f_ieee", args, 1); - } break; + break; + } case 8: { irValue **args = gb_alloc_array(a, irValue *, 1); args[0] = value; return ir_emit_global_call(proc, "__f16_to_f64", args, 1); - } break; + break; + } } } else if (dz == 2) { switch (sz) { @@ -2938,12 +2946,14 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { irValue **args = gb_alloc_array(a, irValue *, 1); args[0] = value; return ir_emit_global_call(proc, "__gnu_f2h_ieee", args, 1); - } break; + break; + } case 8: { irValue **args = gb_alloc_array(a, irValue *, 1); args[0] = value; return ir_emit_global_call(proc, "__truncdfhf2", args, 1); - } break; + break; + } } } @@ -3897,12 +3907,14 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv } return ir_emit_source_code_location(proc, procedure, pos); - } break; + break; + } case BuiltinProc_type_info_of: { Type *t = default_type(type_of_expr(proc->module->info, ce->args[0])); return ir_type_info(proc, t); - } break; + break; + } case BuiltinProc_len: { irValue *v = ir_build_expr(proc, ce->args[0]); @@ -3929,7 +3941,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv } GB_PANIC("Unreachable"); - } break; + break; + } case BuiltinProc_cap: { irValue *v = ir_build_expr(proc, ce->args[0]); @@ -3956,7 +3969,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv GB_PANIC("Unreachable"); - } break; + break; + } #if 0 case BuiltinProc_new: { @@ -3993,7 +4007,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_emit_store(proc, tag_ptr, ir_const_int(a, variant_index)); } return v; - } break; + break; + } #endif case BuiltinProc_make: { @@ -4079,7 +4094,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv return ir_emit_load(proc, array); } - } break; + break; + } #if 0 case BuiltinProc_free: { @@ -4154,7 +4170,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue **args = gb_alloc_array(a, irValue *, 1); args[0] = ptr; return ir_emit_global_call(proc, "free_ptr", args, 1); - } break; + break; + } #endif #if 0 case BuiltinProc_reserve: { @@ -4190,7 +4207,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv } else { GB_PANIC("Unknown type for `reserve`"); } - } break; + break; + } #endif #if 0 case BuiltinProc_clear: { @@ -4217,7 +4235,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv GB_PANIC("TODO(bill): ir clear for `%s`", type_to_string(t)); } return nullptr; - } break; + break; + } #endif #if 0 case BuiltinProc_append: { @@ -4327,7 +4346,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv return ir_emit_global_call(proc, "__slice_append", daa_args, 5); } return ir_emit_global_call(proc, "__dynamic_array_append", daa_args, 5); - } break; + break; + } #endif #if 0 case BuiltinProc_delete: { @@ -4345,7 +4365,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv args[0] = ir_gen_map_header(proc, addr, map_type); args[1] = ir_gen_map_key(proc, key, key_type); return ir_emit_global_call(proc, "__dynamic_map_delete", args, 2); - } break; + break; + } #endif case BuiltinProc_swizzle: { @@ -4374,7 +4395,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_emit_comment(proc, str_lit("swizzle.end")); return ir_emit_load(proc, dst); // return ir_emit(proc, ir_instr_vector_shuffle(proc, vector, indices, index_count)); - } break; + break; + } case BuiltinProc_complex: { ir_emit_comment(proc, str_lit("complex")); @@ -4389,20 +4411,23 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 1), imag); return ir_emit_load(proc, dst); - } break; + break; + } case BuiltinProc_real: { ir_emit_comment(proc, str_lit("real")); irValue *val = ir_build_expr(proc, ce->args[0]); irValue *real = ir_emit_struct_ev(proc, val, 0); return ir_emit_conv(proc, real, tv.type); - } break; + break; + } case BuiltinProc_imag: { ir_emit_comment(proc, str_lit("imag")); irValue *val = ir_build_expr(proc, ce->args[0]); irValue *imag = ir_emit_struct_ev(proc, val, 1); return ir_emit_conv(proc, imag, tv.type); - } break; + break; + } case BuiltinProc_conj: { ir_emit_comment(proc, str_lit("conj")); @@ -4418,7 +4443,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), imag); } return ir_emit_load(proc, res); - } break; + break; + } #if 0 case BuiltinProc_slice_ptr: { @@ -4436,7 +4462,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue *slice = ir_add_local_generated(proc, slice_type); ir_fill_slice(proc, slice, ptr, count, capacity); return ir_emit_load(proc, slice); - } break; + break; + } case BuiltinProc_slice_to_bytes: { ir_emit_comment(proc, str_lit("slice_to_bytes")); @@ -4455,7 +4482,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv capacity = ir_emit_arith(proc, Token_Mul, capacity, ir_const_int(proc->module->allocator, elem_size), t_int); ir_fill_slice(proc, slice, ptr, count, capacity); return ir_emit_load(proc, slice); - } break; + break; + } #endif case BuiltinProc_expand_to_tuple: { @@ -4475,7 +4503,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_emit_store(proc, ep, f); } return ir_emit_load(proc, tuple); - } break; + break; + } case BuiltinProc_min: { ir_emit_comment(proc, str_lit("min")); @@ -4484,7 +4513,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t); irValue *cond = ir_emit_comp(proc, Token_Lt, x, y); return ir_emit_select(proc, cond, x, y); - } break; + break; + } case BuiltinProc_max: { ir_emit_comment(proc, str_lit("max")); @@ -4493,7 +4523,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t); irValue *cond = ir_emit_comp(proc, Token_Gt, x, y); return ir_emit_select(proc, cond, x, y); - } break; + break; + } case BuiltinProc_abs: { ir_emit_comment(proc, str_lit("abs")); @@ -4514,7 +4545,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv irValue *cond = ir_emit_comp(proc, Token_Lt, x, zero); irValue *neg = ir_emit(proc, ir_instr_unary_op(proc, Token_Sub, x, t)); return ir_emit_select(proc, cond, neg, x); - } break; + break; + } case BuiltinProc_clamp: { ir_emit_comment(proc, str_lit("clamp")); @@ -4523,7 +4555,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv ir_build_expr(proc, ce->args[0]), ir_build_expr(proc, ce->args[1]), ir_build_expr(proc, ce->args[2])); - } break; + break; + } } GB_PANIC("Unhandled built-in procedure"); @@ -4775,7 +4808,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *right = ir_build_expr(proc, be->right); irValue *cmp = ir_emit_comp(proc, be->op.kind, left, right); return ir_emit_conv(proc, cmp, type); - } break; + break; + } case Token_CmpAnd: case Token_CmpOr: @@ -5307,7 +5341,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *len = ir_const_int(a, t->Vector.count); ir_emit_bounds_check(proc, ast_node_token(ie->index), index, len); return ir_addr(elem); - } break; + break; + } case Type_Array: { irValue *array = nullptr; @@ -5324,7 +5359,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *len = ir_const_int(a, t->Vector.count); ir_emit_bounds_check(proc, ast_node_token(ie->index), index, len); return ir_addr(elem); - } break; + break; + } case Type_Slice: { irValue *slice = nullptr; @@ -5342,7 +5378,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_bounds_check(proc, ast_node_token(ie->index), index, len); irValue *v = ir_emit_ptr_offset(proc, elem, index); return ir_addr(v); - } break; + break; + } case Type_DynamicArray: { irValue *dynamic_array = nullptr; @@ -5360,7 +5397,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_bounds_check(proc, ast_node_token(ie->index), index, len); irValue *v = ir_emit_ptr_offset(proc, elem, index); return ir_addr(v); - } break; + break; + } case Type_Basic: { // Basic_string @@ -5384,7 +5422,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_bounds_check(proc, ast_node_token(ie->index), index, len); return ir_addr(ir_emit_ptr_offset(proc, elem, index)); - } break; + break; + } } case_end; @@ -5485,7 +5524,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *str = ir_add_local_generated(proc, t_string); ir_fill_string(proc, str, elem, len); return ir_addr(str); - } break; + break; + } } GB_PANIC("Unknown slicable type"); @@ -5544,7 +5584,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_store(proc, gep, ev); } } - } break; + break; + } case Type_Struct: { // TODO(bill): "constant" unions are not initialized constantly at the moment. @@ -5590,7 +5631,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_store(proc, gep, fv); } } - } break; + break; + } case Type_Map: { if (cl->elems.count == 0) { @@ -5611,7 +5653,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *value = ir_build_expr(proc, fv->value); ir_insert_dynamic_map_key_and_value(proc, v, type, key, value); } - } break; + break; + } case Type_DynamicArray: { if (cl->elems.count == 0) { @@ -5649,7 +5692,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { args[4] = ir_const_int(a, item_count); ir_emit_global_call(proc, "__dynamic_array_append", args, 5); } - } break; + break; + } case Type_Array: { if (cl->elems.count > 0) { @@ -5667,7 +5711,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_store(proc, gep, ev); } } - } break; + break; + } case Type_Slice: { if (cl->elems.count > 0) { Type *elem_type = bt->Slice.elem; @@ -5695,7 +5740,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *count = ir_const_int(proc->module->allocator, slice->ConstantSlice.count); ir_fill_slice(proc, v, data, count, count); } - } break; + break; + } case Type_Basic: { GB_ASSERT(is_type_any(bt)); @@ -5814,7 +5860,7 @@ irValue *ir_build_cond(irProcedure *proc, AstNode *cond, irBlock *true_block, ir void ir_build_poly_proc(irProcedure *proc, AstNodeProcLit *pd, Entity *e) { GB_ASSERT(pd->body != nullptr); - if (ptr_set_exists(&proc->module->min_dep_map, e) == false) { + if (ptr_set_exists(&proc->module->min_dep_set, e) == false) { // NOTE(bill): Nothing depends upon it so doesn't need to be built return; } @@ -5876,7 +5922,7 @@ void ir_build_constant_value_decl(irProcedure *proc, AstNodeValueDecl *vd) { } } - if (!polymorphic_struct && !ptr_set_exists(&proc->module->min_dep_map, e)) { + if (!polymorphic_struct && !ptr_set_exists(&proc->module->min_dep_set, e)) { continue; } @@ -5905,7 +5951,7 @@ void ir_build_constant_value_decl(irProcedure *proc, AstNodeValueDecl *vd) { auto procs = *found; for_array(i, procs) { Entity *e = procs[i]; - if (!ptr_set_exists(&proc->module->min_dep_map, e)) { + if (!ptr_set_exists(&proc->module->min_dep_set, e)) { continue; } DeclInfo *d = decl_info_of_entity(info, e); @@ -6061,19 +6107,23 @@ void ir_build_range_indexed(irProcedure *proc, irValue *expr, Type *val_type, ir switch (expr_type->kind) { case Type_Array: { val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx)); - } break; + break; + } case Type_Vector: { val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx)); - } break; + break; + } case Type_Slice: { irValue *elem = ir_slice_elem(proc, expr); val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx)); - } break; + break; + } case Type_DynamicArray: { irValue *elem = ir_emit_struct_ep(proc, expr, 0); elem = ir_emit_load(proc, elem); val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx)); - } break; + break; + } case Type_Map: { irValue *entries = ir_emit_struct_ep(proc, expr, 1); irValue *elem = ir_emit_struct_ep(proc, entries, 0); @@ -6093,7 +6143,8 @@ void ir_build_range_indexed(irProcedure *proc, irValue *expr, Type *val_type, ir } - } break; + break; + } default: GB_PANIC("Cannot do range_indexed of %s", type_to_string(expr_type)); break; @@ -6393,7 +6444,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } } - } break; + break; + } default: { // NOTE(bill): Only 1 += 1 is allowed, no tuples @@ -6403,7 +6455,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irAddr lhs = ir_build_addr(proc, as->lhs[0]); irValue *value = ir_build_expr(proc, as->rhs[0]); ir_build_assign_op(proc, lhs, value, cast(TokenKind)op); - } break; + break; + } } gb_temp_arena_memory_end(tmp); @@ -6726,7 +6779,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irValue *entries_ptr = ir_emit_struct_ep(proc, map, 1); irValue *count_ptr = ir_emit_struct_ep(proc, entries_ptr, 1); ir_build_range_indexed(proc, map, val_type, count_ptr, &val, &index, &loop, &done); - } break; + break; + } case Type_Array: { irValue *count_ptr = nullptr; irValue *array = ir_build_addr(proc, rs->expr).addr; @@ -6736,7 +6790,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { count_ptr = ir_add_local_generated(proc, t_int); ir_emit_store(proc, count_ptr, ir_const_int(proc->module->allocator, et->Array.count)); ir_build_range_indexed(proc, array, val_type, count_ptr, &val, &index, &loop, &done); - } break; + break; + } case Type_Vector: { irValue *count_ptr = nullptr; irValue *vector = ir_build_addr(proc, rs->expr).addr; @@ -6746,7 +6801,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { count_ptr = ir_add_local_generated(proc, t_int); ir_emit_store(proc, count_ptr, ir_const_int(proc->module->allocator, et->Vector.count)); ir_build_range_indexed(proc, vector, val_type, count_ptr, &val, &index, &loop, &done); - } break; + break; + } case Type_DynamicArray: { irValue *count_ptr = nullptr; irValue *array = ir_build_addr(proc, rs->expr).addr; @@ -6755,7 +6811,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } count_ptr = ir_emit_struct_ep(proc, array, 1); ir_build_range_indexed(proc, array, val_type, count_ptr, &val, &index, &loop, &done); - } break; + break; + } case Type_Slice: { irValue *count_ptr = nullptr; irValue *slice = ir_build_expr(proc, rs->expr); @@ -6767,7 +6824,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { ir_emit_store(proc, count_ptr, ir_slice_count(proc, slice)); } ir_build_range_indexed(proc, slice, val_type, count_ptr, &val, &index, &loop, &done); - } break; + break; + } case Type_Basic: { irValue *string = ir_build_expr(proc, rs->expr); if (is_type_pointer(ir_type(string))) { @@ -6779,7 +6837,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { string = ir_emit_load(proc, s); } ir_build_range_string(proc, string, val_type, &val, &index, &loop, &done); - } break; + break; + } default: GB_PANIC("Cannot range over %s", type_to_string(expr_type)); break; @@ -6812,18 +6871,18 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { ir_start_block(proc, done); case_end; - case_ast_node(ms, MatchStmt, node); - ir_emit_comment(proc, str_lit("MatchStmt")); - if (ms->init != nullptr) { - ir_build_stmt(proc, ms->init); + case_ast_node(ss, SwitchStmt, node); + ir_emit_comment(proc, str_lit("SwitchStmt")); + if (ss->init != nullptr) { + ir_build_stmt(proc, ss->init); } irValue *tag = v_true; - if (ms->tag != nullptr) { - tag = ir_build_expr(proc, ms->tag); + if (ss->tag != nullptr) { + tag = ir_build_expr(proc, ss->tag); } - irBlock *done = ir_new_block(proc, node, "match.done"); // NOTE(bill): Append later + irBlock *done = ir_new_block(proc, node, "switch.done"); // NOTE(bill): Append later - ast_node(body, BlockStmt, ms->body); + ast_node(body, BlockStmt, ss->body); Array default_stmts = {}; irBlock *default_fall = nullptr; @@ -6841,9 +6900,9 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (body == nullptr) { if (cc->list.count == 0) { - body = ir_new_block(proc, clause, "match.dflt.body"); + body = ir_new_block(proc, clause, "switch.dflt.body"); } else { - body = ir_new_block(proc, clause, "match.case.body"); + body = ir_new_block(proc, clause, "switch.case.body"); } } if (append_fall && body == fall) { @@ -6853,7 +6912,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { fall = done; if (i+1 < case_count) { append_fall = true; - fall = ir_new_block(proc, clause, "match.fall.body"); + fall = ir_new_block(proc, clause, "switch.fall.body"); } if (cc->list.count == 0) { @@ -6867,7 +6926,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irBlock *next_cond = nullptr; for_array(j, cc->list) { AstNode *expr = unparen_expr(cc->list[j]); - next_cond = ir_new_block(proc, clause, "match.case.next"); + next_cond = ir_new_block(proc, clause, "switch.case.next"); irValue *cond = v_false; if (is_ast_node_a_range(expr)) { ast_node(ie, BinaryExpr, expr); @@ -6891,7 +6950,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } ir_start_block(proc, body); - ir_push_target_list(proc, ms->label, done, nullptr, fall); + ir_push_target_list(proc, ss->label, done, nullptr, fall); ir_open_scope(proc); ir_build_stmt_list(proc, cc->stmts); ir_close_scope(proc, irDeferExit_Default, body); @@ -6906,7 +6965,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { ir_emit_jump(proc, default_block); ir_start_block(proc, default_block); - ir_push_target_list(proc, ms->label, done, nullptr, default_fall); + ir_push_target_list(proc, ss->label, done, nullptr, default_fall); ir_open_scope(proc); ir_build_stmt_list(proc, default_stmts); ir_close_scope(proc, irDeferExit_Default, default_block); @@ -6918,11 +6977,11 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { case_end; - case_ast_node(ms, TypeMatchStmt, node); - ir_emit_comment(proc, str_lit("TypeMatchStmt")); + case_ast_node(ss, TypeSwitchStmt, node); + ir_emit_comment(proc, str_lit("TypeSwitchStmt")); gbAllocator allocator = proc->module->allocator; - ast_node(as, AssignStmt, ms->tag); + ast_node(as, AssignStmt, ss->tag); GB_ASSERT(as->lhs.count == 1); GB_ASSERT(as->rhs.count == 1); @@ -6948,15 +7007,15 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { union_data = ir_emit_conv(proc, parent_ptr, t_rawptr); } - irBlock *start_block = ir_new_block(proc, node, "typematch.case.first"); + irBlock *start_block = ir_new_block(proc, node, "typeswitch.case.first"); ir_emit_jump(proc, start_block); ir_start_block(proc, start_block); // NOTE(bill): Append this later - irBlock *done = ir_new_block(proc, node, "typematch.done"); + irBlock *done = ir_new_block(proc, node, "typeswitch.done"); AstNode *default_ = nullptr; - ast_node(body, BlockStmt, ms->body); + ast_node(body, BlockStmt, ss->body); gb_local_persist i32 weird_count = 0; @@ -6968,11 +7027,11 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { continue; } - irBlock *body = ir_new_block(proc, clause, "typematch.body"); + irBlock *body = ir_new_block(proc, clause, "typeswitch.body"); irBlock *next = nullptr; Type *case_type = nullptr; for_array(type_index, cc->list) { - next = ir_new_block(proc, nullptr, "typematch.next"); + next = ir_new_block(proc, nullptr, "typeswitch.next"); case_type = type_of_expr(proc->module->info, cc->list[type_index]); irValue *cond = nullptr; if (match_type_kind == MatchType_Union) { @@ -7028,13 +7087,13 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } ir_store_type_case_implicit(proc, clause, value); - ir_type_case_body(proc, ms->label, clause, body, done); + ir_type_case_body(proc, ss->label, clause, body, done); ir_start_block(proc, next); } if (default_ != nullptr) { ir_store_type_case_implicit(proc, default_, parent_value); - ir_type_case_body(proc, ms->label, default_, proc->curr_block, done); + ir_type_case_body(proc, ss->label, default_, proc->curr_block, done); } else { ir_emit_jump(proc, done); } @@ -7635,7 +7694,7 @@ void ir_gen_tree(irGen *s) { array_init(&global_variables, m->tmp_allocator, global_variable_max_count); m->entry_point_entity = entry_point; - m->min_dep_map = info->minimum_dependency_map; + m->min_dep_set = info->minimum_dependency_set; for_array(i, info->variable_init_order) { DeclInfo *d = info->variable_init_order[i]; @@ -7647,7 +7706,7 @@ void ir_gen_tree(irGen *s) { continue; } - if (!ptr_set_exists(&m->min_dep_map, e)) { + if (!ptr_set_exists(&m->min_dep_set, e)) { continue; } DeclInfo *decl = decl_info_of_entity(info, e); @@ -7717,7 +7776,7 @@ void ir_gen_tree(irGen *s) { } } - if (!polymorphic_struct && !ptr_set_exists(&m->min_dep_map, e)) { + if (!polymorphic_struct && !ptr_set_exists(&m->min_dep_set, e)) { // NOTE(bill): Nothing depends upon it so doesn't need to be built continue; } @@ -7766,7 +7825,8 @@ void ir_gen_tree(irGen *s) { if (map_get(&m->members, hash_name) == nullptr) { multi_map_insert(&m->members, hash_name, p); } - } break; + break; + } } } @@ -8068,7 +8128,8 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), name); ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), gtip); - } break; + break; + } case Type_Basic: ir_emit_comment(proc, str_lit("TypeInfoBasic")); @@ -8092,7 +8153,8 @@ void ir_gen_tree(irGen *s) { tag = ir_emit_conv(proc, variant_ptr, t_type_info_integer_ptr); irValue *is_signed = ir_const_bool(a, (t->Basic.flags & BasicFlag_Unsigned) == 0); ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), is_signed); - } break; + break; + } case Basic_rune: tag = ir_emit_conv(proc, variant_ptr, t_type_info_rune_ptr); @@ -8129,7 +8191,8 @@ void ir_gen_tree(irGen *s) { tag = ir_emit_conv(proc, variant_ptr, t_type_info_pointer_ptr); irValue *gep = ir_get_type_info_ptr(proc, t->Pointer.elem); ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep); - } break; + break; + } case Type_Array: { ir_emit_comment(proc, str_lit("TypeInfoArray")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_array_ptr); @@ -8143,7 +8206,8 @@ void ir_gen_tree(irGen *s) { irValue *count = ir_emit_struct_ep(proc, tag, 2); ir_emit_store(proc, count, ir_const_int(a, t->Array.count)); - } break; + break; + } case Type_DynamicArray: { ir_emit_comment(proc, str_lit("TypeInfoDynamicArray")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_dynamic_array_ptr); @@ -8153,7 +8217,8 @@ void ir_gen_tree(irGen *s) { isize ez = type_size_of(a, t->DynamicArray.elem); irValue *elem_size = ir_emit_struct_ep(proc, tag, 1); ir_emit_store(proc, elem_size, ir_const_int(a, ez)); - } break; + break; + } case Type_Slice: { ir_emit_comment(proc, str_lit("TypeInfoSlice")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_slice_ptr); @@ -8163,7 +8228,8 @@ void ir_gen_tree(irGen *s) { isize ez = type_size_of(a, t->Slice.elem); irValue *elem_size = ir_emit_struct_ep(proc, tag, 1); ir_emit_store(proc, elem_size, ir_const_int(a, ez)); - } break; + break; + } case Type_Vector: { ir_emit_comment(proc, str_lit("TypeInfoVector")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_vector_ptr); @@ -8174,7 +8240,8 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_const_int(a, ez)); ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_const_int(a, t->Vector.count)); - } break; + break; + } case Type_Proc: { ir_emit_comment(proc, str_lit("TypeInfoProc")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_procedure_ptr); @@ -8194,7 +8261,8 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, convention, ir_const_int(a, t->Proc.calling_convention)); // TODO(bill): TypeInfo for procedures - } break; + break; + } case Type_Tuple: { ir_emit_comment(proc, str_lit("TypeInfoTuple")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_tuple_ptr); @@ -8219,7 +8287,8 @@ void ir_gen_tree(irGen *s) { irValue *count = ir_const_int(a, t->Tuple.variables.count); ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 0), memory_types, count, count); ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names, count, count); - } break; + break; + } case Type_Enum: ir_emit_comment(proc, str_lit("TypeInfoEnum")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_enum_ptr); @@ -8293,7 +8362,8 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, tag_offset_ptr, ir_const_int(a, tag_offset)); } - } break; + break; + } case Type_Struct: { ir_emit_comment(proc, str_lit("TypeInfoStruct")); @@ -8347,7 +8417,8 @@ void ir_gen_tree(irGen *s) { ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names, cv, cv); ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 2), memory_offsets, cv, cv); ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 3), memory_usings, cv, cv); - } break; + break; + } case Type_Map: { ir_emit_comment(proc, str_lit("TypeInfoMap")); tag = ir_emit_conv(proc, variant_ptr, t_type_info_map_ptr); @@ -8360,7 +8431,8 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, key, ir_get_type_info_ptr(proc, t->Map.key)); ir_emit_store(proc, value, ir_get_type_info_ptr(proc, t->Map.value)); ir_emit_store(proc, generated_struct, ir_get_type_info_ptr(proc, t->Map.generated_struct_type)); - } break; + break; + } case Type_BitField: { ir_emit_comment(proc, str_lit("TypeInfoBitField")); @@ -8403,7 +8475,8 @@ void ir_gen_tree(irGen *s) { irValue *offset_array_elem = ir_array_elem(proc, offset_array); ir_fill_slice(proc, offsets, offset_array_elem, v_count, v_count); } - } break; + break; + } } diff --git a/src/parser.cpp b/src/parser.cpp index 02fdd60b6..99c7af21a 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -281,14 +281,14 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ Array list; \ Array stmts; \ }) \ - AST_NODE_KIND(MatchStmt, "match statement", struct { \ + AST_NODE_KIND(SwitchStmt, "switch statement", struct { \ Token token; \ AstNode *label; \ AstNode *init; \ AstNode *tag; \ AstNode *body; \ }) \ - AST_NODE_KIND(TypeMatchStmt, "type match statement", struct { \ + AST_NODE_KIND(TypeSwitchStmt, "type switch statement", struct { \ Token token; \ AstNode *label; \ AstNode *tag; \ @@ -575,8 +575,8 @@ Token ast_node_token(AstNode *node) { case AstNode_ForStmt: return node->ForStmt.token; case AstNode_RangeStmt: return node->RangeStmt.token; case AstNode_CaseClause: return node->CaseClause.token; - case AstNode_MatchStmt: return node->MatchStmt.token; - case AstNode_TypeMatchStmt: return node->TypeMatchStmt.token; + case AstNode_SwitchStmt: return node->SwitchStmt.token; + case AstNode_TypeSwitchStmt: return node->TypeSwitchStmt.token; case AstNode_DeferStmt: return node->DeferStmt.token; case AstNode_BranchStmt: return node->BranchStmt.token; case AstNode_UsingStmt: return node->UsingStmt.token; @@ -783,16 +783,16 @@ AstNode *clone_ast_node(gbAllocator a, AstNode *node) { n->CaseClause.list = clone_ast_node_array(a, n->CaseClause.list); n->CaseClause.stmts = clone_ast_node_array(a, n->CaseClause.stmts); break; - case AstNode_MatchStmt: - n->MatchStmt.label = clone_ast_node(a, n->MatchStmt.label); - n->MatchStmt.init = clone_ast_node(a, n->MatchStmt.init); - n->MatchStmt.tag = clone_ast_node(a, n->MatchStmt.tag); - n->MatchStmt.body = clone_ast_node(a, n->MatchStmt.body); + case AstNode_SwitchStmt: + n->SwitchStmt.label = clone_ast_node(a, n->SwitchStmt.label); + n->SwitchStmt.init = clone_ast_node(a, n->SwitchStmt.init); + n->SwitchStmt.tag = clone_ast_node(a, n->SwitchStmt.tag); + n->SwitchStmt.body = clone_ast_node(a, n->SwitchStmt.body); break; - case AstNode_TypeMatchStmt: - n->TypeMatchStmt.label = clone_ast_node(a, n->TypeMatchStmt.label); - n->TypeMatchStmt.tag = clone_ast_node(a, n->TypeMatchStmt.tag); - n->TypeMatchStmt.body = clone_ast_node(a, n->TypeMatchStmt.body); + case AstNode_TypeSwitchStmt: + n->TypeSwitchStmt.label = clone_ast_node(a, n->TypeSwitchStmt.label); + n->TypeSwitchStmt.tag = clone_ast_node(a, n->TypeSwitchStmt.tag); + n->TypeSwitchStmt.body = clone_ast_node(a, n->TypeSwitchStmt.body); break; case AstNode_DeferStmt: n->DeferStmt.stmt = clone_ast_node(a, n->DeferStmt.stmt); @@ -1266,20 +1266,20 @@ AstNode *ast_range_stmt(AstFile *f, Token token, AstNode *value, AstNode *index, } AstNode *ast_match_stmt(AstFile *f, Token token, AstNode *init, AstNode *tag, AstNode *body) { - AstNode *result = make_ast_node(f, AstNode_MatchStmt); - result->MatchStmt.token = token; - result->MatchStmt.init = init; - result->MatchStmt.tag = tag; - result->MatchStmt.body = body; + AstNode *result = make_ast_node(f, AstNode_SwitchStmt); + result->SwitchStmt.token = token; + result->SwitchStmt.init = init; + result->SwitchStmt.tag = tag; + result->SwitchStmt.body = body; return result; } AstNode *ast_type_match_stmt(AstFile *f, Token token, AstNode *tag, AstNode *body) { - AstNode *result = make_ast_node(f, AstNode_TypeMatchStmt); - result->TypeMatchStmt.token = token; - result->TypeMatchStmt.tag = tag; - result->TypeMatchStmt.body = body; + AstNode *result = make_ast_node(f, AstNode_TypeSwitchStmt); + result->TypeSwitchStmt.token = token; + result->TypeSwitchStmt.tag = tag; + result->TypeSwitchStmt.body = body; return result; } @@ -1774,7 +1774,7 @@ void fix_advance_to_next_stmt(AstFile *f) { case Token_for: case Token_when: case Token_return: - case Token_match: + case Token_switch: case Token_defer: case Token_asm: case Token_using: @@ -1823,12 +1823,15 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { } switch (s->kind) { + case AstNode_EmptyStmt: + return true; + case AstNode_IfStmt: case AstNode_WhenStmt: case AstNode_ForStmt: case AstNode_RangeStmt: - case AstNode_MatchStmt: - case AstNode_TypeMatchStmt: + case AstNode_SwitchStmt: + case AstNode_TypeSwitchStmt: return true; case AstNode_PointerType: @@ -1842,6 +1845,11 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { case AstNode_ProcLit: return s->ProcLit.body != nullptr; + case AstNode_ImportDecl: + case AstNode_ExportDecl: + case AstNode_ForeignLibraryDecl: + return true; + case AstNode_ValueDecl: if (s->ValueDecl.is_mutable) { return false; @@ -3176,7 +3184,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { TokenKind next = look_ahead_token_kind(f, 1); switch (next) { case Token_for: - case Token_match: { + case Token_switch: { expect_token_after(f, Token_Colon, "identifier list"); AstNode *name = lhs[0]; AstNode *label = ast_label_decl(f, ast_node_token(name), name); @@ -3185,8 +3193,8 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { switch (stmt->kind) { _SET_LABEL(ForStmt, label); _SET_LABEL(RangeStmt, label); - _SET_LABEL(MatchStmt, label); - _SET_LABEL(TypeMatchStmt, label); + _SET_LABEL(SwitchStmt, label); + _SET_LABEL(TypeSwitchStmt, label); default: syntax_error(token, "Labels can only be applied to a loop or match statement"); break; @@ -4238,7 +4246,7 @@ AstNode *parse_match_stmt(AstFile *f) { return ast_bad_stmt(f, f->curr_token, f->curr_token); } - Token token = expect_token(f, Token_match); + Token token = expect_token(f, Token_switch); AstNode *init = nullptr; AstNode *tag = nullptr; AstNode *body = nullptr; @@ -4366,12 +4374,15 @@ AstNode *parse_import_decl(AstFile *f, bool is_using) { cond = parse_expr(f, false); } - expect_semicolon(f, nullptr); + AstNode *s = nullptr; if (f->curr_proc != nullptr) { syntax_error(import_name, "You cannot use `import` within a procedure. This must be done at the file scope"); - return ast_bad_decl(f, import_name, file_path); + s = ast_bad_decl(f, import_name, file_path); + } else { + s = ast_import_decl(f, token, is_using, file_path, import_name, cond, docs, f->line_comment); } - return ast_import_decl(f, token, is_using, file_path, import_name, cond, docs, f->line_comment); + expect_semicolon(f, s); + return s; } AstNode *parse_export_decl(AstFile *f) { @@ -4383,12 +4394,16 @@ AstNode *parse_export_decl(AstFile *f) { if (allow_token(f, Token_when)) { cond = parse_expr(f, false); } - expect_semicolon(f, nullptr); + + AstNode *s = nullptr; if (f->curr_proc != nullptr) { syntax_error(token, "You cannot use `export` within a procedure. This must be done at the file scope"); - return ast_bad_decl(f, token, file_path); + s = ast_bad_decl(f, token, file_path); + } else { + s = ast_export_decl(f, token, file_path, cond, docs, f->line_comment); } - return ast_export_decl(f, token, file_path, cond, docs, f->line_comment); + expect_semicolon(f, s); + return s; } AstNode *parse_foreign_decl(AstFile *f) { @@ -4425,14 +4440,16 @@ AstNode *parse_foreign_decl(AstFile *f) { cond = parse_expr(f, false); } - expect_semicolon(f, nullptr); + AstNode *s = nullptr; if (f->curr_proc != nullptr) { syntax_error(lib_name, "You cannot use foreign_system_library within a procedure. This must be done at the file scope"); - return ast_bad_decl(f, lib_name, file_path); + s = ast_bad_decl(f, lib_name, file_path); + } else { + s = ast_foreign_library_decl(f, token, file_path, lib_name, cond, docs, f->line_comment); } - - return ast_foreign_library_decl(f, token, file_path, lib_name, cond, docs, f->line_comment); + expect_semicolon(f, s); + return s; } @@ -4478,7 +4495,7 @@ AstNode *parse_stmt(AstFile *f) { case Token_if: return parse_if_stmt(f); case Token_when: return parse_when_stmt(f); case Token_for: return parse_for_stmt(f); - case Token_match: return parse_match_stmt(f); + case Token_switch: return parse_match_stmt(f); case Token_defer: return parse_defer_stmt(f); case Token_asm: return parse_asm_stmt(f); case Token_return: return parse_return_stmt(f); diff --git a/src/ssa.cpp b/src/ssa.cpp index 5bd149d5a..82fbdb22f 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -2138,12 +2138,12 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { GB_PANIC("TODO: RangeStmt"); case_end; - case_ast_node(rs, MatchStmt, node); - GB_PANIC("TODO: MatchStmt"); + case_ast_node(rs, SwitchStmt, node); + GB_PANIC("TODO: SwitchStmt"); case_end; - case_ast_node(rs, TypeMatchStmt, node); - GB_PANIC("TODO: TypeMatchStmt"); + case_ast_node(rs, TypeSwitchStmt, node); + GB_PANIC("TODO: TypeSwitchStmt"); case_end; case_ast_node(bs, BranchStmt, node); @@ -2445,7 +2445,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) { m.entry_point_entity = entry_point; - m.min_dep_map = generate_minimum_dependency_map(info, entry_point); + m.min_dep_map = generate_minimum_dependency_set(info, entry_point); for_array(i, info->entities.entries) { auto *entry = &info->entities.entries[i]; diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index c9926ee45..1560ac857 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -94,7 +94,7 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \ TOKEN_KIND(Token_if, "if"), \ TOKEN_KIND(Token_else, "else"), \ TOKEN_KIND(Token_for, "for"), \ - TOKEN_KIND(Token_match, "match"), \ + TOKEN_KIND(Token_switch, "switch"), \ TOKEN_KIND(Token_in, "in"), \ TOKEN_KIND(Token_do, "do"), \ TOKEN_KIND(Token_case, "case"), \