From 57e6138a615f28292d0ad95fa6ebf26789f0b961 Mon Sep 17 00:00:00 2001 From: Alexander Medvednikov Date: Sun, 4 Apr 2021 17:43:32 +0300 Subject: [PATCH] all: remove byteptr and charptr; replace them with &byte and &char --- examples/wkhtmltopdf.v | 2 +- vlib/builtin/builtin.c.v | 18 +-- vlib/builtin/builtin_nix.c.v | 4 +- vlib/builtin/builtin_windows.c.v | 2 +- vlib/builtin/cfns.c.v | 62 +++++----- vlib/builtin/js/string.v | 2 +- vlib/builtin/map.v | 20 ++-- vlib/builtin/string.v | 67 +++++------ vlib/builtin/string_test.v | 4 +- vlib/builtin/utf8.c.v | 6 +- vlib/dl/dl_nix.c.v | 4 +- vlib/json/json_primitives.v | 4 +- vlib/net/address.v | 2 +- vlib/net/tcp.v | 8 +- vlib/os/environment.c.v | 22 ++-- vlib/os/file.c.v | 4 +- vlib/os/inode.c.v | 2 +- vlib/os/os_c.v | 108 +++++++++--------- vlib/os/os_nix.c.v | 16 +-- vlib/os/os_test.v | 2 +- vlib/strings/builder.v | 6 +- vlib/szip/szip.v | 2 +- vlib/time/parse.v | 12 +- vlib/v/ast/table.v | 1 + vlib/v/ast/types.v | 58 ++++++---- vlib/v/checker/check_types.v | 6 +- vlib/v/checker/checker.v | 14 ++- vlib/v/checker/tests/fixed_array_conv.out | 6 +- .../tests/fn_headers_with_no_bodies_keep.vv | 4 +- vlib/v/fmt/tests/fn_with_anon_params_keep.vv | 2 +- vlib/v/gen/x64/gen.v | 2 +- vlib/v/util/util.v | 4 +- 32 files changed, 250 insertions(+), 226 deletions(-) diff --git a/examples/wkhtmltopdf.v b/examples/wkhtmltopdf.v index 2d99e9c09c..b5734f648c 100644 --- a/examples/wkhtmltopdf.v +++ b/examples/wkhtmltopdf.v @@ -71,7 +71,7 @@ fn main() { error_code := C.wkhtmltopdf_http_error_code(converter) println('wkhtmltopdf_http_error_code: $error_code') if result { - data := &charptr(0) + data := &&char(0) size := C.wkhtmltopdf_get_output(converter, data) println('wkhtmltopdf_get_output: $size bytes') mut file := os.open_file('./google.pdf', 'w+', 0o666) or { diff --git a/vlib/builtin/builtin.c.v b/vlib/builtin/builtin.c.v index 8813380364..9291633285 100644 --- a/vlib/builtin/builtin.c.v +++ b/vlib/builtin/builtin.c.v @@ -166,7 +166,7 @@ pub fn println(s string) { // malloc returns a `byteptr` pointing to the memory address of the allocated space. // unlike the `calloc` family of functions - malloc will not zero the memory block. [unsafe] -pub fn malloc(n int) byteptr { +pub fn malloc(n int) &byte { if n <= 0 { panic('> V malloc(<=0)') } @@ -180,7 +180,7 @@ pub fn malloc(n int) byteptr { C.fprintf(C.stderr, c'v_malloc %6d total %10d\n', n, total_m) // print_backtrace() } - mut res := byteptr(0) + mut res := &byte(0) $if prealloc { res = g_m2_ptr unsafe { @@ -216,8 +216,8 @@ fn malloc_size(b byteptr) int // previously allocated with `malloc`, `v_calloc` or `vcalloc`. // Please, see also realloc_data, and use it instead if possible. [unsafe] -pub fn v_realloc(b byteptr, n int) byteptr { - mut new_ptr := byteptr(0) +pub fn v_realloc(b &byte, n int) &byte { + mut new_ptr := &byte(0) $if prealloc { unsafe { new_ptr = malloc(n) @@ -245,7 +245,7 @@ pub fn v_realloc(b byteptr, n int) byteptr { // can make debugging easier, when you compile your program with // `-d debug_realloc`. [unsafe] -pub fn realloc_data(old_data byteptr, old_size int, new_size int) byteptr { +pub fn realloc_data(old_data &byte, old_size int, new_size int) &byte { $if prealloc { unsafe { new_ptr := malloc(new_size) @@ -272,7 +272,7 @@ pub fn realloc_data(old_data byteptr, old_size int, new_size int) byteptr { return new_ptr } } - mut nptr := byteptr(0) + mut nptr := &byte(0) $if gcboehm ? { nptr = unsafe { C.GC_REALLOC(old_data, new_size) } } $else { @@ -287,14 +287,14 @@ pub fn realloc_data(old_data byteptr, old_size int, new_size int) byteptr { // vcalloc dynamically allocates a zeroed `n` bytes block of memory on the heap. // vcalloc returns a `byteptr` pointing to the memory address of the allocated space. // Unlike `v_calloc` vcalloc checks for negative values given in `n`. -pub fn vcalloc(n int) byteptr { +pub fn vcalloc(n int) &byte { if n < 0 { panic('calloc(<=0)') } else if n == 0 { - return byteptr(0) + return &byte(0) } $if gcboehm ? { - return byteptr(C.GC_MALLOC(n)) + return &byte(C.GC_MALLOC(n)) } $else { return C.calloc(1, n) } diff --git a/vlib/builtin/builtin_nix.c.v b/vlib/builtin/builtin_nix.c.v index 4d682812fa..aa22fc83ff 100644 --- a/vlib/builtin/builtin_nix.c.v +++ b/vlib/builtin/builtin_nix.c.v @@ -108,7 +108,7 @@ fn print_backtrace_skipping_top_frames_linux(skipframes int) bool { beforeaddr := sframe.all_before('[') cmd := 'addr2line -e $executable $addr' // taken from os, to avoid depending on the os module inside builtin.v - f := C.popen(charptr(cmd.str), 'r') + f := C.popen(&char(cmd.str), c'r') if isnil(f) { eprintln(sframe) continue @@ -117,7 +117,7 @@ fn print_backtrace_skipping_top_frames_linux(skipframes int) bool { mut output := '' unsafe { bp := &buf[0] - for C.fgets(charptr(bp), 1000, f) != 0 { + for C.fgets(&char(bp), 1000, f) != 0 { output += tos(bp, vstrlen(bp)) } } diff --git a/vlib/builtin/builtin_windows.c.v b/vlib/builtin/builtin_windows.c.v index 4a6986a796..0a2260877f 100644 --- a/vlib/builtin/builtin_windows.c.v +++ b/vlib/builtin/builtin_windows.c.v @@ -114,7 +114,7 @@ fn print_backtrace_skipping_top_frames_msvc(skipframes int) bool { mut si := &sic.syminfo si.f_size_of_struct = sizeof(SymbolInfo) // Note: C.SYMBOL_INFO is 88 si.f_max_name_len = sizeof(SymbolInfoContainer) - sizeof(SymbolInfo) - 1 - fname := charptr(&si.f_name) + fname := &char(&si.f_name) mut sline64 := Line64{} sline64.f_size_of_struct = sizeof(Line64) diff --git a/vlib/builtin/cfns.c.v b/vlib/builtin/cfns.c.v index 11cc4ba118..d209fab9da 100644 --- a/vlib/builtin/cfns.c.v +++ b/vlib/builtin/cfns.c.v @@ -23,7 +23,7 @@ fn C.qsort(base voidptr, items size_t, item_size size_t, cb qsort_callback_func) fn C.sprintf(a ...voidptr) int -fn C.strlen(s charptr) int +fn C.strlen(s &char) int fn C.sscanf(byteptr, byteptr, ...byteptr) int @@ -31,19 +31,19 @@ fn C.sscanf(byteptr, byteptr, ...byteptr) int fn C.isdigit(c int) bool // stdio.h -fn C.popen(c charptr, t charptr) voidptr +fn C.popen(c &char, t &char) voidptr // fn C.backtrace(a &voidptr, size int) int -fn C.backtrace_symbols(a &voidptr, size int) &charptr +fn C.backtrace_symbols(a &voidptr, size int) &&char fn C.backtrace_symbols_fd(a &voidptr, size int, fd int) // pub fn proc_pidpath(int, voidptr, int) int -fn C.realpath(charptr, charptr) &char +fn C.realpath(&char, &char) &char // fn C.chmod(byteptr, mode_t) int fn C.chmod(byteptr, u32) int @@ -59,7 +59,7 @@ fn C.fflush(&C.FILE) int // TODO define args in these functions fn C.fseek(stream &C.FILE, offset int, whence int) int -fn C.fopen(filename charptr, mode charptr) &C.FILE +fn C.fopen(filename &char, mode &char) &C.FILE fn C.fileno(&C.FILE) int @@ -75,13 +75,13 @@ fn C.pclose(stream &C.FILE) int [trusted] fn C.getpid() int -fn C.system(cmd charptr) int +fn C.system(cmd &char) int -fn C.posix_spawn(child_pid &int, path charptr, file_actions voidptr, attrp voidptr, argv &charptr, envp &charptr) int +fn C.posix_spawn(child_pid &int, path &char, file_actions voidptr, attrp voidptr, argv &&char, envp &&char) int -fn C.posix_spawnp(child_pid &int, exefile charptr, file_actions voidptr, attrp voidptr, argv &charptr, envp &charptr) int +fn C.posix_spawnp(child_pid &int, exefile &char, file_actions voidptr, attrp voidptr, argv &&char, envp &&char) int -fn C.execve(cmd_path charptr, args voidptr, envs voidptr) int +fn C.execve(cmd_path &char, args voidptr, envs voidptr) int fn C.execvp(cmd_path charptr, args &charptr) int @@ -99,34 +99,34 @@ fn C.waitpid(pid int, status &int, options int) int [trusted] fn C.kill(pid int, sig int) int -fn C.setenv(charptr, charptr, int) int +fn C.setenv(&char, &char, int) int -fn C.unsetenv(charptr) int +fn C.unsetenv(&char) int -fn C.access(path charptr, amode int) int +fn C.access(path &char, amode int) int -fn C.remove(filename charptr) int +fn C.remove(filename &char) int -fn C.rmdir(path charptr) int +fn C.rmdir(path &char) int -fn C.chdir(path charptr) int +fn C.chdir(path &char) int fn C.rewind(stream &C.FILE) int -fn C.stat(charptr, voidptr) int +fn C.stat(&char, voidptr) int -fn C.lstat(path charptr, buf &C.stat) int +fn C.lstat(path &char, buf &C.stat) int -fn C.rename(old_filename charptr, new_filename charptr) int +fn C.rename(old_filename &char, new_filename &char) int -fn C.fgets(str charptr, n int, stream &C.FILE) int +fn C.fgets(str &char, n int, stream &C.FILE) int fn C.memset(str voidptr, c int, n size_t) int [trusted] fn C.sigemptyset() int -fn C.getcwd(buf charptr, size size_t) charptr +fn C.getcwd(buf &char, size size_t) &char fn C.signal(signal int, handlercb voidptr) voidptr @@ -142,12 +142,12 @@ fn C.sleep(seconds u32) u32 [trusted] fn C.usleep(usec u32) int -fn C.opendir(charptr) voidptr +fn C.opendir(&char) voidptr fn C.closedir(dirp &C.DIR) int -// fn C.mkdir(path charptr, mode mode_t) int -fn C.mkdir(path charptr, mode u32) int +// fn C.mkdir(path &char, mode mode_t) int +fn C.mkdir(path &char, mode u32) int // C.rand returns a pseudorandom integer from 0 (inclusive) to C.RAND_MAX (exclusive) [trusted] @@ -157,7 +157,7 @@ fn C.rand() int [trusted] fn C.srand(seed u32) -fn C.atof(str charptr) f64 +fn C.atof(str &char) f64 [trusted] fn C.tolower(c int) int @@ -169,9 +169,9 @@ fn C.toupper(c int) int fn C.getchar() int [trusted] -fn C.strerror(int) charptr +fn C.strerror(int) &char -fn C.snprintf(str charptr, size size_t, format charptr, opt ...voidptr) int +fn C.snprintf(str &char, size size_t, format &char, opt ...voidptr) int fn C.fprintf(byteptr, ...byteptr) @@ -240,7 +240,7 @@ fn C.RegSetValueExW(hKey voidptr, lpValueName &u16, Reserved u32, dwType u32, lp fn C.RegCloseKey(hKey voidptr) -fn C.RemoveDirectory(lpPathName charptr) int +fn C.RemoveDirectory(lpPathName &char) int // fn C.GetStdHandle() voidptr fn C.GetStdHandle(u32) voidptr @@ -257,15 +257,15 @@ fn C.GetCurrentProcessId() int fn C.wprintf() // fn C.setbuf() -fn C.setbuf(voidptr, charptr) +fn C.setbuf(voidptr, &char) fn C.SymCleanup(hProcess voidptr) -fn C.MultiByteToWideChar(codePage u32, dwFlags u32, lpMultiMyteStr charptr, cbMultiByte int, lpWideCharStr &u16, cchWideChar int) int +fn C.MultiByteToWideChar(codePage u32, dwFlags u32, lpMultiMyteStr &char, cbMultiByte int, lpWideCharStr &u16, cchWideChar int) int fn C.wcslen(str &u16) int -fn C.WideCharToMultiByte(codePage u32, dwFlags u32, lpWideCharStr &u16, cchWideChar int, lpMultiByteStr charptr, cbMultiByte int, lpDefaultChar charptr, lpUsedDefaultChar &int) int +fn C.WideCharToMultiByte(codePage u32, dwFlags u32, lpWideCharStr &u16, cchWideChar int, lpMultiByteStr &char, cbMultiByte int, lpDefaultChar &char, lpUsedDefaultChar &int) int fn C._wstat(path &u16, buffer &C._stat) @@ -281,7 +281,7 @@ fn C._wsystem(command &u16) int fn C._wgetenv(varname &u16) voidptr -fn C._putenv(envstring charptr) int +fn C._putenv(envstring &char) int fn C._waccess(path &u16, mode int) int diff --git a/vlib/builtin/js/string.v b/vlib/builtin/js/string.v index 379349102d..a835a7be39 100644 --- a/vlib/builtin/js/string.v +++ b/vlib/builtin/js/string.v @@ -138,7 +138,7 @@ pub fn (s string) i16() i16 { // f32 returns the value of the string as f32 `'1.0'.f32() == f32(1)`. pub fn (s string) f32() f32 { - // return C.atof(charptr(s.str)) + // return C.atof(&char(s.str)) return f32(JS.parseFloat(s)) } diff --git a/vlib/builtin/map.v b/vlib/builtin/map.v index 946c3b8a08..c8ad84bcfd 100644 --- a/vlib/builtin/map.v +++ b/vlib/builtin/map.v @@ -102,8 +102,8 @@ mut: // array allocated (with `cap` bytes) on first deletion // has non-zero element when key deleted all_deleted &byte - values byteptr - keys byteptr + values &byte + keys &byte } [inline] @@ -335,7 +335,7 @@ fn new_map_2(key_bytes int, value_bytes int, hash_fn MapHashFn, key_eq_fn MapEqF cached_hashbits: max_cached_hashbits shift: init_log_capicity key_values: new_dense_array(key_bytes, value_bytes) - metas: &u32(vcalloc(metasize)) + metas: unsafe { &u32(vcalloc(metasize)) } extra_metas: extra_metas_inc len: 0 has_string_keys: has_string_keys @@ -423,7 +423,7 @@ fn (mut m map) ensure_extra_metas(probe_count u32) { m.extra_metas += extra_metas_inc mem_size := (m.even_index + 2 + m.extra_metas) unsafe { - x := realloc_data(byteptr(m.metas), int(size_of_u32 * old_mem_size), int(size_of_u32 * mem_size)) + x := realloc_data(&byte(m.metas), int(size_of_u32 * old_mem_size), int(size_of_u32 * mem_size)) m.metas = &u32(x) C.memset(m.metas + mem_size - extra_metas_inc, 0, int(sizeof(u32) * extra_metas_inc)) } @@ -463,7 +463,7 @@ fn (mut m map) set_1(key voidptr, value voidptr) { pkey := m.key_values.key(kv_index) pvalue := m.key_values.value(kv_index) m.clone_fn(pkey, key) - C.memcpy(byteptr(pvalue), value, m.value_bytes) + C.memcpy(&byte(pvalue), value, m.value_bytes) } m.meta_greater(index, meta, u32(kv_index)) m.len++ @@ -493,7 +493,7 @@ fn (mut m map) rehash() { meta_bytes := sizeof(u32) * (m.even_index + 2 + m.extra_metas) unsafe { // TODO: use realloc_data here too - x := v_realloc(byteptr(m.metas), int(meta_bytes)) + x := v_realloc(&byte(m.metas), int(meta_bytes)) m.metas = &u32(x) C.memset(m.metas, 0, meta_bytes) } @@ -513,7 +513,7 @@ fn (mut m map) rehash() { fn (mut m map) cached_rehash(old_cap u32) { old_metas := m.metas metasize := int(sizeof(u32) * (m.even_index + 2 + m.extra_metas)) - m.metas = &u32(vcalloc(metasize)) + m.metas = unsafe { &u32(vcalloc(metasize)) } old_extra_metas := m.extra_metas for i := u32(0); i <= old_cap + old_extra_metas; i += 2 { if unsafe { old_metas[i] } == 0 { @@ -543,7 +543,7 @@ fn (mut m map) get_and_set_1(key voidptr, zero voidptr) voidptr { pkey := unsafe { m.key_values.key(kv_index) } if m.key_eq_fn(key, pkey) { pval := unsafe { m.key_values.value(kv_index) } - return unsafe { byteptr(pval) } + return unsafe { &byte(pval) } } } index += 2 @@ -570,7 +570,7 @@ fn (m &map) get_1(key voidptr, zero voidptr) voidptr { pkey := unsafe { m.key_values.key(kv_index) } if m.key_eq_fn(key, pkey) { pval := unsafe { m.key_values.value(kv_index) } - return unsafe { byteptr(pval) } + return unsafe { &byte(pval) } } } index += 2 @@ -594,7 +594,7 @@ fn (m &map) get_1_check(key voidptr) voidptr { pkey := unsafe { m.key_values.key(kv_index) } if m.key_eq_fn(key, pkey) { pval := unsafe { m.key_values.value(kv_index) } - return unsafe { byteptr(pval) } + return unsafe { &byte(pval) } } } index += 2 diff --git a/vlib/builtin/string.v b/vlib/builtin/string.v index 1bfd2004c8..27594e7fc5 100644 --- a/vlib/builtin/string.v +++ b/vlib/builtin/string.v @@ -43,8 +43,8 @@ NB: A V string should be/is immutable from the point of view of */ pub struct string { pub: - str byteptr // points to a C style 0 terminated string of bytes. - len int // the length of the .str field, excluding the ending 0 byte. It is always equal to strlen(.str). + str &byte // points to a C style 0 terminated string of bytes. + len int // the length of the .str field, excluding the ending 0 byte. It is always equal to strlen(.str). mut: is_lit int } @@ -67,14 +67,14 @@ pub mut: // vstrlen returns the V length of the C string `s` (0 terminator is not counted). [unsafe] -pub fn vstrlen(s byteptr) int { - return unsafe { C.strlen(charptr(s)) } +pub fn vstrlen(s &byte) int { + return unsafe { C.strlen(&char(s)) } } // tos converts a C string to a V string. // String data is reused, not copied. [unsafe] -pub fn tos(s byteptr, len int) string { +pub fn tos(s &byte, len int) string { // This should never happen. if s == 0 { panic('tos(): nil string') @@ -87,14 +87,14 @@ pub fn tos(s byteptr, len int) string { // tos_clone returns a copy of `s`. [unsafe] -pub fn tos_clone(s byteptr) string { +pub fn tos_clone(s &byte) string { return unsafe { tos2(s) }.clone() } // tos2 does the same as `tos`, but also calculates the length. Called by `string(bytes)` casts. // Used only internally. [unsafe] -pub fn tos2(s byteptr) string { +pub fn tos2(s &byte) string { if s == 0 { panic('tos2: nil string') } @@ -106,19 +106,19 @@ pub fn tos2(s byteptr) string { // tos3 does the same as `tos2`, but for char*, to avoid warnings. [unsafe] -pub fn tos3(s charptr) string { +pub fn tos3(s &char) string { if s == 0 { panic('tos3: nil string') } return string{ - str: byteptr(s) + str: &byte(s) len: unsafe { C.strlen(s) } } } // tos4 does the same as `tos2`, but returns an empty string on nil ptr. [unsafe] -pub fn tos4(s byteptr) string { +pub fn tos4(s &byte) string { if s == 0 { return '' } @@ -127,7 +127,7 @@ pub fn tos4(s byteptr) string { // tos5 does the same as `tos4`, but for char*, to avoid warnings. [unsafe] -pub fn tos5(s charptr) string { +pub fn tos5(s &char) string { if s == 0 { return '' } @@ -135,10 +135,10 @@ pub fn tos5(s charptr) string { } [deprecated] -pub fn tos_lit(s charptr) string { +pub fn tos_lit(s &char) string { eprintln('warning: `tos_lit` has been deprecated, use `_SLIT` instead') return string{ - str: byteptr(s) + str: &byte(s) len: unsafe { C.strlen(s) } is_lit: 1 } @@ -148,17 +148,17 @@ pub fn tos_lit(s charptr) string { // strings returned from this function will be normal V strings beside that (i.e. they would be // freed by V's -autofree mechanism, when they are no longer used). [unsafe] -pub fn (bp byteptr) vstring() string { +pub fn (bp &byte) vstring() string { return string{ str: bp - len: unsafe { C.strlen(charptr(bp)) } + len: unsafe { C.strlen(&char(bp)) } } } // vstring_with_len converts a C style string to a V string. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (bp byteptr) vstring_with_len(len int) string { +pub fn (bp &byte) vstring_with_len(len int) string { return string{ str: bp len: len @@ -169,9 +169,9 @@ pub fn (bp byteptr) vstring_with_len(len int) string { // vstring converts C char* to V string. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (cp charptr) vstring() string { +pub fn (cp &char) vstring() string { return string{ - str: byteptr(cp) + str: &byte(cp) len: unsafe { C.strlen(cp) } is_lit: 0 } @@ -180,9 +180,9 @@ pub fn (cp charptr) vstring() string { // vstring_with_len converts C char* to V string. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (cp charptr) vstring_with_len(len int) string { +pub fn (cp &char) vstring_with_len(len int) string { return string{ - str: byteptr(cp) + str: &byte(cp) len: len is_lit: 0 } @@ -196,10 +196,10 @@ pub fn (cp charptr) vstring_with_len(len int) string { // that can be read by the V program, but that should not be // managed by it, for example `os.args` is implemented using it. [unsafe] -pub fn (bp byteptr) vstring_literal() string { +pub fn (bp &byte) vstring_literal() string { return string{ str: bp - len: unsafe { C.strlen(charptr(bp)) } + len: unsafe { C.strlen(&char(bp)) } is_lit: 1 } } @@ -207,7 +207,7 @@ pub fn (bp byteptr) vstring_literal() string { // vstring_with_len converts a C style string to a V string. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (bp byteptr) vstring_literal_with_len(len int) string { +pub fn (bp &byte) vstring_literal_with_len(len int) string { return string{ str: bp len: len @@ -219,9 +219,9 @@ pub fn (bp byteptr) vstring_literal_with_len(len int) string { // See also vstring_literal defined on byteptr for more details. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (cp charptr) vstring_literal() string { +pub fn (cp &char) vstring_literal() string { return string{ - str: byteptr(cp) + str: &byte(cp) len: unsafe { C.strlen(cp) } is_lit: 1 } @@ -231,9 +231,9 @@ pub fn (cp charptr) vstring_literal() string { // See also vstring_literal_with_len defined on byteptr. // NB: the string data is reused, NOT copied. [unsafe] -pub fn (cp charptr) vstring_literal_with_len(len int) string { +pub fn (cp &char) vstring_literal_with_len(len int) string { return string{ - str: byteptr(cp) + str: &byte(cp) len: len is_lit: 1 } @@ -270,7 +270,7 @@ pub fn (s string) cstr() byteptr { */ // cstring_to_vstring creates a copy of cstr and turns it into a v string. [unsafe] -pub fn cstring_to_vstring(cstr byteptr) string { +pub fn cstring_to_vstring(cstr &byte) string { return unsafe { tos_clone(cstr) } } @@ -483,13 +483,13 @@ pub fn (s string) i16() i16 { // f32 returns the value of the string as f32 `'1.0'.f32() == f32(1)`. pub fn (s string) f32() f32 { - // return C.atof(charptr(s.str)) + // return C.atof(&char(s.str)) return f32(strconv.atof64(s)) } // f64 returns the value of the string as f64 `'1.0'.f64() == f64(1)`. pub fn (s string) f64() f64 { - // return C.atof(charptr(s.str)) + // return C.atof(&char(s.str)) return strconv.atof64(s) } @@ -1639,9 +1639,10 @@ pub fn (a []string) join(del string) string { } len -= del.len // Allocate enough memory - mut res := string{} - res.len = len - res.str = unsafe { malloc(res.len + 1) } + mut res := string{ + len: len + str: unsafe { malloc(len + 1) } + } mut idx := 0 // Go thru every string and copy its every char one by one for i, val in a { diff --git a/vlib/builtin/string_test.v b/vlib/builtin/string_test.v index 1389408d01..9235ff5b70 100644 --- a/vlib/builtin/string_test.v +++ b/vlib/builtin/string_test.v @@ -553,9 +553,9 @@ fn test_bytes_to_string() { } fn test_charptr() { - foo := charptr('VLANG'.str) + foo := &char('VLANG'.str) println(typeof(foo).name) - assert typeof(foo).name == 'charptr' + assert typeof(foo).name == '&char' assert unsafe { foo.vstring() } == 'VLANG' assert unsafe { foo.vstring_with_len(3) } == 'VLA' } diff --git a/vlib/builtin/utf8.c.v b/vlib/builtin/utf8.c.v index 0b60678804..c7e7157fc8 100644 --- a/vlib/builtin/utf8.c.v +++ b/vlib/builtin/utf8.c.v @@ -7,11 +7,11 @@ const ( pub fn (_str string) to_wide() &u16 { $if windows { unsafe { - num_chars := (C.MultiByteToWideChar(cp_utf8, 0, charptr(_str.str), _str.len, + num_chars := (C.MultiByteToWideChar(cp_utf8, 0, &char(_str.str), _str.len, 0, 0)) mut wstr := &u16(malloc((num_chars + 1) * 2)) // sizeof(wchar_t) if wstr != 0 { - C.MultiByteToWideChar(cp_utf8, 0, charptr(_str.str), _str.len, wstr, num_chars) + C.MultiByteToWideChar(cp_utf8, 0, &char(_str.str), _str.len, wstr, num_chars) C.memset(&byte(wstr) + num_chars * 2, 0, 2) } return wstr @@ -40,7 +40,7 @@ pub fn string_from_wide2(_wstr &u16, len int) string { num_chars := C.WideCharToMultiByte(cp_utf8, 0, _wstr, len, 0, 0, 0, 0) mut str_to := malloc(num_chars + 1) if str_to != 0 { - C.WideCharToMultiByte(cp_utf8, 0, _wstr, len, charptr(str_to), num_chars, + C.WideCharToMultiByte(cp_utf8, 0, _wstr, len, &char(str_to), num_chars, 0, 0) C.memset(str_to + num_chars, 0, 1) } diff --git a/vlib/dl/dl_nix.c.v b/vlib/dl/dl_nix.c.v index 56f128dbbe..88370e993f 100644 --- a/vlib/dl/dl_nix.c.v +++ b/vlib/dl/dl_nix.c.v @@ -17,7 +17,7 @@ fn C.dlerror() charptr // open loads the dynamic shared object. pub fn open(filename string, flags int) voidptr { - return C.dlopen(charptr(filename.str), flags) + return C.dlopen(&char(filename.str), flags) } // close frees a given shared object. @@ -27,7 +27,7 @@ pub fn close(handle voidptr) bool { // sym returns an address of a symbol in a given shared object. pub fn sym(handle voidptr, symbol string) voidptr { - return C.dlsym(handle, charptr(symbol.str)) + return C.dlsym(handle, &char(symbol.str)) } // dlerror provides a text error diagnostic message for functions in `dl` diff --git a/vlib/json/json_primitives.v b/vlib/json/json_primitives.v index 9aad77306f..3cfca1e6e9 100644 --- a/vlib/json/json_primitives.v +++ b/vlib/json/json_primitives.v @@ -178,13 +178,13 @@ fn encode_bool(val bool) &C.cJSON { } fn encode_string(val string) &C.cJSON { - return C.cJSON_CreateString(charptr(val.str)) + return C.cJSON_CreateString(&char(val.str)) } // /////////////////////// // user := decode_User(json_parse(js_string_var)) fn json_parse(s string) &C.cJSON { - return C.cJSON_Parse(charptr(s.str)) + return C.cJSON_Parse(&char(s.str)) } // json_string := json_print(encode_User(user)) diff --git a/vlib/net/address.v b/vlib/net/address.v index 505cbc7b4d..d50ed7af13 100644 --- a/vlib/net/address.v +++ b/vlib/net/address.v @@ -36,7 +36,7 @@ fn new_addr(addr C.sockaddr) ?Addr { socket_error(-1) ? } } $else { - res := charptr(C.inet_ntop(SocketFamily.inet, &addr, buf.data, buf.len)) + res := &char(C.inet_ntop(SocketFamily.inet, &addr, buf.data, buf.len)) if res == 0 { socket_error(-1) ? } diff --git a/vlib/net/tcp.v b/vlib/net/tcp.v index e5eca4728d..9cca9a1d9b 100644 --- a/vlib/net/tcp.v +++ b/vlib/net/tcp.v @@ -33,14 +33,14 @@ pub fn (mut c TcpConn) close() ? { } // write_ptr blocks and attempts to write all data -pub fn (mut c TcpConn) write_ptr(b byteptr, len int) ?int { +pub fn (mut c TcpConn) write_ptr(b &byte, len int) ?int { $if trace_tcp ? { eprintln( '>>> TcpConn.write_ptr | c.sock.handle: $c.sock.handle | b: ${ptr_str(b)} len: $len |\n' + unsafe { b.vstring_with_len(len) }) } unsafe { - mut ptr_base := byteptr(b) + mut ptr_base := &byte(b) mut total_sent := 0 for total_sent < len { ptr := ptr_base + total_sent @@ -77,7 +77,7 @@ pub fn (mut c TcpConn) write_string(s string) ?int { return c.write_ptr(s.str, s.len) } -pub fn (mut c TcpConn) read_ptr(buf_ptr byteptr, len int) ?int { +pub fn (mut c TcpConn) read_ptr(buf_ptr &byte, len int) ?int { mut res := wrap_read_result(C.recv(c.sock.handle, buf_ptr, len, 0)) ? $if trace_tcp ? { eprintln('<<< TcpConn.read_ptr | c.sock.handle: $c.sock.handle | buf_ptr: ${ptr_str(buf_ptr)} len: $len | res: $res') @@ -163,7 +163,7 @@ pub fn (c &TcpConn) peer_ip() ?string { peeraddr := C.sockaddr_in{} speeraddr := sizeof(peeraddr) socket_error(C.getpeername(c.sock.handle, unsafe { &C.sockaddr(&peeraddr) }, &speeraddr)) ? - cstr := charptr(C.inet_ntop(SocketFamily.inet, &peeraddr.sin_addr, &buf[0], sizeof(buf))) + cstr := &char(C.inet_ntop(SocketFamily.inet, &peeraddr.sin_addr, &buf[0], sizeof(buf))) if cstr == 0 { return error('net.peer_ip: inet_ntop failed') } diff --git a/vlib/os/environment.c.v b/vlib/os/environment.c.v index ff7173ab42..a4d81685d3 100644 --- a/vlib/os/environment.c.v +++ b/vlib/os/environment.c.v @@ -3,7 +3,7 @@ // that can be found in the LICENSE file. module os -fn C.getenv(charptr) &char +fn C.getenv(&char) &char // C.GetEnvironmentStringsW & C.FreeEnvironmentStringsW are defined only on windows fn C.GetEnvironmentStringsW() &u16 @@ -20,12 +20,12 @@ pub fn getenv(key string) string { } return string_from_wide(s) } $else { - s := C.getenv(charptr(key.str)) + s := C.getenv(&char(key.str)) if s == voidptr(0) { return '' } // NB: C.getenv *requires* that the result be copied. - return cstring_to_vstring(byteptr(s)) + return cstring_to_vstring(&byte(s)) } } } @@ -36,19 +36,19 @@ pub fn setenv(name string, value string, overwrite bool) int { format := '$name=$value' if overwrite { unsafe { - return C._putenv(charptr(format.str)) + return C._putenv(&char(format.str)) } } else { if getenv(name).len == 0 { unsafe { - return C._putenv(charptr(format.str)) + return C._putenv(&char(format.str)) } } } return -1 } $else { unsafe { - return C.setenv(charptr(name.str), charptr(value.str), overwrite) + return C.setenv(&char(name.str), &char(value.str), overwrite) } } } @@ -57,9 +57,9 @@ pub fn setenv(name string, value string, overwrite bool) int { pub fn unsetenv(name string) int { $if windows { format := '$name=' - return C._putenv(charptr(format.str)) + return C._putenv(&char(format.str)) } $else { - return C.unsetenv(charptr(name.str)) + return C.unsetenv(&char(name.str)) } } @@ -83,14 +83,18 @@ pub fn environ() map[string]string { } C.FreeEnvironmentStringsW(estrings) } $else { + /* + // e := unsafe { &&char(C.environ) } e := unsafe { &charptr(C.environ) } for i := 0; !isnil(unsafe { e[i] }); i++ { - eline := unsafe { cstring_to_vstring(byteptr(e[i])) } + x := &byte(e[i]) + eline := unsafe { cstring_to_vstring(x) } eq_index := eline.index_byte(`=`) if eq_index > 0 { res[eline[0..eq_index]] = eline[eq_index + 1..] } } + */ } return res } diff --git a/vlib/os/file.c.v b/vlib/os/file.c.v index 1d05d95067..f9539802a6 100644 --- a/vlib/os/file.c.v +++ b/vlib/os/file.c.v @@ -57,11 +57,11 @@ pub fn open_file(path string, mode string, options ...int) ?File { $if windows { p = path.replace('/', '\\') } - fd := C.open(charptr(p.str), flags, permission) + fd := C.open(&char(p.str), flags, permission) if fd == -1 { return error(posix_get_error_msg(C.errno)) } - cfile := C.fdopen(fd, charptr(mode.str)) + cfile := C.fdopen(fd, &char(mode.str)) if isnil(cfile) { return error('Failed to open or create file "$path"') } diff --git a/vlib/os/inode.c.v b/vlib/os/inode.c.v index 6a3f58d69e..3c6b19bb28 100644 --- a/vlib/os/inode.c.v +++ b/vlib/os/inode.c.v @@ -32,7 +32,7 @@ pub: // it supports windows for regular files but it doesn't matter if you use owner, group or others when checking permissions on windows pub fn inode(path string) FileMode { mut attr := C.stat{} - unsafe { C.stat(charptr(path.str), &attr) } + unsafe { C.stat(&char(path.str), &attr) } mut typ := FileType.regular if attr.st_mode & u32(C.S_IFMT) == u32(C.S_IFDIR) { typ = .directory diff --git a/vlib/os/os_c.v b/vlib/os/os_c.v index 77d6f33337..126193f7ba 100644 --- a/vlib/os/os_c.v +++ b/vlib/os/os_c.v @@ -9,7 +9,7 @@ struct C.dirent { fn C.readdir(voidptr) &C.dirent -fn C.readlink(pathname charptr, buf charptr, bufsiz size_t) int +fn C.readlink(pathname &char, buf &char, bufsiz size_t) int fn C.getline(voidptr, voidptr, voidptr) int @@ -17,15 +17,15 @@ fn C.ftell(fp voidptr) int fn C.sigaction(int, voidptr, int) int -fn C.open(charptr, int, ...int) int +fn C.open(&char, int, ...int) int -fn C.fdopen(fd int, mode charptr) &C.FILE +fn C.fdopen(fd int, mode &char) &C.FILE fn C.CopyFile(&u32, &u32, int) int // fn C.lstat(charptr, voidptr) u64 -fn C._wstat64(charptr, voidptr) u64 +fn C._wstat64(&char, voidptr) u64 // fn C.proc_pidpath(int, byteptr, int) int struct C.stat { @@ -54,7 +54,7 @@ mut: } struct C.dirent { - d_name byteptr + d_name &byte } // read_bytes returns all bytes read from file in `path`. @@ -121,7 +121,7 @@ pub fn file_size(path string) u64 { C._wstat64(path.to_wide(), voidptr(&swin)) return swin.st_size } $else { - C.stat(charptr(path.str), &s) + C.stat(&char(path.str), &s) return u64(s.st_size) } } @@ -133,7 +133,7 @@ pub fn file_size(path string) u64 { C._wstat(path.to_wide(), voidptr(&s)) return u64(s.st_size) } $else { - C.stat(charptr(path.str), &s) + C.stat(&char(path.str), &s) return u64(s.st_size) } } @@ -155,7 +155,7 @@ pub fn mv(src string, dst string) ? { return error_with_code('failed to rename $src to $dst', int(ret)) } } $else { - ret := C.rename(charptr(src.str), charptr(rdst.str)) + ret := C.rename(&char(src.str), &char(rdst.str)) if ret != 0 { return error_with_code('failed to rename $src to $dst', int(ret)) } @@ -172,11 +172,11 @@ pub fn cp(src string, dst string) ? { return error_with_code('failed to copy $src to $dst', int(result)) } } $else { - fp_from := C.open(charptr(src.str), C.O_RDONLY) + fp_from := C.open(&char(src.str), C.O_RDONLY) if fp_from < 0 { // Check if file opened return error_with_code('cp: failed to open $src', int(fp_from)) } - fp_to := C.open(charptr(dst.str), C.O_WRONLY | C.O_CREAT | C.O_TRUNC, C.S_IWUSR | C.S_IRUSR) + fp_to := C.open(&char(dst.str), C.O_WRONLY | C.O_CREAT | C.O_TRUNC, C.S_IWUSR | C.S_IRUSR) if fp_to < 0 { // Check if file opened (permissions problems ...) C.close(fp_from) return error_with_code('cp (permission): failed to write to $dst (fp_to: $fp_to)', @@ -197,9 +197,9 @@ pub fn cp(src string, dst string) ? { } from_attr := C.stat{} unsafe { - C.stat(charptr(src.str), &from_attr) + C.stat(&char(src.str), &from_attr) } - if C.chmod(charptr(dst.str), from_attr.st_mode) < 0 { + if C.chmod(&char(dst.str), from_attr.st_mode) < 0 { return error_with_code('failed to set permissions for $dst', int(-1)) } C.close(fp_to) @@ -218,7 +218,7 @@ pub fn vfopen(path string, mode string) ?&C.FILE { $if windows { fp = C._wfopen(path.to_wide(), mode.to_wide()) } $else { - fp = C.fopen(charptr(path.str), charptr(mode.str)) + fp = C.fopen(&char(path.str), &char(mode.str)) } if isnil(fp) { return error('failed to open file "$path"') @@ -249,7 +249,7 @@ fn vpopen(path string) voidptr { return C._wpopen(wpath, mode.to_wide()) } $else { cpath := path.str - return C.popen(charptr(cpath), 'r') + return C.popen(&char(cpath), c'r') } } @@ -306,7 +306,7 @@ pub fn system(cmd string) int { } $else { $if ios { unsafe { - arg := [c'/bin/sh', c'-c', byteptr(cmd.str), 0] + arg := [c'/bin/sh', c'-c', &byte(cmd.str), 0] pid := 0 ret = C.posix_spawn(&pid, '/bin/sh', 0, 0, arg.data, 0) status := 0 @@ -317,7 +317,7 @@ pub fn system(cmd string) int { } } $else { unsafe { - ret = C.system(charptr(cmd.str)) + ret = C.system(&char(cmd.str)) } } } @@ -340,7 +340,7 @@ pub fn exists(path string) bool { p := path.replace('/', '\\') return C._waccess(p.to_wide(), f_ok) != -1 } $else { - return C.access(charptr(path.str), f_ok) != -1 + return C.access(&char(path.str), f_ok) != -1 } } @@ -359,13 +359,13 @@ pub fn is_executable(path string) bool { $if solaris { statbuf := C.stat{} unsafe { - if C.stat(charptr(path.str), &statbuf) != 0 { + if C.stat(&char(path.str), &statbuf) != 0 { return false } } return (int(statbuf.st_mode) & (s_ixusr | s_ixgrp | s_ixoth)) != 0 } - return C.access(charptr(path.str), x_ok) != -1 + return C.access(&char(path.str), x_ok) != -1 } // is_writable returns `true` if `path` is writable. @@ -374,7 +374,7 @@ pub fn is_writable(path string) bool { p := path.replace('/', '\\') return C._waccess(p.to_wide(), w_ok) != -1 } $else { - return C.access(charptr(path.str), w_ok) != -1 + return C.access(&char(path.str), w_ok) != -1 } } @@ -384,7 +384,7 @@ pub fn is_readable(path string) bool { p := path.replace('/', '\\') return C._waccess(p.to_wide(), r_ok) != -1 } $else { - return C.access(charptr(path.str), r_ok) != -1 + return C.access(&char(path.str), r_ok) != -1 } } @@ -394,7 +394,7 @@ pub fn rm(path string) ? { $if windows { rc = C._wremove(path.to_wide()) } $else { - rc = C.remove(charptr(path.str)) + rc = C.remove(&char(path.str)) } if rc == -1 { return error('Failed to remove "$path": ' + posix_get_error_msg(C.errno)) @@ -411,7 +411,7 @@ pub fn rmdir(path string) ? { return error('Failed to remove "$path": ' + posix_get_error_msg(C.errno)) } } $else { - rc := C.rmdir(charptr(path.str)) + rc := C.rmdir(&char(path.str)) if rc == -1 { return error(posix_get_error_msg(C.errno)) } @@ -421,7 +421,7 @@ pub fn rmdir(path string) ? { // print_c_errno will print the current value of `C.errno`. fn print_c_errno() { e := C.errno - se := unsafe { tos_clone(byteptr(C.strerror(C.errno))) } + se := unsafe { tos_clone(&byte(C.strerror(C.errno))) } println('errno=$e err=$se') } @@ -460,9 +460,9 @@ pub fn get_raw_line() string { } } $else { max := size_t(0) - buf := charptr(0) + buf := &char(0) nr_chars := unsafe { C.getline(&buf, &max, C.stdin) } - return unsafe { tos(byteptr(buf), if nr_chars < 0 { 0 } else { nr_chars }) } + return unsafe { tos(&byte(buf), if nr_chars < 0 { 0 } else { nr_chars }) } } } @@ -496,7 +496,7 @@ pub fn get_raw_stdin() []byte { } } $else { max := size_t(0) - buf := charptr(0) + buf := &char(0) nr_chars := unsafe { C.getline(&buf, &max, C.stdin) } return array{ element_size: 1 @@ -554,7 +554,7 @@ pub fn on_segfault(f voidptr) { pub fn executable() string { $if linux { mut xresult := vcalloc(max_path_len) - count := C.readlink('/proc/self/exe', charptr(xresult), max_path_len) + count := C.readlink('/proc/self/exe', &char(xresult), max_path_len) if count < 0 { eprintln('os.executable() failed at reading /proc/self/exe to get exe path') return executable_fallback() @@ -616,7 +616,7 @@ pub fn executable() string { } $if netbsd { mut result := vcalloc(max_path_len) - count := C.readlink('/proc/curproc/exe', charptr(result), max_path_len) + count := C.readlink('/proc/curproc/exe', &char(result), max_path_len) if count < 0 { eprintln('os.executable() failed at reading /proc/curproc/exe to get exe path') return executable_fallback() @@ -625,7 +625,7 @@ pub fn executable() string { } $if dragonfly { mut result := vcalloc(max_path_len) - count := C.readlink('/proc/curproc/file', charptr(result), max_path_len) + count := C.readlink('/proc/curproc/file', &char(result), max_path_len) if count < 0 { eprintln('os.executable() failed at reading /proc/curproc/file to get exe path') return executable_fallback() @@ -649,7 +649,7 @@ pub fn is_dir(path string) bool { return false } $else { statbuf := C.stat{} - if unsafe { C.stat(charptr(path.str), &statbuf) } != 0 { + if unsafe { C.stat(&char(path.str), &statbuf) } != 0 { return false } // ref: https://code.woboq.org/gcc/include/sys/stat.h.html @@ -664,7 +664,7 @@ pub fn is_link(path string) bool { return false // TODO } $else { statbuf := C.stat{} - if C.lstat(charptr(path.str), &statbuf) != 0 { + if C.lstat(&char(path.str), &statbuf) != 0 { return false } return int(statbuf.st_mode) & s_ifmt == s_iflnk @@ -676,7 +676,7 @@ pub fn chdir(path string) { $if windows { C._wchdir(path.to_wide()) } $else { - C.chdir(charptr(path.str)) + C.chdir(&char(path.str)) } } @@ -695,7 +695,7 @@ pub fn getwd() string { } $else { buf := vcalloc(512) unsafe { - if C.getcwd(charptr(buf), 512) == 0 { + if C.getcwd(&char(buf), 512) == 0 { free(buf) return '' } @@ -713,7 +713,7 @@ pub fn getwd() string { // NB: this particular rabbit hole is *deep* ... [manualfree] pub fn real_path(fpath string) string { - mut fullpath := byteptr(0) + mut fullpath := &byte(0) defer { unsafe { free(fullpath) } } @@ -727,7 +727,7 @@ pub fn real_path(fpath string) string { } } $else { fullpath = vcalloc(max_path_len) - ret := charptr(C.realpath(charptr(fpath.str), charptr(fullpath))) + ret := &char(C.realpath(&char(fpath.str), &char(fullpath))) if ret == 0 { return fpath } @@ -796,7 +796,7 @@ pub fn wait() int { pub fn file_last_mod_unix(path string) int { attr := C.stat{} // # struct stat attr; - unsafe { C.stat(charptr(path.str), &attr) } + unsafe { C.stat(&char(path.str), &attr) } // # stat(path.str, &attr); return attr.st_mtime // # return attr.st_mtime ; @@ -810,7 +810,7 @@ pub fn flush() { // chmod change file access attributes of `path` to `mode`. // Octals like `0o600` can be used. pub fn chmod(path string, mode int) { - C.chmod(charptr(path.str), mode) + C.chmod(&char(path.str), mode) } // open_append opens `path` file for appending. @@ -825,7 +825,7 @@ pub fn open_append(path string) ?File { } $else { cpath := path.str file = File{ - cfile: C.fopen(charptr(cpath), 'ab') + cfile: C.fopen(&char(cpath), c'ab') } } if isnil(file.cfile) { @@ -841,17 +841,17 @@ pub fn open_append(path string) ?File { // NB: this function will NOT return when successfull, since // the child process will take control over execution. pub fn execvp(cmdpath string, args []string) ? { - mut cargs := []charptr{} - cargs << charptr(cmdpath.str) + mut cargs := []&char{} + cargs << &char(cmdpath.str) for i in 0 .. args.len { - cargs << charptr(args[i].str) + cargs << &char(args[i].str) } - cargs << charptr(0) + cargs << &char(0) mut res := int(0) $if windows { - res = C._execvp(charptr(cmdpath.str), cargs.data) + res = C._execvp(&char(cmdpath.str), cargs.data) } $else { - res = C.execvp(charptr(cmdpath.str), cargs.data) + res = C.execvp(&char(cmdpath.str), cargs.data) } if res == -1 { return error_with_code(posix_get_error_msg(C.errno), C.errno) @@ -867,22 +867,22 @@ pub fn execvp(cmdpath string, args []string) ? { // NB: this function will NOT return when successfull, since // the child process will take control over execution. pub fn execve(cmdpath string, args []string, envs []string) ? { - mut cargv := []charptr{} - mut cenvs := []charptr{} - cargv << charptr(cmdpath.str) + mut cargv := []&char{} + mut cenvs := []&char{} + cargv << &char(cmdpath.str) for i in 0 .. args.len { - cargv << charptr(args[i].str) + cargv << &char(args[i].str) } for i in 0 .. envs.len { - cenvs << charptr(envs[i].str) + cenvs << &char(envs[i].str) } - cargv << charptr(0) - cenvs << charptr(0) + cargv << &char(0) + cenvs << &char(0) mut res := int(0) $if windows { - res = C._execve(charptr(cmdpath.str), cargv.data, cenvs.data) + res = C._execve(&char(cmdpath.str), cargv.data, cenvs.data) } $else { - res = C.execve(charptr(cmdpath.str), cargv.data, cenvs.data) + res = C.execve(&char(cmdpath.str), cargv.data, cenvs.data) } // NB: normally execve does not return at all. // If it returns, then something went wrong... diff --git a/vlib/os/os_nix.c.v b/vlib/os/os_nix.c.v index c0da8ac813..78ff43cb97 100644 --- a/vlib/os/os_nix.c.v +++ b/vlib/os/os_nix.c.v @@ -75,14 +75,14 @@ fn init_os_args(argc int, argv &&byte) []string { // mut args := []string{len:argc} for i in 0 .. argc { // args [i] = argv[i].vstring() - unsafe { args_ << byteptr(argv[i]).vstring_literal() } + unsafe { args_ << (&byte(argv[i])).vstring_literal() } } return args_ } pub fn ls(path string) ?[]string { mut res := []string{} - dir := unsafe { C.opendir(charptr(path.str)) } + dir := unsafe { C.opendir(&char(path.str)) } if isnil(dir) { return error('ls() couldnt open dir "$path"') } @@ -149,7 +149,7 @@ pub fn mkdir(path string) ?bool { } } */ - r := unsafe { C.mkdir(charptr(apath.str), 511) } + r := unsafe { C.mkdir(&char(apath.str), 511) } if r == -1 { return error(posix_get_error_msg(C.errno)) } @@ -177,7 +177,7 @@ pub fn execute(cmd string) Result { } unsafe { bufbp := &buf[0] - for C.fgets(charptr(bufbp), 4096, f) != 0 { + for C.fgets(&char(bufbp), 4096, f) != 0 { res.write_ptr(bufbp, vstrlen(bufbp)) } } @@ -220,7 +220,7 @@ pub fn (mut c Command) read_line() string { } unsafe { bufbp := &buf[0] - for C.fgets(charptr(bufbp), 4096, c.f) != 0 { + for C.fgets(&char(bufbp), 4096, c.f) != 0 { len := vstrlen(bufbp) for i in 0 .. len { if bufbp[i] == `\n` { @@ -245,7 +245,7 @@ pub fn (c &Command) close() ? { } pub fn symlink(origin string, target string) ?bool { - res := C.symlink(charptr(origin.str), charptr(target.str)) + res := C.symlink(&char(origin.str), &char(target.str)) if res == 0 { return true } @@ -290,7 +290,7 @@ pub fn is_writable_folder(folder string) ?bool { } tmp_perm_check := join_path(folder, 'XXXXXX') unsafe { - x := C.mkstemp(charptr(tmp_perm_check.str)) + x := C.mkstemp(&char(tmp_perm_check.str)) if -1 == x { return error('folder `$folder` is not writable') } @@ -309,7 +309,7 @@ pub fn getpid() int { pub fn posix_set_permission_bit(path_s string, mode u32, enable bool) { mut s := C.stat{} mut new_mode := u32(0) - path := charptr(path_s.str) + path := &char(path_s.str) unsafe { C.stat(path, &s) new_mode = s.st_mode diff --git a/vlib/os/os_test.v b/vlib/os/os_test.v index 2bdbed2eac..37136b73de 100644 --- a/vlib/os/os_test.v +++ b/vlib/os/os_test.v @@ -522,7 +522,7 @@ fn test_posix_set_bit() { fpath := '/tmp/permtest' create(fpath) or { panic("Couldn't create file") } chmod(fpath, 0o7777) - c_fpath := charptr(fpath.str) + c_fpath := &char(fpath.str) mut s := C.stat{} unsafe { C.stat(c_fpath, &s) diff --git a/vlib/strings/builder.v b/vlib/strings/builder.v index e919e9dfdb..12f7538f0d 100644 --- a/vlib/strings/builder.v +++ b/vlib/strings/builder.v @@ -28,13 +28,13 @@ pub fn new_builder(initial_size int) Builder { [deprecated: 'use Builder.write_ptr() instead'] [deprecated_after: '2021-04-18'] [unsafe] -pub fn (mut b Builder) write_bytes(bytes byteptr, len int) { +pub fn (mut b Builder) write_bytes(bytes &byte, len int) { unsafe { b.write_ptr(bytes, len) } } // write_ptr writes `len` bytes provided byteptr to the accumulated buffer [unsafe] -pub fn (mut b Builder) write_ptr(ptr byteptr, len int) { +pub fn (mut b Builder) write_ptr(ptr &byte, len int) { unsafe { b.buf.push_many(ptr, len) } b.len += len } @@ -140,7 +140,7 @@ pub fn (b &Builder) after(n int) string { // .str() call. pub fn (mut b Builder) str() string { b.buf << `\0` - s := unsafe { byteptr(memdup(b.buf.data, b.len)).vstring_with_len(b.len) } + s := unsafe { (&byte(memdup(b.buf.data, b.len))).vstring_with_len(b.len) } b.len = 0 b.buf.trim(0) return s diff --git a/vlib/szip/szip.v b/vlib/szip/szip.v index cd3dd5b456..53f42314c2 100644 --- a/vlib/szip/szip.v +++ b/vlib/szip/szip.v @@ -208,7 +208,7 @@ pub fn extract_zip_to_dir(file string, dir string) ?bool { if C.access(dir.str, 0) == -1 { return error('szip: cannot open directory for extracting, directory not exists') } - res := C.zip_extract_without_callback(charptr(file.str), charptr(dir.str)) + res := C.zip_extract_without_callback(&char(file.str), &char(dir.str)) return res == 0 } diff --git a/vlib/time/parse.v b/vlib/time/parse.v index 411c1b5512..f86bd5cb3a 100644 --- a/vlib/time/parse.v +++ b/vlib/time/parse.v @@ -37,7 +37,7 @@ pub fn parse_rfc2822(s string) ?Time { mm := pos / 3 + 1 unsafe { tmstr := malloc(s.len * 2) - count := C.snprintf(charptr(tmstr), (s.len * 2), '%s-%02d-%s %s', fields[3].str, + count := C.snprintf(&char(tmstr), (s.len * 2), c'%s-%02d-%s %s', fields[3].str, mm, fields[1].str, fields[4].str) return parse(tos(tmstr, count)) } @@ -50,7 +50,7 @@ const ( fn parse_iso8601_date(s string) ?(int, int, int) { year, month, day, dummy := 0, 0, 0, byte(0) - count := unsafe { C.sscanf(charptr(s.str), '%4d-%2d-%2d%c', &year, &month, &day, &dummy) } + count := unsafe { C.sscanf(&char(s.str), '%4d-%2d-%2d%c', &year, &month, &day, &dummy) } if count != 3 { return time.err_invalid_8601 } @@ -66,14 +66,14 @@ fn parse_iso8601_time(s string) ?(int, int, int, int, i64, bool) { offset_hour := 0 offset_minute := 0 mut count := unsafe { - C.sscanf(charptr(s.str), '%2d:%2d:%2d.%6d%c%2d:%2d', &hour_, &minute_, &second_, - µsecond_, charptr(&plus_min_z), &offset_hour, &offset_minute) + C.sscanf(&char(s.str), '%2d:%2d:%2d.%6d%c%2d:%2d', &hour_, &minute_, &second_, + µsecond_, &char(&plus_min_z), &offset_hour, &offset_minute) } // Missread microsecond ([Sec Hour Minute].len == 3 < 4) if count < 4 { count = unsafe { - C.sscanf(charptr(s.str), '%2d:%2d:%2d%c%2d:%2d', &hour_, &minute_, &second_, - charptr(&plus_min_z), &offset_hour, &offset_minute) + C.sscanf(&char(s.str), '%2d:%2d:%2d%c%2d:%2d', &hour_, &minute_, &second_, + &char(&plus_min_z), &offset_hour, &offset_minute) } count++ // Increment count because skipped microsecond } diff --git a/vlib/v/ast/table.v b/vlib/v/ast/table.v index a21ba09d41..ff35c0ef37 100644 --- a/vlib/v/ast/table.v +++ b/vlib/v/ast/table.v @@ -882,6 +882,7 @@ pub fn (t &Table) sumtype_has_variant(parent Type, variant Type) bool { return false } +// only used for debugging V compiler type bugs pub fn (t &Table) known_type_names() []string { mut res := []string{cap: t.type_idxs.len} for _, idx in t.type_idxs { diff --git a/vlib/v/ast/types.v b/vlib/v/ast/types.v index 0b06f78f43..cb80244b7c 100644 --- a/vlib/v/ast/types.v +++ b/vlib/v/ast/types.v @@ -813,8 +813,14 @@ pub fn (mytable &Table) type_to_code(t Type) string { } // import_aliases is a map of imported symbol aliases 'module.Type' => 'Type' -pub fn (mytable &Table) type_to_str_using_aliases(t Type, import_aliases map[string]string) string { - sym := mytable.get_type_symbol(t) +pub fn (t &Table) type_to_str_using_aliases(typ Type, import_aliases map[string]string) string { + /* + if t.pref.is_verbose { + print_backtrace() + exit(0) + } + */ + sym := t.get_type_symbol(typ) mut res := sym.name match sym.kind { .int_literal, .float_literal { @@ -823,23 +829,29 @@ pub fn (mytable &Table) type_to_str_using_aliases(t Type, import_aliases map[str .i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .char, .rune, .string, .bool, .none_, .byteptr, .voidptr, .charptr { // primitive types - res = sym.kind.str() + if sym.kind == .byteptr { + res = '&byte' + } else if sym.kind == .charptr { + res = '&char' + } else { + res = sym.kind.str() + } } .array { - if t == ast.array_type { + if typ == ast.array_type { return 'array' } - if t.has_flag(.variadic) { - res = mytable.type_to_str_using_aliases(mytable.value_type(t), import_aliases) + if typ.has_flag(.variadic) { + res = t.type_to_str_using_aliases(t.value_type(typ), import_aliases) } else { info := sym.info as Array - elem_str := mytable.type_to_str_using_aliases(info.elem_type, import_aliases) + elem_str := t.type_to_str_using_aliases(info.elem_type, import_aliases) res = '[]$elem_str' } } .array_fixed { info := sym.info as ArrayFixed - elem_str := mytable.type_to_str_using_aliases(info.elem_type, import_aliases) + elem_str := t.type_to_str_using_aliases(info.elem_type, import_aliases) res = '[$info.size]$elem_str' } .chan { @@ -852,63 +864,63 @@ pub fn (mytable &Table) type_to_str_using_aliases(t Type, import_aliases map[str mut_str = 'mut ' elem_type = elem_type.set_nr_muls(elem_type.nr_muls() - 1) } - elem_str := mytable.type_to_str_using_aliases(elem_type, import_aliases) + elem_str := t.type_to_str_using_aliases(elem_type, import_aliases) res = 'chan $mut_str$elem_str' } } .function { info := sym.info as FnType - if !mytable.is_fmt { - res = mytable.fn_signature(info.func, type_only: true) + if !t.is_fmt { + res = t.fn_signature(info.func, type_only: true) } else { if res.starts_with('fn (') { // fn foo () - res = mytable.fn_signature(info.func, type_only: true) + res = t.fn_signature(info.func, type_only: true) } else { // FnFoo - res = mytable.shorten_user_defined_typenames(res, import_aliases) + res = t.shorten_user_defined_typenames(res, import_aliases) } } } .map { - if int(t) == ast.map_type_idx { + if int(typ) == ast.map_type_idx { return 'map' } info := sym.info as Map - key_str := mytable.type_to_str_using_aliases(info.key_type, import_aliases) - val_str := mytable.type_to_str_using_aliases(info.value_type, import_aliases) + key_str := t.type_to_str_using_aliases(info.key_type, import_aliases) + val_str := t.type_to_str_using_aliases(info.value_type, import_aliases) res = 'map[$key_str]$val_str' } .multi_return { res = '(' info := sym.info as MultiReturn - for i, typ in info.types { + for i, typ2 in info.types { if i > 0 { res += ', ' } - res += mytable.type_to_str_using_aliases(typ, import_aliases) + res += t.type_to_str_using_aliases(typ2, import_aliases) } res += ')' } .void { - if t.has_flag(.optional) { + if typ.has_flag(.optional) { return '?' } return 'void' } else { - res = mytable.shorten_user_defined_typenames(res, import_aliases) + res = t.shorten_user_defined_typenames(res, import_aliases) } } - mut nr_muls := t.nr_muls() - if t.has_flag(.shared_f) { + mut nr_muls := typ.nr_muls() + if typ.has_flag(.shared_f) { nr_muls-- res = 'shared ' + res } if nr_muls > 0 { res = strings.repeat(`&`, nr_muls) + res } - if t.has_flag(.optional) { + if typ.has_flag(.optional) { res = '?' + res } return res diff --git a/vlib/v/checker/check_types.v b/vlib/v/checker/check_types.v index 8d8d8cb7a0..cb9a514fd2 100644 --- a/vlib/v/checker/check_types.v +++ b/vlib/v/checker/check_types.v @@ -241,7 +241,8 @@ pub fn (mut c Checker) check_types(got ast.Type, expected ast.Type) bool { if exp_idx == got_idx { return true } - if exp_idx == ast.voidptr_type_idx || exp_idx == ast.byteptr_type_idx { + if exp_idx == ast.voidptr_type_idx || exp_idx == ast.byteptr_type_idx + || (expected.is_ptr() && expected.deref().idx() == ast.byte_type_idx) { if got.is_ptr() || got.is_pointer() { return true } @@ -253,7 +254,8 @@ pub fn (mut c Checker) check_types(got ast.Type, expected ast.Type) bool { return true } } - if got_idx == ast.voidptr_type_idx || got_idx == ast.byteptr_type_idx { + if got_idx == ast.voidptr_type_idx || got_idx == ast.byteptr_type_idx + || (got_idx == ast.byte_type_idx && got.is_ptr()) { if expected.is_ptr() || expected.is_pointer() { return true } diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v index 34834d9c6b..a65bda82f9 100644 --- a/vlib/v/checker/checker.v +++ b/vlib/v/checker/checker.v @@ -2915,7 +2915,7 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { c.error('cannot modify blank `_` identifier', left.pos) } } else if left.info !is ast.IdentVar { - c.error('cannot assign to $left.kind `$left.name`', left.pos) + c.error('1cannot assign to $left.kind `$left.name`', left.pos) } else { if is_decl { c.check_valid_snake_case(left.name, 'variable name', left.pos) @@ -3019,7 +3019,7 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { } right_is_ptr := right_type.is_ptr() || right_sym.is_pointer() if !right_is_ptr && assign_stmt.op == .assign && right_type_unwrapped.is_number() { - c.error('cannot assign to `$left`: ' + + c.error('2cannot assign to `$left`: ' + c.expected_msg(right_type_unwrapped, left_type_unwrapped), right.position()) } if (right is ast.StructInit || !right_is_ptr) && !(right_sym.is_number() @@ -3122,7 +3122,7 @@ pub fn (mut c Checker) assign_stmt(mut assign_stmt ast.AssignStmt) { && left_sym.kind != .interface_ { // Dual sides check (compatibility check) c.check_expected(right_type_unwrapped, left_type_unwrapped) or { - c.error('cannot assign to `$left`: $err.msg', right.position()) + c.error('3cannot assign to `$left`: $err.msg', right.position()) } } if left_sym.kind == .interface_ { @@ -4412,7 +4412,8 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) ast.Type { // variadic case can happen when arrays are converted into variadic msg := if node.expr_type.has_flag(.optional) { 'an optional' } else { 'a variadic' } c.error('cannot type cast $msg', node.pos) - } else if !c.inside_unsafe && node.typ.is_ptr() && node.expr_type.is_ptr() { + } else if !c.inside_unsafe && node.typ.is_ptr() && node.expr_type.is_ptr() + && node.typ.deref() != ast.char_type && node.expr_type.deref() != ast.char_type { ft := c.table.type_to_str(node.expr_type) tt := c.table.type_to_str(node.typ) c.warn('casting `$ft` to `$tt` is only allowed in `unsafe` code', node.pos) @@ -5240,7 +5241,10 @@ pub fn (mut c Checker) lock_expr(mut node ast.LockExpr) ast.Type { } pub fn (mut c Checker) unsafe_expr(mut node ast.UnsafeExpr) ast.Type { - assert !c.inside_unsafe + // assert !c.inside_unsafe + if c.inside_unsafe { + c.error('unsafe inside unsafe', node.pos) + } c.inside_unsafe = true t := c.expr(node.expr) c.inside_unsafe = false diff --git a/vlib/v/checker/tests/fixed_array_conv.out b/vlib/v/checker/tests/fixed_array_conv.out index 8358d9ac4f..3e3c405f27 100644 --- a/vlib/v/checker/tests/fixed_array_conv.out +++ b/vlib/v/checker/tests/fixed_array_conv.out @@ -17,16 +17,16 @@ vlib/v/checker/tests/fixed_array_conv.vv:6:6: error: cannot cast a fixed array ( 5 | ip = arr 6 | _ = &int(arr) | ~~~~~~~~ - 7 | + 7 | 8 | unsafe { vlib/v/checker/tests/fixed_array_conv.vv:9:13: error: cannot use `[2]int` as `voidptr` in argument 1 to `memdup` - 7 | + 7 | 8 | unsafe { 9 | _ = memdup(arr, 1) | ~~~ 10 | _ = tos(arr, 1) 11 | fn (p &int){}(arr) -vlib/v/checker/tests/fixed_array_conv.vv:10:10: error: cannot use `[2]int` as `byteptr` in argument 1 to `tos` +vlib/v/checker/tests/fixed_array_conv.vv:10:10: error: cannot use `[2]int` as `&byte` in argument 1 to `tos` 8 | unsafe { 9 | _ = memdup(arr, 1) 10 | _ = tos(arr, 1) diff --git a/vlib/v/fmt/tests/fn_headers_with_no_bodies_keep.vv b/vlib/v/fmt/tests/fn_headers_with_no_bodies_keep.vv index c92fdba36d..98d04768d2 100644 --- a/vlib/v/fmt/tests/fn_headers_with_no_bodies_keep.vv +++ b/vlib/v/fmt/tests/fn_headers_with_no_bodies_keep.vv @@ -1,5 +1,5 @@ fn proc_pidpath(int, voidptr, int) int -fn C.realpath(charptr, charptr) &char +fn C.realpath(&char, &char) &char -fn C.chmod(byteptr, int) int +fn C.chmod(&byte, int) int diff --git a/vlib/v/fmt/tests/fn_with_anon_params_keep.vv b/vlib/v/fmt/tests/fn_with_anon_params_keep.vv index d5dab9ce08..ab6a13ab77 100644 --- a/vlib/v/fmt/tests/fn_with_anon_params_keep.vv +++ b/vlib/v/fmt/tests/fn_with_anon_params_keep.vv @@ -1 +1 @@ -fn C.PQgetvalue(voidptr, int, int) byteptr +fn C.PQgetvalue(voidptr, int, int) &byte diff --git a/vlib/v/gen/x64/gen.v b/vlib/v/gen/x64/gen.v index cff521002c..6d19e6ff60 100644 --- a/vlib/v/gen/x64/gen.v +++ b/vlib/v/gen/x64/gen.v @@ -666,7 +666,7 @@ fn (mut g Gen) stmt(node ast.Stmt) { if word.len != 2 { verror('opcodes format: xx xx xx xx') } - b := unsafe { C.strtol(charptr(word.str), 0, 16) } + b := unsafe { C.strtol(&char(word.str), 0, 16) } // b := word.byte() // println('"$word" $b') g.write8(b) diff --git a/vlib/v/util/util.v b/vlib/v/util/util.v index 2251424e33..c4b2884f9d 100644 --- a/vlib/v/util/util.v +++ b/vlib/v/util/util.v @@ -50,7 +50,7 @@ pub fn vhash() string { buf[0] = 0 unsafe { bp := &buf[0] - C.snprintf(charptr(bp), 50, '%s', C.V_COMMIT_HASH) + C.snprintf(&char(bp), 50, c'%s', C.V_COMMIT_HASH) return tos_clone(bp) } } @@ -119,7 +119,7 @@ pub fn githash(should_get_from_filesystem bool) string { buf[0] = 0 unsafe { bp := &buf[0] - C.snprintf(charptr(bp), 50, '%s', C.V_CURRENT_COMMIT_HASH) + C.snprintf(&char(bp), 50, c'%s', C.V_CURRENT_COMMIT_HASH) return tos_clone(bp) } }