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)
}
}