mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

all: make u8 the primary type, byte the alias

Browse Source
This commit is contained in:
Alexander Medvednikov
2022-04-15 13:43:03 +03:00
parent 566f150b24
commit e6ff1508d2
7 changed files with 45 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
vlib/builtin/array.v
View File

@ -172,9 +172,9 @@ pub fn (a array) repeat_to_depth(count int, depth int) array {
for i in 0 .. count {
if depth > 0 {
ary_clone := unsafe { a.clone_to_depth(depth) }
unsafe { vmemcpy(arr.get_unsafe(i * a.len), &byte(ary_clone.data), a.len * a.element_size) }
unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(ary_clone.data), a.len * a.element_size) }
} else {
unsafe { vmemcpy(arr.get_unsafe(i * a.len), &byte(a.data), a.len * a.element_size) }
unsafe { vmemcpy(arr.get_unsafe(i * a.len), &u8(a.data), a.len * a.element_size) }
}
}
}
@ -286,7 +286,7 @@ pub fn (mut a array) delete_many(i int, size int) {
}
if a.flags.all(.noshrink | .noslices) {
unsafe {
vmemmove(&byte(a.data) + i * a.element_size, &byte(a.data) + (i + size) * a.element_size,
vmemmove(&u8(a.data) + i * a.element_size, &u8(a.data) + (i + size) * a.element_size,
(a.len - i - size) * a.element_size)
}
a.len -= size
@ -300,7 +300,7 @@ pub fn (mut a array) delete_many(i int, size int) {
a.data = vcalloc(new_cap * a.element_size)
unsafe { vmemcpy(a.data, old_data, i * a.element_size) }
unsafe {
vmemcpy(&byte(a.data) + i * a.element_size, &byte(old_data) + (i + size) * a.element_size,
vmemcpy(&u8(a.data) + i * a.element_size, &u8(old_data) + (i + size) * a.element_size,
(a.len - i - size) * a.element_size)
}
if a.flags.has(.noslices) {
@ -344,7 +344,7 @@ pub fn (mut a array) drop(num int) {
}
n := if num <= a.len { num } else { a.len }
blen := n * a.element_size
a.data = unsafe { &byte(a.data) + blen }
a.data = unsafe { &u8(a.data) + blen }
a.offset += blen
a.len -= n
a.cap -= n
@ -354,7 +354,7 @@ pub fn (mut a array) drop(num int) {
[inline; unsafe]
fn (a array) get_unsafe(i int) voidptr {
unsafe {
return &byte(a.data) + i * a.element_size
return &u8(a.data) + i * a.element_size
}
}
@ -366,7 +366,7 @@ fn (a array) get(i int) voidptr {
}
}
unsafe {
return &byte(a.data) + i * a.element_size
return &u8(a.data) + i * a.element_size
}
}
@ -376,7 +376,7 @@ fn (a array) get_with_check(i int) voidptr {
return 0
}
unsafe {
return &byte(a.data) + i * a.element_size
return &u8(a.data) + i * a.element_size
}
}
@ -402,7 +402,7 @@ pub fn (a array) last() voidptr {
}
}
unsafe {
return &byte(a.data) + (a.len - 1) * a.element_size
return &u8(a.data) + (a.len - 1) * a.element_size
}
}
@ -429,7 +429,7 @@ pub fn (mut a array) pop() voidptr {
}
}
new_len := a.len - 1
last_elem := unsafe { &byte(a.data) + new_len * a.element_size }
last_elem := unsafe { &u8(a.data) + new_len * a.element_size }
a.len = new_len
// Note: a.cap is not changed here *on purpose*, so that
// further << ops on that array will be more efficient.
@ -475,7 +475,7 @@ fn (a array) slice(start int, _end int) array {
// TODO: integrate reference counting
// a.flags.clear(.noslices)
offset := start * a.element_size
data := unsafe { &byte(a.data) + offset }
data := unsafe { &u8(a.data) + offset }
l := end - start
res := array{
element_size: a.element_size
@ -527,7 +527,7 @@ fn (a array) slice_ni(_start int, _end int) array {
}
offset := start * a.element_size
data := unsafe { &byte(a.data) + offset }
data := unsafe { &u8(a.data) + offset }
l := end - start
res := array{
element_size: a.element_size
@ -583,7 +583,7 @@ pub fn (a &array) clone_to_depth(depth int) array {
return arr
} else {
if !isnil(a.data) {
unsafe { vmemcpy(&byte(arr.data), a.data, a.cap * a.element_size) }
unsafe { vmemcpy(&u8(arr.data), a.data, a.cap * a.element_size) }
}
return arr
}
@ -592,7 +592,7 @@ pub fn (a &array) clone_to_depth(depth int) array {
// we manually inline this for single operations for performance without -prod
[inline; unsafe]
fn (mut a array) set_unsafe(i int, val voidptr) {
unsafe { vmemcpy(&byte(a.data) + a.element_size * i, val, a.element_size) }
unsafe { vmemcpy(&u8(a.data) + a.element_size * i, val, a.element_size) }
}
// Private function. Used to implement assigment to the array element.
@ -602,14 +602,14 @@ fn (mut a array) set(i int, val voidptr) {
panic('array.set: index out of range (i == $i, a.len == $a.len)')
}
}
unsafe { vmemcpy(&byte(a.data) + a.element_size * i, val, a.element_size) }
unsafe { vmemcpy(&u8(a.data) + a.element_size * i, val, a.element_size) }
}
fn (mut a array) push(val voidptr) {
if a.len >= a.cap {
a.ensure_cap(a.len + 1)
}
unsafe { vmemcpy(&byte(a.data) + a.element_size * a.len, val, a.element_size) }
unsafe { vmemcpy(&u8(a.data) + a.element_size * a.len, val, a.element_size) }
a.len++
}
@ -641,10 +641,10 @@ pub fn (mut a array) reverse_in_place() {
unsafe {
mut tmp_value := malloc(a.element_size)
for i in 0 .. a.len / 2 {
vmemcpy(tmp_value, &byte(a.data) + i * a.element_size, a.element_size)
vmemcpy(&byte(a.data) + i * a.element_size, &byte(a.data) +
vmemcpy(tmp_value, &u8(a.data) + i * a.element_size, a.element_size)
vmemcpy(&u8(a.data) + i * a.element_size, &u8(a.data) +
(a.len - 1 - i) * a.element_size, a.element_size)
vmemcpy(&byte(a.data) + (a.len - 1 - i) * a.element_size, tmp_value, a.element_size)
vmemcpy(&u8(a.data) + (a.len - 1 - i) * a.element_size, tmp_value, a.element_size)
}
free(tmp_value)
}
@ -676,7 +676,7 @@ pub fn (a &array) free() {
// if a.is_slice {
// return
// }
mblock_ptr := &byte(u64(a.data) - u64(a.offset))
mblock_ptr := &u8(u64(a.data) - u64(a.offset))
unsafe { free(mblock_ptr) }
}
@ -845,12 +845,12 @@ pub fn (b []byte) hex() string {
for i in b {
n0 := i >> 4
unsafe {
hex[dst_i] = if n0 < 10 { n0 + `0` } else { n0 + byte(87) }
hex[dst_i] = if n0 < 10 { n0 + `0` } else { n0 + u8(87) }
dst_i++
}
n1 := i & 0xF
unsafe {
hex[dst_i] = if n1 < 10 { n1 + `0` } else { n1 + byte(87) }
hex[dst_i] = if n1 < 10 { n1 + `0` } else { n1 + u8(87) }
dst_i++
}
}
@ -868,7 +868,7 @@ pub fn (b []byte) hex() string {
pub fn copy(mut dst []byte, src []byte) int {
min := if dst.len < src.len { dst.len } else { src.len }
if min > 0 {
unsafe { vmemmove(&byte(dst.data), src.data, min) }
unsafe { vmemmove(&u8(dst.data), src.data, min) }
}
return min
}

12
vlib/builtin/builtin.c.v
View File

@ -111,7 +111,7 @@ pub fn c_error_number_str(errnum int) string {
$if !vinix {
c_msg := C.strerror(errnum)
err_msg = string{
str: &byte(c_msg)
str: &u8(c_msg)
len: unsafe { C.strlen(c_msg) }
is_lit: 1
}
@ -284,7 +284,7 @@ pub fn malloc(n int) &byte {
C.fprintf(C.stderr, c'_v_malloc %6d total %10d\n', n, total_m)
// print_backtrace()
}
mut res := &byte(0)
mut res := &u8(0)
$if prealloc {
return unsafe { prealloc_malloc(n) }
} $else $if gcboehm ? {
@ -327,7 +327,7 @@ pub fn malloc_noscan(n int) &byte {
C.fprintf(C.stderr, c'malloc_noscan %6d total %10d\n', n, total_m)
// print_backtrace()
}
mut res := &byte(0)
mut res := &u8(0)
$if prealloc {
return unsafe { prealloc_malloc(n) }
} $else $if gcboehm ? {
@ -365,7 +365,7 @@ pub fn v_realloc(b &byte, n int) &byte {
$if trace_realloc ? {
C.fprintf(C.stderr, c'v_realloc %6d\n', n)
}
mut new_ptr := &byte(0)
mut new_ptr := &u8(0)
$if prealloc {
unsafe {
new_ptr = malloc(n)
@ -417,7 +417,7 @@ pub fn realloc_data(old_data &byte, old_size int, new_size int) &byte {
return new_ptr
}
}
mut nptr := &byte(0)
mut nptr := &u8(0)
$if gcboehm ? {
nptr = unsafe { C.GC_REALLOC(old_data, new_size) }
} $else {
@ -436,7 +436,7 @@ pub fn vcalloc(n int) &byte {
if n < 0 {
panic('calloc($n < 0)')
} else if n == 0 {
return &byte(0)
return &u8(0)
}
$if trace_vcalloc ? {
total_m += n

3
vlib/builtin/int.v
View File

@ -7,7 +7,8 @@ module builtin
// ----- value to string functions -----
//
type u8 = byte
//type u8 = byte
type byte = u8
type i32 = int
// ptr_str returns the address of `ptr` as a `string`.