98 lines
1.8 KiB
V
98 lines
1.8 KiB
V
module builtin
|
|
|
|
// String: This is a minimal implementation of the "string" builtin until the WASM backend
|
|
// is able to compile the original builtin implementation
|
|
|
|
pub struct string {
|
|
pub:
|
|
str &u8
|
|
len int
|
|
}
|
|
|
|
// Concatenation operator: var += str / str + str
|
|
// Note: This will alloc a new string with the content of these two strings
|
|
pub fn (s string) + (other string) string {
|
|
if s.len == 0 {
|
|
return other
|
|
}
|
|
if other.len == 0 {
|
|
return s
|
|
}
|
|
total_len := s.len + other.len
|
|
result_ptr := unsafe { malloc(total_len) }
|
|
if result_ptr == 0 {
|
|
panic('string.+: malloc failed')
|
|
}
|
|
unsafe {
|
|
vmemcpy(result_ptr, s.str, s.len)
|
|
vmemcpy(result_ptr + s.len, other.str, other.len)
|
|
}
|
|
return string{
|
|
str: result_ptr
|
|
len: total_len
|
|
}
|
|
}
|
|
|
|
// Equality comparison: checks if two strings are identical
|
|
pub fn (s string) == (other string) bool {
|
|
if s.len != other.len {
|
|
return false
|
|
}
|
|
|
|
for i in 0 .. s.len {
|
|
if s[i] != other[i] {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Less-than comparison: lexicographically compares two strings
|
|
pub fn (s string) < (other string) bool {
|
|
// Taken from the C Backend
|
|
for i in 0 .. s.len {
|
|
if i >= other.len || s[i] > other[i] {
|
|
return false
|
|
} else if s[i] < other[i] {
|
|
return true
|
|
}
|
|
}
|
|
if s.len < other.len {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// at returns the byte at index `idx`.
|
|
// Example: assert 'ABC'.at(1) == u8(`B`)
|
|
// NOTE: Adapted from C built-in, modified for WASM
|
|
pub fn (s string) at(idx int) u8 {
|
|
$if !no_bounds_checking {
|
|
if idx < 0 || idx >= s.len {
|
|
panic('string index out of range')
|
|
}
|
|
}
|
|
return unsafe { s.str[idx] }
|
|
}
|
|
|
|
// Convert C string to V string
|
|
pub fn cstring_to_vstring(ptr &u8) string {
|
|
if ptr == 0 {
|
|
return ''
|
|
}
|
|
|
|
mut len := 0
|
|
unsafe {
|
|
for ptr[len] != 0 {
|
|
len++
|
|
}
|
|
}
|
|
unsafe {
|
|
return string{
|
|
str: ptr
|
|
len: len
|
|
}
|
|
}
|
|
}
|