relibc/header/string/

mod.rs

//! `string.h` implementation.
//!
//! See <https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/string.h.html>.

use core::{iter::once, mem, ptr, slice};

use cbitset::BitSet256;

use crate::{
    header::{
        errno::{ENOMEM, ERANGE, STR_ERROR, STRERROR_MAX},
        signal,
    },
    iter::{NulTerminated, NulTerminatedInclusive, SrcDstPtrIter},
    platform::{
        self,
        types::{c_char, c_int, c_void, size_t},
    },
    raw_cell::RawCell,
};

use super::{bits_locale_t::locale_t, locale::THREAD_LOCALE};

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memccpy.html>.
///
/// # Safety
/// The caller must ensure that:
/// - `n` is not longer than the memory area pointed to by `s1`, and
/// - `n` is not longer than the memory area pointed to by `s2`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memccpy(
    s1: *mut c_void,
    s2: *const c_void,
    c: c_int,
    n: size_t,
) -> *mut c_void {
    let to = unsafe { memchr(s2, c, n) };
    let dist = if to.is_null() {
        n
    } else {
        ((to as usize) - (s2 as usize)) + 1
    };
    unsafe { memcpy(s1, s2, dist) };
    if to.is_null() {
        ptr::null_mut()
    } else {
        unsafe { s1.cast::<u8>().add(dist).cast::<c_void>() }
    }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memchr.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memchr(
    haystack: *const c_void,
    needle: c_int,
    len: size_t,
) -> *mut c_void {
    let haystack = unsafe { slice::from_raw_parts(haystack.cast::<u8>(), len) };

    match memchr::memchr(needle as u8, haystack) {
        Some(index) => haystack[index..].as_ptr() as *mut c_void,
        None => ptr::null_mut(),
    }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memcmp.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memcmp(s1: *const c_void, s2: *const c_void, n: size_t) -> c_int {
    let (div, rem) = (n / mem::size_of::<size_t>(), n % mem::size_of::<size_t>());
    let mut a = s1.cast::<usize>();
    let mut b = s2.cast::<usize>();
    for _ in 0..div {
        // SAFETY: `s1` and `s2` are `*const c_void`, which only guarantees byte
        // alignment. Hence `a` and `b` may be unaligned.
        if unsafe { a.read_unaligned() } != unsafe { b.read_unaligned() } {
            for i in 0..mem::size_of::<usize>() {
                let c = unsafe { *(a.cast::<u8>()).add(i) };
                let d = unsafe { *(b.cast::<u8>()).add(i) };
                if c != d {
                    return c_int::from(c) - c_int::from(d);
                }
            }
            unreachable!()
        }
        a = unsafe { a.offset(1) };
        b = unsafe { b.offset(1) };
    }

    let mut a = a.cast::<u8>();
    let mut b = b.cast::<u8>();
    for _ in 0..rem {
        if unsafe { *a } != unsafe { *b } {
            return c_int::from(unsafe { *a }) - c_int::from(unsafe { *b });
        }
        a = unsafe { a.offset(1) };
        b = unsafe { b.offset(1) };
    }
    0
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memcpy.html>.
///
/// # Safety
/// The caller must ensure that *either*:
/// - `n` is 0, *or*
///     - `s1` is convertible to a `&mut [MaybeUninit<u8>]` with length `n`,
///       and
///     - `s2` is convertible to a `&[MaybeUninit<u8>]` with length `n`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memcpy(s1: *mut c_void, s2: *const c_void, n: size_t) -> *mut c_void {
    for i in 0..n {
        unsafe { *s1.cast::<u8>().add(i) = *s2.cast::<u8>().add(i) };
    }
    s1
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memmem.html>.
///
/// # Safety
/// The caller must ensure that:
/// - `haystack` is convertible to a `&[u8]` with length `haystacklen`, and
/// - `needle` is convertible to a `&[u8]` with length `needlelen`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memmem(
    haystack: *const c_void,
    haystacklen: size_t,
    needle: *const c_void,
    needlelen: size_t,
) -> *mut c_void {
    match needlelen {
        // Required to satisfy spec (would otherwise cause .windows() to panic)
        0 => haystack,
        _ => {
            // SAFETY: the caller is required to ensure that the provided
            // pointers are valid.
            let haystack_slice =
                unsafe { slice::from_raw_parts(haystack.cast::<u8>(), haystacklen) };
            let needle_slice = unsafe { slice::from_raw_parts(needle.cast::<u8>(), needlelen) };

            // At this point, .windows() will receive a nonzero `needlelen` and
            // thus not panic.
            match haystack_slice
                .windows(needlelen)
                .find(|&haystack_window| haystack_window == needle_slice)
            {
                Some(match_slice) => match_slice.as_ptr().cast(),
                None => ptr::null(),
            }
        }
    }
    .cast_mut()
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memmove.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memmove(s1: *mut c_void, s2: *const c_void, n: size_t) -> *mut c_void {
    if s2 < s1.cast_const() {
        // copy from end
        let mut i = n;
        while i != 0 {
            i -= 1;
            unsafe { *s1.cast::<u8>().add(i) = *s2.cast::<u8>().add(i) };
        }
    } else {
        // copy from beginning
        let mut i = 0;
        while i < n {
            unsafe { *s1.cast::<u8>().add(i) = *s2.cast::<u8>().add(i) };
            i += 1;
        }
    }
    s1
}

/// Non-POSIX, see <https://www.man7.org/linux/man-pages/man3/memchr.3.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memrchr(
    haystack: *const c_void,
    needle: c_int,
    len: size_t,
) -> *mut c_void {
    let haystack = unsafe { slice::from_raw_parts(haystack.cast::<u8>(), len) };

    match memchr::memrchr(needle as u8, haystack) {
        Some(index) => haystack[index..].as_ptr() as *mut c_void,
        None => ptr::null_mut(),
    }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/memset.html>.
///
/// Copies `c` (converted to an unsigned char) into each of the first `n` bytes
/// of the object pointed to by `s`.
///
/// Returns `s`.
///
/// # Implementation
/// Casting of `c` may result in truncation.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn memset(s: *mut c_void, c: c_int, n: size_t) -> *mut c_void {
    for i in 0..n {
        unsafe { *s.cast::<u8>().add(i) = c as u8 };
    }
    s
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcpy.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn stpcpy(mut s1: *mut c_char, mut s2: *const c_char) -> *mut c_char {
    loop {
        unsafe { *s1 = *s2 };

        if unsafe { *s1 } == 0 {
            break;
        }

        s1 = unsafe { s1.add(1) };
        s2 = unsafe { s2.add(1) };
    }

    s1
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strncpy.html>.
///
/// Copies not more than `n` bytes (bytes that follow a NUL character are not
/// copied) from the array pointed to by `s2` to the array pointed to by `s1`.
///
/// If the array pointed to by `s2` is a string that is shorter than `n` bytes,
/// NUL characters shall be appended to the copy in the array pointed to by
/// `s1`, until `n` bytes in all are written.
///
/// If any NUL characters are written to the destination, returns the address
/// of the first such NUL character. If no NUL characters are written to the
/// destination, returns `&s1[n]`.
///
/// # Safety
/// If copying takes place between objects that overlap, the behaviour is
/// undefined.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn stpncpy(
    mut s1: *mut c_char,
    mut s2: *const c_char,
    mut n: size_t,
) -> *mut c_char {
    while n > 0 {
        unsafe { *s1 = *s2 };

        if unsafe { *s1 } == 0 {
            break;
        }

        n -= 1;
        s1 = unsafe { s1.add(1) };
        s2 = unsafe { s2.add(1) };
    }

    unsafe { memset(s1.cast(), 0, n) };

    s1
}

/// Non-POSIX, see <https://www.man7.org/linux/man-pages/man3/strstr.3.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcasestr(haystack: *const c_char, needle: *const c_char) -> *mut c_char {
    unsafe { inner_strstr(haystack, needle, !32) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcat.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcat(s1: *mut c_char, s2: *const c_char) -> *mut c_char {
    unsafe { strncat(s1, s2, usize::MAX) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strchr.html>.
///
/// # Safety
/// The caller is required to ensure that `s` is a valid pointer to a buffer
/// containing at least one nul value. The pointed-to buffer must not be
/// modified for the duration of the call.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strchr(s: *const c_char, c: c_int) -> *mut c_char {
    let c_as_c_char = c as c_char;

    // We iterate over non-mut references and thus need to coerce the
    // resulting reference via a *const pointer before we can get our *mut.
    // SAFETY: the caller is required to ensure that s points to a valid
    // nul-terminated buffer.
    let ptr: *const c_char =
        match unsafe { NulTerminatedInclusive::new(s) }.find(|&&sc| sc == c_as_c_char) {
            Some(sc_ref) => sc_ref,
            None => ptr::null(),
        };
    ptr.cast_mut()
}

/// Non-POSIX, see <https://man7.org/linux/man-pages/man3/strchr.3.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strchrnul(s: *const c_char, c: c_int) -> *mut c_char {
    let mut s = s.cast_mut();
    loop {
        if unsafe { *s } == c as _ {
            break;
        }
        if unsafe { *s } == 0 {
            break;
        }
        s = unsafe { s.add(1) };
    }
    s
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcmp.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcmp(s1: *const c_char, s2: *const c_char) -> c_int {
    unsafe { strncmp(s1, s2, usize::MAX) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcoll_l.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcoll_l(s1: *const c_char, s2: *const c_char, _loc: locale_t) -> c_int {
    // relibc has no locale stuff (yet)
    unsafe { strcmp(s1, s2) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcoll.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcoll(s1: *const c_char, s2: *const c_char) -> c_int {
    unsafe { strcoll_l(s1, s2, THREAD_LOCALE as locale_t) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcpy.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char {
    let src_iter = unsafe { NulTerminated::new(src).unwrap() };
    let src_dest_iter = unsafe { SrcDstPtrIter::new(src_iter.chain(once(&0)), dst) };
    for (src_item, dst_item) in src_dest_iter {
        dst_item.write(*src_item);
    }

    dst
}

pub unsafe fn inner_strspn(s1: *const c_char, s2: *const c_char, cmp: bool) -> size_t {
    let mut s1 = s1.cast::<u8>();
    let mut s2 = s2.cast::<u8>();

    // The below logic is effectively ripped from the musl implementation. It
    // works by placing each byte as it's own bit in an array of numbers. Each
    // number can hold up to 8 * mem::size_of::<usize>() bits. We need 256 bits
    // in total, to fit one byte.

    let mut set = BitSet256::new();

    while unsafe { *s2 } != 0 {
        set.insert(unsafe { *s2 } as usize);
        s2 = unsafe { s2.offset(1) };
    }

    let mut i = 0;
    while unsafe { *s1 } != 0 {
        if set.contains(unsafe { *s1 } as usize) != cmp {
            break;
        }
        i += 1;
        s1 = unsafe { s1.offset(1) };
    }
    i
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcspn.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcspn(s1: *const c_char, s2: *const c_char) -> size_t {
    unsafe { inner_strspn(s1, s2, false) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strdup.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strdup(s1: *const c_char) -> *mut c_char {
    unsafe { strndup(s1, usize::MAX) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strerror_l.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strerror_l(errnum: c_int, _loc: locale_t) -> *mut c_char {
    use core::fmt::Write;

    static STRERROR_BUF: RawCell<[c_char; STRERROR_MAX]> = RawCell::new([0; STRERROR_MAX]);
    let strerror_ptr = unsafe { STRERROR_BUF.unsafe_mut().as_mut_ptr() };
    let mut w = platform::StringWriter(strerror_ptr, STRERROR_MAX);

    let _ = match STR_ERROR.get(errnum as usize) {
        Some(e) => w.write_str(e),
        None => w.write_fmt(format_args!("Unknown error {}", errnum)),
    };

    strerror_ptr
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strerror.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strerror(errnum: c_int) -> *mut c_char {
    unsafe { strerror_l(errnum, THREAD_LOCALE as locale_t) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strerror_r.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t) -> c_int {
    let msg = unsafe { strerror(errnum) };
    let len = unsafe { strlen(msg) };

    if len >= buflen {
        if buflen != 0 {
            unsafe { memcpy(buf.cast::<c_void>(), msg as *const c_void, buflen - 1) };
            unsafe { *buf.add(buflen - 1) = 0 };
        }
        return ERANGE as c_int;
    }
    unsafe { memcpy(buf.cast::<c_void>(), msg as *const c_void, len + 1) };

    0
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strlcat.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strlcat(dst: *mut c_char, src: *const c_char, dstsize: size_t) -> size_t {
    let dst_len = unsafe { strnlen(dst, dstsize) };
    let d = unsafe { dst.add(dst_len) };
    let src_len = unsafe { strlcpy(d, src, dstsize - dst_len) };
    src_len + if dst_len > dstsize { dstsize } else { dst_len }
}

/// Non-POSIX, see <https://www.man7.org/linux/man-pages/man3/strsep.3.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strsep(str_: *mut *mut c_char, sep: *const c_char) -> *mut c_char {
    let s = unsafe { *str_ };
    if s.is_null() {
        return ptr::null_mut();
    }
    let mut end = unsafe { s.add(strcspn(s, sep)) };
    if unsafe { *end } != 0 {
        unsafe { *end = 0 };
        end = unsafe { end.add(1) };
    } else {
        end = ptr::null_mut();
    }
    unsafe { *str_ = end };
    s
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strlcat.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strlcpy(dst: *mut c_char, src: *const c_char, dstsize: size_t) -> size_t {
    let mut i = 0;

    if dstsize != 0 {
        while unsafe { *src.add(i) } != 0 && i < dstsize - 1 {
            unsafe {
                *dst.add(i) = *src.add(i);
            }
            i += 1;
        }
        unsafe {
            *dst.add(i) = 0;
        }
    }

    while unsafe { *src.add(i) } != 0 {
        i += 1;
    }

    i as size_t
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strlen.html>.
///
/// Returns the number of bytes in the string to which `s` points, not
/// including the `NUL` character.
///
/// Always successful. The return value never represents an error.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strlen(s: *const c_char) -> size_t {
    unsafe { NulTerminated::new(s) }
        .map(|s| s.count())
        .unwrap_or(0)
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strncat.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strncat(s1: *mut c_char, s2: *const c_char, n: size_t) -> *mut c_char {
    let len = unsafe { strlen(s1.cast()) };
    let mut i = 0;
    while i < n {
        let b = unsafe { *s2.add(i) };
        if b == 0 {
            break;
        }

        unsafe { *s1.add(len + i) = b };
        i += 1;
    }
    unsafe { *s1.add(len + i) = 0 };

    s1
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strncmp.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strncmp(s1: *const c_char, s2: *const c_char, n: size_t) -> c_int {
    for i in 0..n {
        // These must be cast as u8 to have correct comparisons
        let a = unsafe { *s1.add(i) } as u8;
        let b = unsafe { *s2.add(i) } as u8;
        if a != b || a == 0 {
            return c_int::from(a) - c_int::from(b);
        }
    }

    0
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strncpy.html>.
///
/// Copies not more than `n` bytes (bytes that follow a NUL character are not
/// copied) from the array pointed to by `s2` to the array pointed to by `s1`.
///
/// If the array pointed to by `s2` is a string that is shorter than `n` bytes,
/// NUL characters shall be appended to the copy in the array pointed to by
/// `s1`, until `n` bytes in all are written.
///
/// Returns `s1`.
///
/// # Implementation
/// Simply calls `stpncpy` and returns `s1`.
///
/// # Safety
/// If copying takes place between objects that overlap, the behaviour is
/// undefined.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strncpy(s1: *mut c_char, s2: *const c_char, n: size_t) -> *mut c_char {
    unsafe { stpncpy(s1, s2, n) };
    s1
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strdup.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strndup(s1: *const c_char, size: size_t) -> *mut c_char {
    let len = unsafe { strnlen(s1, size) };

    // the "+ 1" is to account for the NUL byte
    let buffer = unsafe { platform::alloc(len + 1) }.cast::<c_char>();
    if buffer.is_null() {
        platform::ERRNO.set(ENOMEM as c_int);
    } else {
        //memcpy(buffer, s1, len)
        for i in 0..len {
            unsafe { *buffer.add(i) = *s1.add(i) };
        }
        unsafe { *buffer.add(len) = 0 };
    }

    buffer
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strlen.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strnlen(s: *const c_char, size: size_t) -> size_t {
    unsafe { NulTerminated::new(s).unwrap() }.take(size).count()
}

/// Non-POSIX, see <https://en.cppreference.com/w/c/string/byte/strlen>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strnlen_s(s: *const c_char, size: size_t) -> size_t {
    if s.is_null() {
        0
    } else {
        unsafe { strnlen(s, size) }
    }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strpbrk.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strpbrk(s1: *const c_char, s2: *const c_char) -> *mut c_char {
    let p = unsafe { s1.add(strcspn(s1, s2)) };
    if unsafe { *p } != 0 {
        p.cast_mut()
    } else {
        ptr::null_mut()
    }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strrchr.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strrchr(s: *const c_char, c: c_int) -> *mut c_char {
    let len = unsafe { strlen(s) } as isize;
    let c = c as c_char;
    let mut i = len - 1;
    while i >= 0 {
        if unsafe { *s.offset(i) } == c {
            return unsafe { s.offset(i) }.cast_mut();
        }
        i -= 1;
    }
    ptr::null_mut()
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strsignal.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strsignal(sig: c_int) -> *mut c_char {
    signal::SIGNAL_STRINGS
        .get(sig as usize)
        .unwrap_or(&signal::SIGNAL_STRINGS[0]) // Unknown signal message
        .as_ptr() as *mut c_char
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strspn.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strspn(s1: *const c_char, s2: *const c_char) -> size_t {
    unsafe { inner_strspn(s1, s2, true) }
}

unsafe fn inner_strstr(
    mut haystack: *const c_char,
    needle: *const c_char,
    mask: c_char,
) -> *mut c_char {
    while unsafe { *haystack } != 0 {
        let mut i = 0;
        loop {
            if unsafe { *needle.offset(i) } == 0 {
                // We reached the end of the needle, everything matches this far
                return haystack.cast_mut();
            }
            if unsafe { *haystack.offset(i) } & mask != unsafe { *needle.offset(i) } & mask {
                break;
            }

            i += 1;
        }

        haystack = unsafe { haystack.offset(1) };
    }
    ptr::null_mut()
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strstr.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strstr(haystack: *const c_char, needle: *const c_char) -> *mut c_char {
    unsafe { inner_strstr(haystack, needle, !0) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strtok.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strtok(s1: *mut c_char, delimiter: *const c_char) -> *mut c_char {
    static mut HAYSTACK: *mut c_char = ptr::null_mut();
    unsafe { strtok_r(s1, delimiter, &raw mut HAYSTACK) }
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strtok.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strtok_r(
    s: *mut c_char,
    delimiter: *const c_char,
    lasts: *mut *mut c_char,
) -> *mut c_char {
    // musl returns null if both s and lasts are null, it sets s to lasts otherwise
    let mut haystack = s;
    if haystack.is_null() {
        if (unsafe { *lasts }).is_null() {
            return ptr::null_mut();
        }
        haystack = unsafe { *lasts };
    }

    // Skip past any extra delimiter left over from previous call
    haystack = unsafe { haystack.add(strspn(haystack, delimiter)) };
    if unsafe { *haystack } == 0 {
        unsafe { *lasts = haystack };
        return ptr::null_mut();
    }

    // Build token by injecting null byte into delimiter
    let token = haystack;
    haystack = unsafe { strpbrk(token, delimiter) };
    if !haystack.is_null() {
        unsafe { haystack.write(0) };
        haystack = unsafe { haystack.add(1) };
        unsafe { *lasts = haystack };
    } else {
        unsafe { *lasts = token.add(strlen(token)) };
    }

    token
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strxfrm_l.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strxfrm_l(
    s1: *mut c_char,
    s2: *const c_char,
    n: size_t,
    _loc: locale_t,
) -> size_t {
    // relibc has no locale stuff (yet)
    let len = unsafe { strlen(s2) };
    if len < n {
        unsafe { strcpy(s1, s2) };
    }
    len
}

/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strxfrm.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strxfrm(s1: *mut c_char, s2: *const c_char, n: size_t) -> size_t {
    unsafe { strxfrm_l(s1, s2, n, THREAD_LOCALE as locale_t) }
}