From f25818e9230b77bbe3a3422c75d1544c9b417fcf Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 15 Jul 2019 21:18:37 +0100 Subject: [PATCH] Make procedure parameters just named values rather than copied variables --- core/decimal/decimal.odin | 34 ++++++++++++------------- core/fmt/fmt.odin | 7 +++--- core/mem/allocators.odin | 21 ++++++++-------- core/mem/raw.odin | 6 ++--- core/runtime/core.odin | 3 ++- core/runtime/internal.odin | 6 +++-- core/strconv/generic_float.odin | 26 ++++++++++--------- core/strconv/strconv.odin | 9 ++++--- core/strings/builder.odin | 22 ++++++++--------- core/strings/strings.odin | 44 +++++++++++++++++++-------------- core/sys/win32/comdlg32.odin | 9 +++---- core/sys/win32/crt.odin | 4 +-- core/sys/win32/general.odin | 6 ++--- core/unicode/utf8/utf8.odin | 4 ++- src/check_expr.cpp | 40 +++++++++++++++++------------- src/check_stmt.cpp | 4 +++ src/check_type.cpp | 14 +---------- src/parser.cpp | 8 ------ src/parser.hpp | 2 -- 19 files changed, 138 insertions(+), 131 deletions(-) diff --git a/core/decimal/decimal.odin b/core/decimal/decimal.odin index 2acf7a03d..97c586635 100644 --- a/core/decimal/decimal.odin +++ b/core/decimal/decimal.odin @@ -20,29 +20,29 @@ decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string { // TODO(bill): make this work with a buffer that's not big enough assert(len(buf) >= n); - buf = buf[0:n]; + b := buf[0:n]; if a.count == 0 { - buf[0] = '0'; - return string(buf[0:1]); + b[0] = '0'; + return string(b[0:1]); } w := 0; if a.decimal_point <= 0 { - buf[w] = '0'; w += 1; - buf[w] = '.'; w += 1; - w += digit_zero(buf[w : w-a.decimal_point]); - w += copy(buf[w:], a.digits[0:a.count]); + b[w] = '0'; w += 1; + b[w] = '.'; w += 1; + w += digit_zero(b[w : w-a.decimal_point]); + w += copy(b[w:], a.digits[0:a.count]); } else if a.decimal_point < a.count { - w += copy(buf[w:], a.digits[0:a.decimal_point]); - buf[w] = '.'; w += 1; - w += copy(buf[w:], a.digits[a.decimal_point : a.count]); + w += copy(b[w:], a.digits[0:a.decimal_point]); + b[w] = '.'; w += 1; + w += copy(b[w:], a.digits[a.decimal_point : a.count]); } else { - w += copy(buf[w:], a.digits[0:a.count]); - w += digit_zero(buf[w : w+a.decimal_point-a.count]); + w += copy(b[w:], a.digits[0:a.count]); + w += digit_zero(b[w : w+a.decimal_point-a.count]); } - return string(buf[0:w]); + return string(b[0:w]); } // trim trailing zeros @@ -56,10 +56,10 @@ trim :: proc(a: ^Decimal) { } -assign :: proc(a: ^Decimal, i: u64) { +assign :: proc(a: ^Decimal, idx: u64) { buf: [64]byte; n := 0; - for i > 0 { + for i := idx; i > 0; { j := i/10; i -= 10*j; buf[n] = byte('0'+i); @@ -175,11 +175,11 @@ shift_left :: proc(a: ^Decimal, k: uint) { trim(a); } -shift :: proc(a: ^Decimal, k: int) { +shift :: proc(a: ^Decimal, i: int) { uint_size :: 8*size_of(uint); max_shift :: uint_size-4; - switch { + switch k := i; { case a.count == 0: // no need to update case k > 0: diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index 1080f9d3d..60b1fdcc1 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -783,7 +783,8 @@ fmt_pointer :: proc(fi: ^Info, p: rawptr, verb: rune) { } } -enum_value_to_string :: proc(v: any) -> (string, bool) { +enum_value_to_string :: proc(val: any) -> (string, bool) { + v := val; v.id = runtime.typeid_base(v.id); type_info := type_info_of(v.id); @@ -890,8 +891,8 @@ fmt_bit_set :: proc(fi: ^Info, v: any, name: string = "") { if ti == nil { return false; } - ti = runtime.type_info_base(ti); - switch info in ti.variant { + t := runtime.type_info_base(ti); + switch info in t.variant { case runtime.Type_Info_Integer: switch info.endianness { case .Platform: return false; diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 77cc0abf1..04b0fd0b1 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -377,7 +377,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return nil; } - alignment = clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2); + align := clamp(alignment, 1, 8*size_of(Stack_Allocation_Header{}.padding)/2); raw_alloc :: proc(s: ^Small_Stack, size, alignment: int) -> rawptr { curr_addr := uintptr(&s.data[0]) + uintptr(s.offset); @@ -400,7 +400,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, switch mode { case .Alloc: - return raw_alloc(s, size, alignment); + return raw_alloc(s, size, align); case .Free: if old_memory == nil { return nil; @@ -429,7 +429,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, case .Resize: if old_memory == nil { - return raw_alloc(s, size, alignment); + return raw_alloc(s, size, align); } if size == 0 { return nil; @@ -452,7 +452,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, return old_memory; } - ptr := raw_alloc(s, size, alignment); + ptr := raw_alloc(s, size, align); copy(ptr, old_memory, min(old_size, size)); return ptr; } @@ -568,9 +568,10 @@ dynamic_pool_alloc :: proc(using pool: ^Dynamic_Pool, bytes: int) -> rawptr { } - extra := alignment - (bytes % alignment); - bytes += extra; - if bytes >= out_band_size { + n := bytes; + extra := alignment - (n % alignment); + n += extra; + if n >= out_band_size { assert(block_allocator.procedure != nil); memory := block_allocator.procedure(block_allocator.data, Allocator_Mode.Alloc, block_size, alignment, @@ -581,7 +582,7 @@ dynamic_pool_alloc :: proc(using pool: ^Dynamic_Pool, bytes: int) -> rawptr { return memory; } - if bytes_left < bytes { + if bytes_left < n { cycle_new_block(pool); if current_block == nil { return nil; @@ -589,8 +590,8 @@ dynamic_pool_alloc :: proc(using pool: ^Dynamic_Pool, bytes: int) -> rawptr { } memory := current_pos; - current_pos = ptr_offset((^byte)(current_pos), bytes); - bytes_left -= bytes; + current_pos = ptr_offset((^byte)(current_pos), n); + bytes_left -= n; return memory; } diff --git a/core/mem/raw.odin b/core/mem/raw.odin index 5f22f4b3c..c7f4ee9db 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -37,13 +37,13 @@ make_any :: inline proc(data: rawptr, id: typeid) -> any { } raw_string_data :: inline proc(s: $T/string) -> ^byte { - return (^Raw_String)(&s).data; + return (transmute(Raw_String)s).data; } raw_slice_data :: inline proc(a: $T/[]$E) -> ^E { - return cast(^E)(^Raw_Slice)(&a).data; + return cast(^E)(transmute(Raw_Slice)a).data; } raw_dynamic_array_data :: inline proc(a: $T/[dynamic]$E) -> ^E { - return cast(^E)(^Raw_Dynamic_Array)(&a).data; + return cast(^E)(transmute(Raw_Dynamic_Array)a).data; } raw_data :: proc{raw_string_data, raw_slice_data, raw_dynamic_array_data}; diff --git a/core/runtime/core.odin b/core/runtime/core.odin index 9ebdc17fa..2203e7179 100644 --- a/core/runtime/core.odin +++ b/core/runtime/core.odin @@ -501,7 +501,8 @@ append_elem :: proc(array: ^$T/[dynamic]$E, arg: E, loc := #caller_location) { a := (^mem.Raw_Dynamic_Array)(array); data := (^E)(a.data); assert(data != nil); - mem.copy(mem.ptr_offset(data, a.len), &arg, size_of(E)); + val := arg; + mem.copy(mem.ptr_offset(data, a.len), &val, size_of(E)); a.len += arg_len; } } diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin index d3ef1f94d..d4d7ab84d 100644 --- a/core/runtime/internal.odin +++ b/core/runtime/internal.odin @@ -5,12 +5,13 @@ import "core:os" import "core:unicode/utf8" -print_u64 :: proc(fd: os.Handle, u: u64) { +print_u64 :: proc(fd: os.Handle, x: u64) { digits := "0123456789"; a: [129]byte; i := len(a); b := u64(10); + u := x; for u >= b { i -= 1; a[i] = digits[u % b]; u /= b; @@ -20,10 +21,11 @@ print_u64 :: proc(fd: os.Handle, u: u64) { os.write(fd, a[i:]); } -print_i64 :: proc(fd: os.Handle, u: i64) { +print_i64 :: proc(fd: os.Handle, x: i64) { digits := "0123456789"; b :: i64(10); + u := x; neg := u < 0; u = abs(u); diff --git a/core/strconv/generic_float.odin b/core/strconv/generic_float.odin index 5ce794d3d..f0e43bcc9 100644 --- a/core/strconv/generic_float.odin +++ b/core/strconv/generic_float.odin @@ -28,7 +28,7 @@ _f32_info := Float_Info{23, 8, -127}; _f64_info := Float_Info{52, 11, -1023}; -generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> []byte { +generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, precision, bit_size: int) -> []byte { bits: u64; flt: ^Float_Info; switch bit_size { @@ -73,6 +73,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [ assign(d, mant); shift(d, exp - int(flt.mantbits)); digs: Decimal_Slice; + prec := precision; shortest := prec < 0; if shortest { round_shortest(d, mant, exp, flt); @@ -100,7 +101,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [ -format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slice, prec: int, fmt: byte) -> []byte { +format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slice, precision: int, fmt: byte) -> []byte { Buffer :: struct { b: []byte, n: int, @@ -112,6 +113,7 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic } b := Buffer{b = buf}; + prec := precision; switch fmt { case 'f', 'F': @@ -289,7 +291,8 @@ MAX_BASE :: 32; digits := "0123456789abcdefghijklmnopqrstuvwxyz"; -is_integer_negative :: proc(u: u64, is_signed: bool, bit_size: int) -> (unsigned: u64, neg: bool) { +is_integer_negative :: proc(x: u64, is_signed: bool, bit_size: int) -> (u: u64, neg: bool) { + u = x; if is_signed { switch bit_size { case 8: @@ -312,18 +315,17 @@ is_integer_negative :: proc(u: u64, is_signed: bool, bit_size: int) -> (unsigned panic("is_integer_negative: Unknown integer size"); } } - return u, neg; + return; } -append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flags) -> string { +append_bits :: proc(buf: []byte, x: u64, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flags) -> string { if base < 2 || base > MAX_BASE { panic("strconv: illegal base passed to append_bits"); } - neg: bool; a: [129]byte; i := len(a); - u, neg = is_integer_negative(u, is_signed, bit_size); + u, neg := is_integer_negative(x, is_signed, bit_size); b := u64(base); for u >= b { i-=1; a[i] = digits[u % b]; @@ -360,7 +362,8 @@ append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: i return string(buf[0:len(out)]); } -is_integer_negative_128 :: proc(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) { +is_integer_negative_128 :: proc(x: u128, is_signed: bool, bit_size: int) -> (u: u128, neg: bool) { + u = x; if is_signed { switch bit_size { case 8: @@ -387,19 +390,18 @@ is_integer_negative_128 :: proc(u: u128, is_signed: bool, bit_size: int) -> (uns panic("is_integer_negative: Unknown integer size"); } } - return u, neg; + return; } -append_bits_128 :: proc(buf: []byte, u: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flags) -> string { +append_bits_128 :: proc(buf: []byte, x: u128, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flags) -> string { if base < 2 || base > MAX_BASE { panic("strconv: illegal base passed to append_bits"); } - neg: bool; a: [140]byte; i := len(a); - u, neg = is_integer_negative_128(u, is_signed, bit_size); + u, neg := is_integer_negative_128(x, is_signed, bit_size); b := u128(base); for u >= b { i-=1; a[i] = digits[u % b]; diff --git a/core/strconv/strconv.odin b/core/strconv/strconv.odin index dd1eea0cb..ac78f78dc 100644 --- a/core/strconv/strconv.odin +++ b/core/strconv/strconv.odin @@ -23,7 +23,8 @@ _digit_value :: proc(r: rune) -> int { return v; } -parse_i64 :: proc(s: string) -> i64 { +parse_i64 :: proc(str: string) -> i64 { + s := str; neg := false; if len(s) > 1 { switch s[0] { @@ -66,7 +67,8 @@ parse_i64 :: proc(s: string) -> i64 { return value; } -parse_u64 :: proc(s: string) -> u64 { +parse_u64 :: proc(str: string) -> u64 { + s := str; neg := false; if len(s) > 1 && s[0] == '+' { s = s[1:]; @@ -209,7 +211,7 @@ append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> str } -quote :: proc(buf: []byte, s: string) -> string { +quote :: proc(buf: []byte, str: string) -> string { write_byte :: inline proc(buf: []byte, i: ^int, bytes: ..byte) { if i^ >= len(buf) do return; n := copy(buf[i^:], bytes[:]); @@ -222,6 +224,7 @@ quote :: proc(buf: []byte, s: string) -> string { c :: '"'; i := 0; + s := str; write_byte(buf, &i, c); for width := 0; len(s) > 0; s = s[width:] { diff --git a/core/strings/builder.odin b/core/strings/builder.odin index 7b528c750..68f1a7ceb 100644 --- a/core/strings/builder.odin +++ b/core/strings/builder.odin @@ -68,9 +68,9 @@ write_bytes :: proc(b: ^Builder, x: []byte) { @(private, static) DIGITS_LOWER := "0123456789abcdefx"; -write_quoted_string :: proc(b: ^Builder, s: string, quote: byte = '"') { +write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') { write_byte(b, quote); - for width := 0; len(s) > 0; s = s[width:] { + for width, s := 0, str; len(s) > 0; s = s[width:] { r := rune(s[0]); width = 1; if r >= utf8.RUNE_SELF { @@ -166,27 +166,27 @@ write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false case '\t': write_string(b, `\t`); case '\v': write_string(b, `\v`); case: - switch { - case r < ' ': + switch c := r; { + case c < ' ': write_byte(b, '\\'); write_byte(b, 'x'); - write_byte(b, DIGITS_LOWER[byte(r)>>4]); - write_byte(b, DIGITS_LOWER[byte(r)&0xf]); + write_byte(b, DIGITS_LOWER[byte(c)>>4]); + write_byte(b, DIGITS_LOWER[byte(c)&0xf]); - case r > utf8.MAX_RUNE: - r = 0xfffd; + case c > utf8.MAX_RUNE: + c = 0xfffd; fallthrough; - case r < 0x10000: + case c < 0x10000: write_byte(b, '\\'); write_byte(b, 'u'); for s := 12; s >= 0; s -= 4 { - write_byte(b, DIGITS_LOWER[r>>uint(s) & 0xf]); + write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]); } case: write_byte(b, '\\'); write_byte(b, 'U'); for s := 28; s >= 0; s -= 4 { - write_byte(b, DIGITS_LOWER[r>>uint(s) & 0xf]); + write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]); } } } diff --git a/core/strings/strings.odin b/core/strings/strings.odin index df3d69732..8f9db86be 100644 --- a/core/strings/strings.odin +++ b/core/strings/strings.odin @@ -67,7 +67,8 @@ rune_count :: proc(s: string) -> int { } -equal_fold :: proc(s, t: string) -> bool { +equal_fold :: proc(u, v: string) -> bool { + s, t := u, v; loop: for s != "" && t != "" { sr, tr: rune; if s[0] < utf8.RUNE_SELF { @@ -250,13 +251,14 @@ count :: proc(s, substr: string) -> int { // TODO(bill): Use a non-brute for approach n := 0; + str := s; for { - i := index(s, substr); + i := index(str, substr); if i == -1 { return n; } n += 1; - s = s[i+len(substr):]; + str = str[i+len(substr):]; } return n; } @@ -289,22 +291,22 @@ replace :: proc(s, old, new: string, n: int, allocator := context.allocator) -> output = s; return; } - + byte_count := n; if m := count(s, old); m == 0 { was_allocation = false; output = s; return; } else if n < 0 || m < n { - n = m; + byte_count = m; } - t := make([]byte, len(s) + n*(len(new) - len(old)), allocator); + t := make([]byte, len(s) + byte_count*(len(new) - len(old)), allocator); was_allocation = true; w := 0; start := 0; - for i := 0; i < n; i += 1 { + for i := 0; i < byte_count; i += 1 { j := start; if len(old) == 0 { if i > 0 { @@ -475,14 +477,16 @@ trim_left :: proc(s: string, cutset: string) -> string { if s == "" || cutset == "" { return s; } - return trim_left_proc_with_state(s, is_in_cutset, &cutset); + state := cutset; + return trim_left_proc_with_state(s, is_in_cutset, &state); } trim_right :: proc(s: string, cutset: string) -> string { if s == "" || cutset == "" { return s; } - return trim_right_proc_with_state(s, is_in_cutset, &cutset); + state := cutset; + return trim_right_proc_with_state(s, is_in_cutset, &state); } trim :: proc(s: string, cutset: string) -> string { @@ -515,7 +519,8 @@ trim_null :: proc(s: string) -> string { // scrub scruvs invalid utf-8 characters and replaces them with the replacement string // Adjacent invalid bytes are only replaced once -scrub :: proc(str: string, replacement: string, allocator := context.allocator) -> string { +scrub :: proc(s: string, replacement: string, allocator := context.allocator) -> string { + str := s; b := make_builder(allocator);; grow_builder(&b, len(str)); @@ -547,7 +552,8 @@ scrub :: proc(str: string, replacement: string, allocator := context.allocator) } -reverse :: proc(str: string, allocator := context.allocator) -> string { +reverse :: proc(s: string, allocator := context.allocator) -> string { + str := s; n := len(str); buf := make([]byte, n); i := 0; @@ -560,17 +566,18 @@ reverse :: proc(str: string, allocator := context.allocator) -> string { return string(buf); } -expand_tabs :: proc(str: string, tab_size: int, allocator := context.allocator) -> string { +expand_tabs :: proc(s: string, tab_size: int, allocator := context.allocator) -> string { if tab_size <= 0 { panic("tab size must be positive"); } - if str == "" { + + if s == "" { return ""; } b := make_builder(allocator); - + str := s; column: int; for len(str) > 0 { @@ -683,11 +690,12 @@ write_pad_string :: proc(b: ^Builder, pad: string, pad_len, remains: int) { write_string(b, pad); } - remains = remains % pad_len; + n := remains % pad_len; + p := pad; - if remains != 0 do for i := 0; i < remains; i += 1 { - r, w := utf8.decode_rune_in_string(pad); + for i := 0; i < n; i += 1 { + r, w := utf8.decode_rune_in_string(p); write_rune(b, r); - pad = pad[w:]; + p = p[w:]; } } diff --git a/core/sys/win32/comdlg32.odin b/core/sys/win32/comdlg32.odin index 3d9fb74c4..5238806a7 100644 --- a/core/sys/win32/comdlg32.odin +++ b/core/sys/win32/comdlg32.odin @@ -89,7 +89,6 @@ _open_file_dialog :: proc(title: string, dir: string, // Filters need to be passed as a pair of strings (title, filter) filter_len := u32(len(filters)); if filter_len % 2 != 0 do return "", false; - default_filter = clamp(default_filter, 1, filter_len / 2); filter: string; filter = strings.join(filters, "\u0000", context.temp_allocator); @@ -102,7 +101,7 @@ _open_file_dialog :: proc(title: string, dir: string, title = utf8_to_wstring(title, context.temp_allocator), filter = utf8_to_wstring(filter, context.temp_allocator), initial_dir = utf8_to_wstring(dir, context.temp_allocator), - filter_index = u32(default_filter), + filter_index = u32(clamp(default_filter, 1, filter_len / 2)), def_ext = utf8_to_wstring(default_ext, context.temp_allocator), flags = u32(flags), }; @@ -121,7 +120,7 @@ _open_file_dialog :: proc(title: string, dir: string, return "", false; } - file_name := ucs2_to_utf8(file_buf[:], allocator); + file_name := utf16_to_utf8(file_buf[:], allocator); path = strings.trim_right_null(file_name); return; } @@ -143,7 +142,7 @@ select_file_to_save :: proc(title := SAVE_TITLE, dir := ".", return; } -// TODO: Implement convenience function for select_file_to_open with ALLOW_MULTI_SELECT that takes +// TODO: Implement convenience function for select_file_to_open with ALLOW_MULTI_SELECT that takes // it output of the form "path\u0000\file1u\0000file2" and turns it into []string with the path + file pre-concatenated for you. OFN_ALLOWMULTISELECT :: 0x00000200; // NOTE(Jeroen): Without OFN_EXPLORER it uses the Win3 dialog. @@ -186,4 +185,4 @@ CDERR_LOCKRESFAILURE :: 0x00000008; CDERR_MEMALLOCFAILURE :: 0x00000009; CDERR_MEMLOCKFAILURE :: 0x0000000A; CDERR_NOHOOK :: 0x0000000B; -CDERR_REGISTERMSGFAIL :: 0x0000000C; \ No newline at end of file +CDERR_REGISTERMSGFAIL :: 0x0000000C; diff --git a/core/sys/win32/crt.odin b/core/sys/win32/crt.odin index 46fba6fe8..d89f1cf96 100644 --- a/core/sys/win32/crt.odin +++ b/core/sys/win32/crt.odin @@ -9,6 +9,6 @@ foreign { get_cwd :: proc(allocator := context.temp_allocator) -> string { buffer := make([]u16, MAX_PATH_WIDE, allocator); _get_cwd_wide(Wstring(&buffer[0]), MAX_PATH_WIDE); - file := ucs2_to_utf8(buffer[:], allocator); + file := utf16_to_utf8(buffer[:], allocator); return strings.trim_right_null(file); -} \ No newline at end of file +} diff --git a/core/sys/win32/general.odin b/core/sys/win32/general.odin index f4f3de380..16241de05 100644 --- a/core/sys/win32/general.odin +++ b/core/sys/win32/general.odin @@ -728,7 +728,7 @@ CP_UTF8 :: 65001; // UTF-8 translation MB_ERR_INVALID_CHARS :: 8; WC_ERR_INVALID_CHARS :: 128; -utf8_to_ucs2 :: proc(s: string, allocator := context.temp_allocator) -> []u16 { +utf8_to_utf16 :: proc(s: string, allocator := context.temp_allocator) -> []u16 { if len(s) < 1 { return nil; } @@ -751,13 +751,13 @@ utf8_to_ucs2 :: proc(s: string, allocator := context.temp_allocator) -> []u16 { return text[:len(text)-1]; } utf8_to_wstring :: proc(s: string, allocator := context.temp_allocator) -> Wstring { - if res := utf8_to_ucs2(s, allocator); res != nil { + if res := utf8_to_utf16(s, allocator); res != nil { return Wstring(&res[0]); } return nil; } -ucs2_to_utf8 :: proc(s: []u16, allocator := context.temp_allocator) -> string { +utf16_to_utf8 :: proc(s: []u16, allocator := context.temp_allocator) -> string { if len(s) < 1 { return ""; } diff --git a/core/unicode/utf8/utf8.odin b/core/unicode/utf8/utf8.odin index d0396b9e0..33cb48e1c 100644 --- a/core/unicode/utf8/utf8.odin +++ b/core/unicode/utf8/utf8.odin @@ -60,7 +60,9 @@ accept_sizes := [256]u8{ 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff }; -encode_rune :: proc(r: rune) -> ([4]u8, int) { +encode_rune :: proc(c: rune) -> ([4]u8, int) { + r := c; + buf: [4]u8; i := u32(r); mask :: u8(0x3f); diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 4c2133f4c..6845c167d 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -1533,8 +1533,14 @@ void check_unary_expr(CheckerContext *c, Operand *o, Token op, Ast *node) { if (ast_node_expect(node, Ast_UnaryExpr)) { ast_node(ue, UnaryExpr, node); gbString str = expr_to_string(ue->expr); - error(op, "Cannot take the pointer address of '%s'", str); - gb_string_free(str); + defer (gb_string_free(str)); + + Entity *e = entity_of_ident(o->expr); + if (e != nullptr && (e->flags & EntityFlag_Param) != 0) { + error(op, "Cannot take the pointer address of '%s' which is a procedure parameter", str); + } else { + error(op, "Cannot take the pointer address of '%s'", str); + } } o->mode = Addressing_Invalid; return; @@ -5909,17 +5915,6 @@ void check_expr_with_type_hint(CheckerContext *c, Operand *o, Ast *e, Type *t) { } } -void check_set_mode_with_indirection(Operand *o, bool indirection) { - if (o->mode != Addressing_Immutable) { - if (indirection) { - o->mode = Addressing_Variable; - } else if (o->mode != Addressing_Variable && - o->mode != Addressing_Constant) { - o->mode = Addressing_Value; - } - } -} - bool check_set_index_data(Operand *o, Type *t, bool indirection, i64 *max_count) { switch (t->kind) { case Type_Basic: @@ -5927,7 +5922,9 @@ bool check_set_index_data(Operand *o, Type *t, bool indirection, i64 *max_count) if (o->mode == Addressing_Constant) { *max_count = o->value.value_string.len; } - check_set_mode_with_indirection(o, indirection); + if (o->mode != Addressing_Immutable && o->mode != Addressing_Constant) { + o->mode = Addressing_Variable; + } o->type = t_u8; return true; } @@ -5935,20 +5932,29 @@ bool check_set_index_data(Operand *o, Type *t, bool indirection, i64 *max_count) case Type_Array: *max_count = t->Array.count; - check_set_mode_with_indirection(o, indirection); + if (o->mode != Addressing_Immutable) { + if (indirection) { + o->mode = Addressing_Variable; + } else if (o->mode != Addressing_Variable && + o->mode != Addressing_Constant) { + o->mode = Addressing_Value; + } + } o->type = t->Array.elem; return true; case Type_Slice: o->type = t->Slice.elem; - if (o->mode != Addressing_Immutable) { + if (o->mode != Addressing_Immutable && o->mode != Addressing_Constant) { o->mode = Addressing_Variable; } return true; case Type_DynamicArray: o->type = t->DynamicArray.elem; - check_set_mode_with_indirection(o, indirection); + if (o->mode != Addressing_Immutable && o->mode != Addressing_Constant) { + o->mode = Addressing_Variable; + } return true; } diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 24f540930..e2090688f 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -303,9 +303,13 @@ Type *check_assignment_variable(CheckerContext *ctx, Operand *lhs, Operand *rhs) } } + Entity *e = entity_of_ident(lhs->expr); + gbString str = expr_to_string(lhs->expr); if (lhs->mode == Addressing_Immutable) { error(lhs->expr, "Cannot assign to an immutable: '%s'", str); + } else if (e != nullptr && e->flags & EntityFlag_Param) { + error(lhs->expr, "Cannot assign to '%s' which is a procedure parameter", str); } else { error(lhs->expr, "Cannot assign to '%s'", str); } diff --git a/src/check_type.cpp b/src/check_type.cpp index df3c554dd..f4e5b49d0 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -1519,18 +1519,6 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is } } - if (p->flags&FieldFlag_in) { - if (is_type_param) { - error(param, "'in' cannot be applied to a type parameter"); - p->flags &= ~FieldFlag_in; - } else if (is_variadic) { - error(param, "'in' cannot be applied to a variadic parameter"); - p->flags &= ~FieldFlag_in; - } - } - - bool is_in = (p->flags&FieldFlag_in) != 0; - for_array(j, p->names) { Ast *name = p->names[j]; @@ -1670,7 +1658,7 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is param = alloc_entity_const_param(scope, name->Ident.token, type, poly_const, is_type_polymorphic(type)); } else { - param = alloc_entity_param(scope, name->Ident.token, type, is_using, is_in); + param = alloc_entity_param(scope, name->Ident.token, type, is_using, true); param->Variable.param_value = param_value; } } diff --git a/src/parser.cpp b/src/parser.cpp index d2e64f23c..a377b773c 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2854,7 +2854,6 @@ enum FieldPrefixKind { FieldPrefix_no_alias, FieldPrefix_c_var_arg, FieldPrefix_auto_cast, - FieldPrefix_in, }; FieldPrefixKind is_token_field_prefix(AstFile *f) { @@ -2865,9 +2864,6 @@ FieldPrefixKind is_token_field_prefix(AstFile *f) { case Token_using: return FieldPrefix_using; - case Token_in: - return FieldPrefix_in; - case Token_auto_cast: return FieldPrefix_auto_cast; @@ -2892,7 +2888,6 @@ u32 parse_field_prefixes(AstFile *f) { i32 using_count = 0; i32 no_alias_count = 0; i32 c_vararg_count = 0; - i32 in_count = 0; i32 auto_cast_count = 0; for (;;) { @@ -2910,14 +2905,12 @@ u32 parse_field_prefixes(AstFile *f) { case FieldPrefix_using: using_count += 1; advance_token(f); break; case FieldPrefix_no_alias: no_alias_count += 1; advance_token(f); break; case FieldPrefix_c_var_arg: c_vararg_count += 1; advance_token(f); break; - case FieldPrefix_in: in_count += 1; advance_token(f); break; case FieldPrefix_auto_cast: auto_cast_count += 1; advance_token(f); break; } } if (using_count > 1) syntax_error(f->curr_token, "Multiple 'using' in this field list"); if (no_alias_count > 1) syntax_error(f->curr_token, "Multiple '#no_alias' in this field list"); if (c_vararg_count > 1) syntax_error(f->curr_token, "Multiple '#c_vararg' in this field list"); - if (in_count > 1) syntax_error(f->curr_token, "Multiple 'in' in this field list"); if (auto_cast_count > 1) syntax_error(f->curr_token, "Multiple 'auto_cast' in this field list"); @@ -2925,7 +2918,6 @@ u32 parse_field_prefixes(AstFile *f) { if (using_count > 0) field_flags |= FieldFlag_using; if (no_alias_count > 0) field_flags |= FieldFlag_no_alias; if (c_vararg_count > 0) field_flags |= FieldFlag_c_vararg; - if (in_count > 0) field_flags |= FieldFlag_in; if (auto_cast_count > 0) field_flags |= FieldFlag_auto_cast; return field_flags; } diff --git a/src/parser.hpp b/src/parser.hpp index a6c9d190b..9f4f68a7b 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -186,8 +186,6 @@ enum FieldFlag { FieldFlag_c_vararg = 1<<3, FieldFlag_auto_cast = 1<<4, - FieldFlag_in = 1<<5, - FieldFlag_Results = 1<<16,