1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/builtin/linux_bare/libc_impl.v

169 lines
3.1 KiB
V
Raw Normal View History

module builtin
import dlmalloc
__global global_allocator dlmalloc.Dlmalloc
[unsafe]
2021-09-08 13:09:32 +03:00
pub fn memcpy(dest &C.void, src &C.void, n usize) &C.void {
2022-04-15 14:58:56 +03:00
dest_ := unsafe { &u8(dest) }
src_ := unsafe { &u8(src) }
unsafe {
2021-04-17 02:38:41 +03:00
for i in 0 .. int(n) {
dest_[i] = src_[i]
}
}
return unsafe { dest }
}
[export: 'malloc']
[unsafe]
2021-09-08 13:09:32 +03:00
fn __malloc(n usize) &C.void {
return unsafe { global_allocator.malloc(n) }
}
[unsafe]
2021-09-08 13:09:32 +03:00
fn strlen(_s &C.void) usize {
2022-04-15 14:58:56 +03:00
s := unsafe { &u8(_s) }
mut i := 0
for ; unsafe { s[i] } != 0; i++ {}
2021-09-08 13:09:32 +03:00
return usize(i)
}
[unsafe]
2021-09-08 13:09:32 +03:00
fn realloc(old_area &C.void, new_size usize) &C.void {
if old_area == 0 {
2021-04-17 02:38:41 +03:00
return unsafe { malloc(int(new_size)) }
}
2021-09-08 13:09:32 +03:00
if new_size == usize(0) {
unsafe { free(old_area) }
return 0
}
old_size := unsafe { *(&u64(old_area - sizeof(u64))) }
2021-04-17 02:38:41 +03:00
if u64(new_size) <= old_size {
return unsafe { old_area }
} else {
2021-04-17 02:38:41 +03:00
new_area := unsafe { malloc(int(new_size)) }
2021-09-08 13:09:32 +03:00
unsafe { memmove(new_area, old_area, usize(old_size)) }
unsafe { free(old_area) }
return new_area
}
}
[unsafe]
2021-09-08 13:09:32 +03:00
fn memset(s &C.void, c int, n usize) &C.void {
2021-04-17 02:38:41 +03:00
mut s_ := unsafe { &char(s) }
for i in 0 .. int(n) {
unsafe {
2021-04-17 02:38:41 +03:00
s_[i] = char(c)
}
}
return unsafe { s }
}
[unsafe]
2021-09-08 13:09:32 +03:00
fn memmove(dest &C.void, src &C.void, n usize) &C.void {
2022-04-15 14:58:56 +03:00
dest_ := unsafe { &u8(dest) }
src_ := unsafe { &u8(src) }
2021-04-17 02:38:41 +03:00
mut temp_buf := unsafe { malloc(int(n)) }
for i in 0 .. int(n) {
unsafe {
2021-04-17 02:38:41 +03:00
temp_buf[i] = src_[i]
}
}
for i in 0 .. int(n) {
unsafe {
2021-04-17 02:38:41 +03:00
dest_[i] = temp_buf[i]
}
}
unsafe { free(temp_buf) }
return unsafe { dest }
}
[export: 'calloc']
[unsafe]
2021-09-08 13:09:32 +03:00
fn __calloc(nmemb usize, size usize) &C.void {
2021-04-17 02:38:41 +03:00
new_area := unsafe { malloc(int(nmemb) * int(size)) }
unsafe { memset(new_area, 0, nmemb * size) }
return new_area
}
fn getchar() int {
2022-04-15 14:58:56 +03:00
x := u8(0)
2021-04-17 02:38:41 +03:00
sys_read(0, &x, 1)
return int(x)
}
2021-09-08 13:09:32 +03:00
fn memcmp(a &C.void, b &C.void, n usize) int {
2022-04-15 14:58:56 +03:00
a_ := unsafe { &u8(a) }
b_ := unsafe { &u8(b) }
for i in 0 .. int(n) {
2021-04-17 02:38:41 +03:00
if unsafe { a_[i] != b_[i] } {
unsafe {
2021-04-17 02:38:41 +03:00
return a_[i] - b_[i]
}
}
}
return 0
}
[export: 'free']
[unsafe]
2021-04-17 02:38:41 +03:00
fn __free(ptr &C.void) {
unsafe {
global_allocator.free_(ptr)
}
}
fn vsprintf(str &char, format &char, ap &byte) int {
panic('vsprintf(): string interpolation is not supported in `-freestanding`')
}
2021-09-08 13:09:32 +03:00
fn vsnprintf(str &char, size usize, format &char, ap &byte) int {
panic('vsnprintf(): string interpolation is not supported in `-freestanding`')
}
// not really needed
fn bare_read(buf &byte, count u64) (i64, Errno) {
return sys_read(0, buf, count)
}
pub fn bare_print(buf &byte, len u64) {
sys_write(1, buf, len)
}
fn bare_eprint(buf &byte, len u64) {
sys_write(2, buf, len)
}
2021-04-17 02:38:41 +03:00
2021-06-23 13:18:17 +03:00
pub fn write(fd i64, buf &byte, count u64) i64 {
x, _ := sys_write(fd, buf, count)
return x
}
[noreturn]
2021-04-17 02:38:41 +03:00
fn bare_panic(msg string) {
println('V panic' + msg)
exit(1)
}
fn bare_backtrace() string {
return 'backtraces are not available with `-freestanding`'
}
[export: 'exit']
[noreturn]
2021-04-17 02:38:41 +03:00
fn __exit(code int) {
sys_exit(code)
}
[export: 'qsort']
2021-09-08 13:09:32 +03:00
fn __qsort(base voidptr, nmemb usize, size usize, sort_cb FnSortCB) {
panic('qsort() is not yet implemented in `-freestanding`')
}
fn init_global_allocator() {
global_allocator = dlmalloc.new(get_linux_allocator())
}