strings.kai

#import kai("posix")
#import kai("arrays")

Equal :: fn(a, b: string) -> bool {
    if a.len != b.len return false

    for _, i in a {
        if a[i] != b[i] return false
    }
    return true
}

NulTerminate :: fn(s: *string) -> void {
    arrays.Append(s, 0)
    s.len += 1
}

FromCString :: fn(p: *u8) -> string {
    if p == nil return ""

    len := posix.strlen(p)

    s := []u8{}
    arrays.Reserve(&s, len + 1)
    s.raw = p
    s.len = len
    s.cap = len

    return bitcast(string) s
}

FromCStringCopy :: fn(p: *u8) -> string {
    if p == nil return ""

    len := posix.strlen(p)

    s := []u8{}
    arrays.Reserve(&s, len + 1)
    s.raw = posix.memcpy(s.raw, p, len + 1)
    s.len = len
    s.cap = len

    return s
}

#test "Equal" {
    assert(Equal("", ""))
    assert(Equal("Kai", "Kai"))
    assert(!Equal("1", "42"))
    assert(!Equal("Kai", "Swift"))
}

#test "NulTerminate" {
    str := "0"
    arrays.Append(&str, "1")
    str.raw[2] = 0xff
    NulTerminate(&str)
    assert(str.raw[2] == 0)
}

#test "FromCString" {
    cstring := "asdf".raw

    str := FromCString(cstring)
    assert(str.raw == cstring)
    assert(str.len == 4)
    assert(str.cap == 4)
}

#test "FromCStringCopy" {
    cstring := "asdf".raw

    str := FromCStringCopy(cstring)
    assert(str.raw != cstring)
    assert(str.len == 4)
    assert(str.cap == 4)
}