WebSVN – HelenOS – Diff – /branches/network/kernel/generic/src/lib/string.c


/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup generic
 * @{
 */
 
/**
 * @file
 * @brief String functions.
 *
 * Strings and characters use the Universal Character Set (UCS). The standard
 * strings, called just strings are encoded in UTF-8. Wide strings (encoded
 * in UTF-32) are supported to a limited degree. A single character is
 * represented as wchar_t.@n
 *
 * Overview of the terminology:@n
 *
 *  Term                  Meaning
 *  --------------------  ----------------------------------------------------
 *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
 *
 *  character             UTF-32 encoded Unicode character, stored in wchar_t
 *                        (signed 32 bit integer), code points 0 .. 1114111
 *                        are valid
 *
 *  ASCII character       7 bit encoded ASCII character, stored in char
 *                        (usually signed 8 bit integer), code points 0 .. 127
 *                        are valid
 *
 *  string                UTF-8 encoded NULL-terminated Unicode string, char *
 *
 *  wide string           UTF-32 encoded NULL-terminated Unicode string,
 *                        wchar_t *
 *
 *  [wide] string size    number of BYTES in a [wide] string (excluding
 *                        the NULL-terminator), size_t
 *
 *  [wide] string length  number of CHARACTERS in a [wide] string (excluding
 *                        the NULL-terminator), count_t
 *
 *  [wide] string width   number of display cells on a monospace display taken
 *                        by a [wide] string, count_t
 *
 *
 * Overview of string metrics:@n
 *
 *  Metric  Abbrev.  Type     Meaning
 *  ------  ------   ------   -------------------------------------------------
 *  size    n        size_t   number of BYTES in a string (excluding the
 *                            NULL-terminator)
 *
 *  length  l        count_t  number of CHARACTERS in a string (excluding the
 *                            null terminator)
 *
 *  width  w         count_t  number of display cells on a monospace display
 *                            taken by a string
 *
 *
 * Function naming prefixes:@n
 *
 *  chr_    operate on characters
 *  ascii_  operate on ASCII characters
 *  str_    operate on strings
 *  wstr_   operate on wide strings
 *
 *  [w]str_[n|l|w]  operate on a prefix limited by size, length
 *                  or width
 *
 *
 * A specific character inside a [wide] string can be referred to by:@n
 *
 *  pointer (char *, wchar_t *)
 *  byte offset (size_t)
 *  character index (count_t)
 *
 */
 
#include <string.h>
#include <print.h>
#include <cpu.h>
#include <arch/asm.h>
#include <arch.h>
#include <errno.h>
#include <align.h>
#include <debug.h>
 
/** Byte mask consisting of lowest @n bits (out of 8) */
#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
 
/** Byte mask consisting of lowest @n bits (out of 32) */
#define LO_MASK_32(n)  ((uint32_t) ((1 << (n)) - 1))
 
/** Byte mask consisting of highest @n bits (out of 8) */
#define HI_MASK_8(n)  (~LO_MASK_8(8 - (n)))
 
/** Number of data bits in a UTF-8 continuation byte */
#define CONT_BITS  6
 
/** Decode a single character from a string.
 *
 * Decode a single character from a string of size @a size. Decoding starts
 * at @a offset and this offset is moved to the beginning of the next
 * character. In case of decoding error, offset generally advances at least
 * by one. However, offset is never moved beyond size.
 *
 * @param str    String (not necessarily NULL-terminated).
 * @param offset Byte offset in string where to start decoding.
 * @param size   Size of the string (in bytes).
 *
 * @return Value of decoded character, U_SPECIAL on decoding error or
 *         NULL if attempt to decode beyond @a size.
 *
 */
wchar_t str_decode(const char *str, size_t *offset, size_t size)
{
    if (*offset + 1 > size)
        return 0;
   
    /* First byte read from string */
    uint8_t b0 = (uint8_t) str[(*offset)++];
   
    /* Determine code length */
   
    unsigned int b0_bits;  /* Data bits in first byte */
    unsigned int cbytes;   /* Number of continuation bytes */
   
    if ((b0 & 0x80) == 0) {
        /* 0xxxxxxx (Plain ASCII) */
        b0_bits = 7;
        cbytes = 0;
    } else if ((b0 & 0xe0) == 0xc0) {
        /* 110xxxxx 10xxxxxx */
        b0_bits = 5;
        cbytes = 1;
    } else if ((b0 & 0xf0) == 0xe0) {
        /* 1110xxxx 10xxxxxx 10xxxxxx */
        b0_bits = 4;
        cbytes = 2;
    } else if ((b0 & 0xf8) == 0xf0) {
        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
        b0_bits = 3;
        cbytes = 3;
    } else {
        /* 10xxxxxx -- unexpected continuation byte */
        return U_SPECIAL;
    }
   
    if (*offset + cbytes > size)
        return U_SPECIAL;
   
    wchar_t ch = b0 & LO_MASK_8(b0_bits);
   
    /* Decode continuation bytes */
    while (cbytes > 0) {
        uint8_t b = (uint8_t) str[(*offset)++];
       
        /* Must be 10xxxxxx */
        if ((b & 0xc0) != 0x80)
            return U_SPECIAL;
       
        /* Shift data bits to ch */
        ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
        cbytes--;
    }
   
    return ch;
}
 
/** Encode a single character to string representation.
 *
 * Encode a single character to string representation (i.e. UTF-8) and store
 * it into a buffer at @a offset. Encoding starts at @a offset and this offset
 * is moved to the position where the next character can be written to.
 *
 * @param ch     Input character.
 * @param str    Output buffer.
 * @param offset Byte offset where to start writing.
 * @param size   Size of the output buffer (in bytes).
 *
 * @return EOK if the character was encoded successfully, EOVERFLOW if there
 *     was not enough space in the output buffer or EINVAL if the character
 *     code was invalid.
 */
int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
{
    if (*offset >= size)
        return EOVERFLOW;
   
    if (!chr_check(ch))
        return EINVAL;
   
    /* Unsigned version of ch (bit operations should only be done
       on unsigned types). */
    uint32_t cc = (uint32_t) ch;
   
    /* Determine how many continuation bytes are needed */
   
    unsigned int b0_bits;  /* Data bits in first byte */
    unsigned int cbytes;   /* Number of continuation bytes */
   
    if ((cc & ~LO_MASK_32(7)) == 0) {
        b0_bits = 7;
        cbytes = 0;
    } else if ((cc & ~LO_MASK_32(11)) == 0) {
        b0_bits = 5;
        cbytes = 1;
    } else if ((cc & ~LO_MASK_32(16)) == 0) {
        b0_bits = 4;
        cbytes = 2;
    } else if ((cc & ~LO_MASK_32(21)) == 0) {
        b0_bits = 3;
        cbytes = 3;
    } else {
        /* Codes longer than 21 bits are not supported */
        return EINVAL;
    }
   
    /* Check for available space in buffer */
    if (*offset + cbytes >= size)
        return EOVERFLOW;
   
    /* Encode continuation bytes */
    unsigned int i;
    for (i = cbytes; i > 0; i--) {
        str[*offset + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS));
        cc = cc >> CONT_BITS;
    }
   
    /* Encode first byte */
    str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
   
    /* Advance offset */
    *offset += cbytes + 1;
   
    return EOK;
}
 
/** Get size of string.
 *
 * Get the number of bytes which are used by the string @a str (excluding the
 * NULL-terminator).
 *
 * @param str String to consider.
 *
 * @return Number of bytes used by the string
 *
 */
size_t str_size(const char *str)
{
    size_t size = 0;
   
    while (*str++ != 0)
        size++;
   
    return size;
}
 
/** Get size of wide string.
 *
 * Get the number of bytes which are used by the wide string @a str (excluding the
 * NULL-terminator).
 *
 * @param str Wide string to consider.
 *
 * @return Number of bytes used by the wide string
 *
 */
size_t wstr_size(const wchar_t *str)
{
    return (wstr_length(str) * sizeof(wchar_t));
}
 
/** Get size of string with length limit.
 *
 * Get the number of bytes which are used by up to @a max_len first
 * characters in the string @a str. If @a max_len is greater than
 * the length of @a str, the entire string is measured (excluding the
 * NULL-terminator).
 *
 * @param str     String to consider.
 * @param max_len Maximum number of characters to measure.
 *
 * @return Number of bytes used by the characters.
 *
 */
size_t str_lsize(const char *str, count_t max_len)
{
    count_t len = 0;
    size_t offset = 0;
   
    while (len < max_len) {
        if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
            break;
       
        len++;
    }
   
    return offset;
}
 
/** Get size of wide string with length limit.
 *
 * Get the number of bytes which are used by up to @a max_len first
 * wide characters in the wide string @a str. If @a max_len is greater than
 * the length of @a str, the entire wide string is measured (excluding the
 * NULL-terminator).
 *
 * @param str     Wide string to consider.
 * @param max_len Maximum number of wide characters to measure.
 *
 * @return Number of bytes used by the wide characters.
 *
 */
size_t wstr_lsize(const wchar_t *str, count_t max_len)
{
    return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
}
 
/** Get number of characters in a string.
 *
 * @param str NULL-terminated string.
 *
 * @return Number of characters in string.
 *
 */
count_t str_length(const char *str)
{
    count_t len = 0;
    size_t offset = 0;
   
    while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
        len++;
   
    return len;
}
 
/** Get number of characters in a wide string.
 *
 * @param str NULL-terminated wide string.
 *
 * @return Number of characters in @a str.
 *
 */
count_t wstr_length(const wchar_t *wstr)
{
    count_t len = 0;
   
    while (*wstr++ != 0)
        len++;
   
    return len;
}
 
/** Get number of characters in a string with size limit.
 *
 * @param str  NULL-terminated string.
 * @param size Maximum number of bytes to consider.
 *
 * @return Number of characters in string.
 *
 */
count_t str_nlength(const char *str, size_t size)
{
    count_t len = 0;
    size_t offset = 0;
   
    while (str_decode(str, &offset, size) != 0)
        len++;
   
    return len;
}
 
/** Get number of characters in a string with size limit.
 *
 * @param str  NULL-terminated string.
 * @param size Maximum number of bytes to consider.
 *
 * @return Number of characters in string.
 *
 */
count_t wstr_nlength(const wchar_t *str, size_t size)
{
    count_t len = 0;
    count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
    count_t offset = 0;
   
    while ((offset < limit) && (*str++ != 0)) {
        len++;
        offset += sizeof(wchar_t);
    }
   
    return len;
}
 
/** Check whether character is plain ASCII.
 *
 * @return True if character is plain ASCII.
 *
 */
bool ascii_check(wchar_t ch)
{
    if ((ch >= 0) && (ch <= 127))
        return true;
   
    return false;
}
 
/** Check whether character is valid
 *
 * @return True if character is a valid Unicode code point.
 *
 */
bool chr_check(wchar_t ch)
{
    if ((ch >= 0) && (ch <= 1114111))
        return true;
   
    return false;
}
 
/** Compare two NULL terminated strings.
 *
 * Do a char-by-char comparison of two NULL-terminated strings.
 * The strings are considered equal iff they consist of the same
 * characters on the minimum of their lengths.
 *
 * @param s1 First string to compare.
 * @param s2 Second string to compare.
 *
 * @return 0 if the strings are equal, -1 if first is smaller,
 *         1 if second smaller.
 *
 */
int str_cmp(const char *s1, const char *s2)
{
    wchar_t c1 = 0;
    wchar_t c2 = 0;
   
    size_t off1 = 0;
    size_t off2 = 0;
 
    while (true) {
        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
 
        if (c1 < c2)
            return -1;
       
        if (c1 > c2)
            return 1;
 
        if (c1 == 0 || c2 == 0)
            break;     
    }
 
    return 0;
}
 
/** Compare two NULL terminated strings with length limit.
 *
 * Do a char-by-char comparison of two NULL-terminated strings.
 * The strings are considered equal iff they consist of the same
 * characters on the minimum of their lengths and the length limit.
 *
 * @param s1      First string to compare.
 * @param s2      Second string to compare.
 * @param max_len Maximum number of characters to consider.
 *
 * @return 0 if the strings are equal, -1 if first is smaller,
 *         1 if second smaller.
 *
 */
int str_lcmp(const char *s1, const char *s2, count_t max_len)
{
    wchar_t c1 = 0;
    wchar_t c2 = 0;
   
    size_t off1 = 0;
    size_t off2 = 0;
   
    count_t len = 0;
 
    while (true) {
        if (len >= max_len)
            break;
 
        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
 
        if (c1 < c2)
            return -1;
 
        if (c1 > c2)
            return 1;
 
        if (c1 == 0 || c2 == 0)
            break;
 
        ++len; 
    }
 
    return 0;
 
}
 
/** Copy string.
 *
 * Copy source string @a src to destination buffer @a dest.
 * No more than @a size bytes are written. If the size of the output buffer
 * is at least one byte, the output string will always be well-formed, i.e.
 * null-terminated and containing only complete characters.
 
 *
 
 * @param dst   Destination buffer.
 * @param count Size of the destination buffer (must be > 0).
 * @param src   Source string.
 */
void str_cpy(char *dest, size_t size, const char *src)
{
    wchar_t ch;
    size_t src_off;
    size_t dest_off;
 
    /* There must be space for a null terminator in the buffer. */
    ASSERT(size > 0);
   
    src_off = 0;
    dest_off = 0;
 
    while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
        if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
            break;
    }
 
    dest[dest_off] = '\0';
}
 
/** Copy size-limited substring.
 *
 * Copy prefix of string @a src of max. size @a size to destination buffer
 * @a dest. No more than @a size bytes are written. The output string will
 * always be well-formed, i.e. null-terminated and containing only complete
 * characters.
 *
 * No more than @a n bytes are read from the input string, so it does not
 * have to be null-terminated.
 *
 * @param dst   Destination buffer.
 * @param count Size of the destination buffer (must be > 0).
 * @param src   Source string.
 * @param n Maximum number of bytes to read from @a src.
 */
void str_ncpy(char *dest, size_t size, const char *src, size_t n)
{
    wchar_t ch;
    size_t src_off;
    size_t dest_off;
 
    /* There must be space for a null terminator in the buffer. */
    ASSERT(size > 0);
   
    src_off = 0;
    dest_off = 0;
 
    while ((ch = str_decode(src, &src_off, n)) != 0) {
        if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
            break;
    }
 
 
 
 
    dest[dest_off] = '\0';
}
 
/** Copy NULL-terminated wide string to string
 *
 * Copy source wide string @a src to destination buffer @a dst.
 * No more than @a size bytes are written. NULL-terminator is always
 * written after the last succesfully copied character (i.e. if the
 * destination buffer is has at least 1 byte, it will be always
 * NULL-terminated).
 *
 * @param src   Source wide string.
 * @param dst   Destination buffer.
 * @param count Size of the destination buffer.
 *
 */
void wstr_nstr(char *dst, const wchar_t *src, size_t size)
{
    /* No space for the NULL-terminator in the buffer */
    if (size == 0)
        return;
   
    wchar_t ch;
    count_t src_idx = 0;
    size_t dst_off = 0;
   
    while ((ch = src[src_idx++]) != 0) {
        if (chr_encode(ch, dst, &dst_off, size) != EOK)
            break;
    }
   
    if (dst_off >= size)
        dst[size - 1] = 0;
    else
        dst[dst_off] = 0;
}
 
/** Find first occurence of character in string.
 *
 * @param str String to search.
 * @param ch  Character to look for.
 *
 * @return Pointer to character in @a str or NULL if not found.
 *
 */
const char *str_chr(const char *str, wchar_t ch)
{
    wchar_t acc;
    size_t off = 0;
    size_t last = 0;
   
    while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
        if (acc == ch)
            return (str + last);
        last = off;
    }
   
    return NULL;
}
 
/** Insert a wide character into a wide string.
 *
 * Insert a wide character into a wide string at position
 * @a pos. The characters after the position are shifted.
 *
 * @param str     String to insert to.
 * @param ch      Character to insert to.
 * @param pos     Character index where to insert.
 @ @param max_pos Characters in the buffer.
 *
 * @return True if the insertion was sucessful, false if the position
 *         is out of bounds.
 *
 */
bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
{
    count_t len = wstr_length(str);
   
    if ((pos > len) || (pos + 1 > max_pos))
        return false;
   
    count_t i;
    for (i = len; i + 1 > pos; i--)
        str[i + 1] = str[i];
   
    str[pos] = ch;
   
    return true;
}
 
/** Remove a wide character from a wide string.
 *
 * Remove a wide character from a wide string at position
 * @a pos. The characters after the position are shifted.
 *
 * @param str String to remove from.
 * @param pos Character index to remove.
 *
 * @return True if the removal was sucessful, false if the position
 *         is out of bounds.
 *
 */
bool wstr_remove(wchar_t *str, count_t pos)
{
    count_t len = wstr_length(str);
   
    if (pos >= len)
        return false;
   
    count_t i;
    for (i = pos + 1; i <= len; i++)
        str[i - 1] = str[i];
   
    return true;
}
 
/** @}
 */
 

Rev 4263	Rev 4327
1	/*	1	/*
2	* Copyright (c) 2001-2004 Jakub Jermar	2	* Copyright (c) 2001-2004 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup generic	29	/** @addtogroup generic
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file	34	* @file
35	* @brief String functions.	35	* @brief String functions.
36	*	36	*
37	* Strings and characters use the Universal Character Set (UCS). The standard	37	* Strings and characters use the Universal Character Set (UCS). The standard
38	* strings, called just strings are encoded in UTF-8. Wide strings (encoded	38	* strings, called just strings are encoded in UTF-8. Wide strings (encoded
39	* in UTF-32) are supported to a limited degree. A single character is	39	* in UTF-32) are supported to a limited degree. A single character is
40	* represented as wchar_t.@n	40	* represented as wchar_t.@n
41	*	41	*
42	* Overview of the terminology:@n	42	* Overview of the terminology:@n
43	*	43	*
44	* Term Meaning	44	* Term Meaning
45	* -------------------- ----------------------------------------------------	45	* -------------------- ----------------------------------------------------
46	* byte 8 bits stored in uint8_t (unsigned 8 bit integer)	46	* byte 8 bits stored in uint8_t (unsigned 8 bit integer)
47	*	47	*
48	* character UTF-32 encoded Unicode character, stored in wchar_t	48	* character UTF-32 encoded Unicode character, stored in wchar_t
49	* (signed 32 bit integer), code points 0 .. 1114111	49	* (signed 32 bit integer), code points 0 .. 1114111
50	* are valid	50	* are valid
51	*	51	*
52	* ASCII character 7 bit encoded ASCII character, stored in char	52	* ASCII character 7 bit encoded ASCII character, stored in char
53	* (usually signed 8 bit integer), code points 0 .. 127	53	* (usually signed 8 bit integer), code points 0 .. 127
54	* are valid	54	* are valid
55	*	55	*
56	* string UTF-8 encoded NULL-terminated Unicode string, char *	56	* string UTF-8 encoded NULL-terminated Unicode string, char *
57	*	57	*
58	* wide string UTF-32 encoded NULL-terminated Unicode string,	58	* wide string UTF-32 encoded NULL-terminated Unicode string,
59	* wchar_t *	59	* wchar_t *
60	*	60	*
61	* [wide] string size number of BYTES in a [wide] string (excluding	61	* [wide] string size number of BYTES in a [wide] string (excluding
62	* the NULL-terminator), size_t	62	* the NULL-terminator), size_t
63	*	63	*
64	* [wide] string length number of CHARACTERS in a [wide] string (excluding	64	* [wide] string length number of CHARACTERS in a [wide] string (excluding
65	* the NULL-terminator), count_t	65	* the NULL-terminator), count_t
66	*	66	*
67	* [wide] string width number of display cells on a monospace display taken	67	* [wide] string width number of display cells on a monospace display taken
68	* by a [wide] string, count_t	68	* by a [wide] string, count_t
69	*	69	*
70	*	70	*
71	* Overview of string metrics:@n	71	* Overview of string metrics:@n
72	*	72	*
73	* Metric Abbrev. Type Meaning	73	* Metric Abbrev. Type Meaning
74	* ------ ------ ------ -------------------------------------------------	74	* ------ ------ ------ -------------------------------------------------
75	* size n size_t number of BYTES in a string (excluding the	75	* size n size_t number of BYTES in a string (excluding the
76	* NULL-terminator)	76	* NULL-terminator)
77	*	77	*
78	* length l count_t number of CHARACTERS in a string (excluding the	78	* length l count_t number of CHARACTERS in a string (excluding the
79	* null terminator)	79	* null terminator)
80	*	80	*
81	* width w count_t number of display cells on a monospace display	81	* width w count_t number of display cells on a monospace display
82	* taken by a string	82	* taken by a string
83	*	83	*
84	*	84	*
85	* Function naming prefixes:@n	85	* Function naming prefixes:@n
86	*	86	*
87	* chr_ operate on characters	87	* chr_ operate on characters
88	* ascii_ operate on ASCII characters	88	* ascii_ operate on ASCII characters
89	* str_ operate on strings	89	* str_ operate on strings
90	* wstr_ operate on wide strings	90	* wstr_ operate on wide strings
91	*	91	*
92	* [w]str_[n\|l\|w] operate on a prefix limited by size, length	92	* [w]str_[n\|l\|w] operate on a prefix limited by size, length
93	* or width	93	* or width
94	*	94	*
95	*	95	*
96	* A specific character inside a [wide] string can be referred to by:@n	96	* A specific character inside a [wide] string can be referred to by:@n
97	*	97	*
98	* pointer (char , wchar_t )	98	* pointer (char , wchar_t )
99	* byte offset (size_t)	99	* byte offset (size_t)
100	* character index (count_t)	100	* character index (count_t)
101	*	101	*
102	*/	102	*/
103		103
104	#include <string.h>	104	#include <string.h>
105	#include <print.h>	105	#include <print.h>
106	#include <cpu.h>	106	#include <cpu.h>
107	#include <arch/asm.h>	107	#include <arch/asm.h>
108	#include <arch.h>	108	#include <arch.h>
109	#include <errno.h>	109	#include <errno.h>
110	#include <align.h>	110	#include <align.h>
-		111	#include <debug.h>
111		112
112	/** Byte mask consisting of lowest @n bits (out of 8) */	113	/** Byte mask consisting of lowest @n bits (out of 8) */
113	#define LO_MASK_8(n) ((uint8_t) ((1 << (n)) - 1))	114	#define LO_MASK_8(n) ((uint8_t) ((1 << (n)) - 1))
114		115
115	/** Byte mask consisting of lowest @n bits (out of 32) */	116	/** Byte mask consisting of lowest @n bits (out of 32) */
116	#define LO_MASK_32(n) ((uint32_t) ((1 << (n)) - 1))	117	#define LO_MASK_32(n) ((uint32_t) ((1 << (n)) - 1))
117		118
118	/** Byte mask consisting of highest @n bits (out of 8) */	119	/** Byte mask consisting of highest @n bits (out of 8) */
119	#define HI_MASK_8(n) (~LO_MASK_8(8 - (n)))	120	#define HI_MASK_8(n) (~LO_MASK_8(8 - (n)))
120		121
121	/** Number of data bits in a UTF-8 continuation byte */	122	/** Number of data bits in a UTF-8 continuation byte */
122	#define CONT_BITS 6	123	#define CONT_BITS 6
123		124
124	/** Decode a single character from a string.	125	/** Decode a single character from a string.
125	*	126	*
126	* Decode a single character from a string of size @a size. Decoding starts	127	* Decode a single character from a string of size @a size. Decoding starts
127	* at @a offset and this offset is moved to the beginning of the next	128	* at @a offset and this offset is moved to the beginning of the next
128	* character. In case of decoding error, offset generally advances at least	129	* character. In case of decoding error, offset generally advances at least
129	* by one. However, offset is never moved beyond size.	130	* by one. However, offset is never moved beyond size.
130	*	131	*
131	* @param str String (not necessarily NULL-terminated).	132	* @param str String (not necessarily NULL-terminated).
132	* @param offset Byte offset in string where to start decoding.	133	* @param offset Byte offset in string where to start decoding.
133	* @param size Size of the string (in bytes).	134	* @param size Size of the string (in bytes).
134	*	135	*
135	* @return Value of decoded character, U_SPECIAL on decoding error or	136	* @return Value of decoded character, U_SPECIAL on decoding error or
136	* NULL if attempt to decode beyond @a size.	137	* NULL if attempt to decode beyond @a size.
137	*	138	*
138	*/	139	*/
139	wchar_t str_decode(const char str, size_t offset, size_t size)	140	wchar_t str_decode(const char str, size_t offset, size_t size)
140	{	141	{
141	if (*offset + 1 > size)	142	if (*offset + 1 > size)
142	return 0;	143	return 0;
143		144
144	/* First byte read from string */	145	/* First byte read from string */
145	uint8_t b0 = (uint8_t) str[(*offset)++];	146	uint8_t b0 = (uint8_t) str[(*offset)++];
146		147
147	/* Determine code length */	148	/* Determine code length */
148		149
149	unsigned int b0_bits; /* Data bits in first byte */	150	unsigned int b0_bits; /* Data bits in first byte */
150	unsigned int cbytes; /* Number of continuation bytes */	151	unsigned int cbytes; /* Number of continuation bytes */
151		152
152	if ((b0 & 0x80) == 0) {	153	if ((b0 & 0x80) == 0) {
153	/* 0xxxxxxx (Plain ASCII) */	154	/* 0xxxxxxx (Plain ASCII) */
154	b0_bits = 7;	155	b0_bits = 7;
155	cbytes = 0;	156	cbytes = 0;
156	} else if ((b0 & 0xe0) == 0xc0) {	157	} else if ((b0 & 0xe0) == 0xc0) {
157	/* 110xxxxx 10xxxxxx */	158	/* 110xxxxx 10xxxxxx */
158	b0_bits = 5;	159	b0_bits = 5;
159	cbytes = 1;	160	cbytes = 1;
160	} else if ((b0 & 0xf0) == 0xe0) {	161	} else if ((b0 & 0xf0) == 0xe0) {
161	/* 1110xxxx 10xxxxxx 10xxxxxx */	162	/* 1110xxxx 10xxxxxx 10xxxxxx */
162	b0_bits = 4;	163	b0_bits = 4;
163	cbytes = 2;	164	cbytes = 2;
164	} else if ((b0 & 0xf8) == 0xf0) {	165	} else if ((b0 & 0xf8) == 0xf0) {
165	/* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */	166	/* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
166	b0_bits = 3;	167	b0_bits = 3;
167	cbytes = 3;	168	cbytes = 3;
168	} else {	169	} else {
169	/* 10xxxxxx -- unexpected continuation byte */	170	/* 10xxxxxx -- unexpected continuation byte */
170	return U_SPECIAL;	171	return U_SPECIAL;
171	}	172	}
172		173
173	if (*offset + cbytes > size)	174	if (*offset + cbytes > size)
174	return U_SPECIAL;	175	return U_SPECIAL;
175		176
176	wchar_t ch = b0 & LO_MASK_8(b0_bits);	177	wchar_t ch = b0 & LO_MASK_8(b0_bits);
177		178
178	/* Decode continuation bytes */	179	/* Decode continuation bytes */
179	while (cbytes > 0) {	180	while (cbytes > 0) {
180	uint8_t b = (uint8_t) str[(*offset)++];	181	uint8_t b = (uint8_t) str[(*offset)++];
181		182
182	/* Must be 10xxxxxx */	183	/* Must be 10xxxxxx */
183	if ((b & 0xc0) != 0x80)	184	if ((b & 0xc0) != 0x80)
184	return U_SPECIAL;	185	return U_SPECIAL;
185		186
186	/* Shift data bits to ch */	187	/* Shift data bits to ch */
187	ch = (ch << CONT_BITS) \| (wchar_t) (b & LO_MASK_8(CONT_BITS));	188	ch = (ch << CONT_BITS) \| (wchar_t) (b & LO_MASK_8(CONT_BITS));
188	cbytes--;	189	cbytes--;
189	}	190	}
190		191
191	return ch;	192	return ch;
192	}	193	}
193		194
194	/** Encode a single character to string representation.	195	/** Encode a single character to string representation.
195	*	196	*
196	* Encode a single character to string representation (i.e. UTF-8) and store	197	* Encode a single character to string representation (i.e. UTF-8) and store
197	* it into a buffer at @a offset. Encoding starts at @a offset and this offset	198	* it into a buffer at @a offset. Encoding starts at @a offset and this offset
198	* is moved to the position where the next character can be written to.	199	* is moved to the position where the next character can be written to.
199	*	200	*
200	* @param ch Input character.	201	* @param ch Input character.
201	* @param str Output buffer.	202	* @param str Output buffer.
202	* @param offset Byte offset where to start writing.	203	* @param offset Byte offset where to start writing.
203	* @param size Size of the output buffer (in bytes).	204	* @param size Size of the output buffer (in bytes).
204	*	205	*
205	* @return EOK if the character was encoded successfully, EOVERFLOW if there	206	* @return EOK if the character was encoded successfully, EOVERFLOW if there
206	* was not enough space in the output buffer or EINVAL if the character	207	* was not enough space in the output buffer or EINVAL if the character
207	* code was invalid.	208	* code was invalid.
208	*/	209	*/
209	int chr_encode(wchar_t ch, char str, size_t offset, size_t size)	210	int chr_encode(wchar_t ch, char str, size_t offset, size_t size)
210	{	211	{
211	if (*offset >= size)	212	if (*offset >= size)
212	return EOVERFLOW;	213	return EOVERFLOW;
213		214
214	if (!chr_check(ch))	215	if (!chr_check(ch))
215	return EINVAL;	216	return EINVAL;
216		217
217	/* Unsigned version of ch (bit operations should only be done	218	/* Unsigned version of ch (bit operations should only be done
218	on unsigned types). */	219	on unsigned types). */
219	uint32_t cc = (uint32_t) ch;	220	uint32_t cc = (uint32_t) ch;
220		221
221	/* Determine how many continuation bytes are needed */	222	/* Determine how many continuation bytes are needed */
222		223
223	unsigned int b0_bits; /* Data bits in first byte */	224	unsigned int b0_bits; /* Data bits in first byte */
224	unsigned int cbytes; /* Number of continuation bytes */	225	unsigned int cbytes; /* Number of continuation bytes */
225		226
226	if ((cc & ~LO_MASK_32(7)) == 0) {	227	if ((cc & ~LO_MASK_32(7)) == 0) {
227	b0_bits = 7;	228	b0_bits = 7;
228	cbytes = 0;	229	cbytes = 0;
229	} else if ((cc & ~LO_MASK_32(11)) == 0) {	230	} else if ((cc & ~LO_MASK_32(11)) == 0) {
230	b0_bits = 5;	231	b0_bits = 5;
231	cbytes = 1;	232	cbytes = 1;
232	} else if ((cc & ~LO_MASK_32(16)) == 0) {	233	} else if ((cc & ~LO_MASK_32(16)) == 0) {
233	b0_bits = 4;	234	b0_bits = 4;
234	cbytes = 2;	235	cbytes = 2;
235	} else if ((cc & ~LO_MASK_32(21)) == 0) {	236	} else if ((cc & ~LO_MASK_32(21)) == 0) {
236	b0_bits = 3;	237	b0_bits = 3;
237	cbytes = 3;	238	cbytes = 3;
238	} else {	239	} else {
239	/* Codes longer than 21 bits are not supported */	240	/* Codes longer than 21 bits are not supported */
240	return EINVAL;	241	return EINVAL;
241	}	242	}
242		243
243	/* Check for available space in buffer */	244	/* Check for available space in buffer */
244	if (*offset + cbytes >= size)	245	if (*offset + cbytes >= size)
245	return EOVERFLOW;	246	return EOVERFLOW;
246		247
247	/* Encode continuation bytes */	248	/* Encode continuation bytes */
248	unsigned int i;	249	unsigned int i;
249	for (i = cbytes; i > 0; i--) {	250	for (i = cbytes; i > 0; i--) {
250	str[*offset + i] = 0x80 \| (cc & LO_MASK_32(CONT_BITS));	251	str[*offset + i] = 0x80 \| (cc & LO_MASK_32(CONT_BITS));
251	cc = cc >> CONT_BITS;	252	cc = cc >> CONT_BITS;
252	}	253	}
253		254
254	/* Encode first byte */	255	/* Encode first byte */
255	str[*offset] = (cc & LO_MASK_32(b0_bits)) \| HI_MASK_8(8 - b0_bits - 1);	256	str[*offset] = (cc & LO_MASK_32(b0_bits)) \| HI_MASK_8(8 - b0_bits - 1);
256		257
257	/* Advance offset */	258	/* Advance offset */
258	*offset += cbytes + 1;	259	*offset += cbytes + 1;
259		260
260	return EOK;	261	return EOK;
261	}	262	}
262		263
263	/** Get size of string.	264	/** Get size of string.
264	*	265	*
265	* Get the number of bytes which are used by the string @a str (excluding the	266	* Get the number of bytes which are used by the string @a str (excluding the
266	* NULL-terminator).	267	* NULL-terminator).
267	*	268	*
268	* @param str String to consider.	269	* @param str String to consider.
269	*	270	*
270	* @return Number of bytes used by the string	271	* @return Number of bytes used by the string
271	*	272	*
272	*/	273	*/
273	size_t str_size(const char *str)	274	size_t str_size(const char *str)
274	{	275	{
275	size_t size = 0;	276	size_t size = 0;
276		277
277	while (*str++ != 0)	278	while (*str++ != 0)
278	size++;	279	size++;
279		280
280	return size;	281	return size;
281	}	282	}
282		283
283	/** Get size of wide string.	284	/** Get size of wide string.
284	*	285	*
285	* Get the number of bytes which are used by the wide string @a str (excluding the	286	* Get the number of bytes which are used by the wide string @a str (excluding the
286	* NULL-terminator).	287	* NULL-terminator).
287	*	288	*
288	* @param str Wide string to consider.	289	* @param str Wide string to consider.
289	*	290	*
290	* @return Number of bytes used by the wide string	291	* @return Number of bytes used by the wide string
291	*	292	*
292	*/	293	*/
293	size_t wstr_size(const wchar_t *str)	294	size_t wstr_size(const wchar_t *str)
294	{	295	{
295	return (wstr_length(str) * sizeof(wchar_t));	296	return (wstr_length(str) * sizeof(wchar_t));
296	}	297	}
297		298
298	/** Get size of string with length limit.	299	/** Get size of string with length limit.
299	*	300	*
300	* Get the number of bytes which are used by up to @a max_len first	301	* Get the number of bytes which are used by up to @a max_len first
301	* characters in the string @a str. If @a max_len is greater than	302	* characters in the string @a str. If @a max_len is greater than
302	* the length of @a str, the entire string is measured (excluding the	303	* the length of @a str, the entire string is measured (excluding the
303	* NULL-terminator).	304	* NULL-terminator).
304	*	305	*
305	* @param str String to consider.	306	* @param str String to consider.
306	* @param max_len Maximum number of characters to measure.	307	* @param max_len Maximum number of characters to measure.
307	*	308	*
308	* @return Number of bytes used by the characters.	309	* @return Number of bytes used by the characters.
309	*	310	*
310	*/	311	*/
311	size_t str_lsize(const char *str, count_t max_len)	312	size_t str_lsize(const char *str, count_t max_len)
312	{	313	{
313	count_t len = 0;	314	count_t len = 0;
314	size_t offset = 0;	315	size_t offset = 0;
315		316
316	while (len < max_len) {	317	while (len < max_len) {
317	if (str_decode(str, &offset, STR_NO_LIMIT) == 0)	318	if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
318	break;	319	break;
319		320
320	len++;	321	len++;
321	}	322	}
322		323
323	return offset;	324	return offset;
324	}	325	}
325		326
326	/** Get size of wide string with length limit.	327	/** Get size of wide string with length limit.
327	*	328	*
328	* Get the number of bytes which are used by up to @a max_len first	329	* Get the number of bytes which are used by up to @a max_len first
329	* wide characters in the wide string @a str. If @a max_len is greater than	330	* wide characters in the wide string @a str. If @a max_len is greater than
330	* the length of @a str, the entire wide string is measured (excluding the	331	* the length of @a str, the entire wide string is measured (excluding the
331	* NULL-terminator).	332	* NULL-terminator).
332	*	333	*
333	* @param str Wide string to consider.	334	* @param str Wide string to consider.
334	* @param max_len Maximum number of wide characters to measure.	335	* @param max_len Maximum number of wide characters to measure.
335	*	336	*
336	* @return Number of bytes used by the wide characters.	337	* @return Number of bytes used by the wide characters.
337	*	338	*
338	*/	339	*/
339	size_t wstr_lsize(const wchar_t *str, count_t max_len)	340	size_t wstr_lsize(const wchar_t *str, count_t max_len)
340	{	341	{
341	return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));	342	return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
342	}	343	}
343		344
344	/** Get number of characters in a string.	345	/** Get number of characters in a string.
345	*	346	*
346	* @param str NULL-terminated string.	347	* @param str NULL-terminated string.
347	*	348	*
348	* @return Number of characters in string.	349	* @return Number of characters in string.
349	*	350	*
350	*/	351	*/
351	count_t str_length(const char *str)	352	count_t str_length(const char *str)
352	{	353	{
353	count_t len = 0;	354	count_t len = 0;
354	size_t offset = 0;	355	size_t offset = 0;
355		356
356	while (str_decode(str, &offset, STR_NO_LIMIT) != 0)	357	while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
357	len++;	358	len++;
358		359
359	return len;	360	return len;
360	}	361	}
361		362
362	/** Get number of characters in a wide string.	363	/** Get number of characters in a wide string.
363	*	364	*
364	* @param str NULL-terminated wide string.	365	* @param str NULL-terminated wide string.
365	*	366	*
366	* @return Number of characters in @a str.	367	* @return Number of characters in @a str.
367	*	368	*
368	*/	369	*/
369	count_t wstr_length(const wchar_t *wstr)	370	count_t wstr_length(const wchar_t *wstr)
370	{	371	{
371	count_t len = 0;	372	count_t len = 0;
372		373
373	while (*wstr++ != 0)	374	while (*wstr++ != 0)
374	len++;	375	len++;
375		376
376	return len;	377	return len;
377	}	378	}
378		379
379	/** Get number of characters in a string with size limit.	380	/** Get number of characters in a string with size limit.
380	*	381	*
381	* @param str NULL-terminated string.	382	* @param str NULL-terminated string.
382	* @param size Maximum number of bytes to consider.	383	* @param size Maximum number of bytes to consider.
383	*	384	*
384	* @return Number of characters in string.	385	* @return Number of characters in string.
385	*	386	*
386	*/	387	*/
387	count_t str_nlength(const char *str, size_t size)	388	count_t str_nlength(const char *str, size_t size)
388	{	389	{
389	count_t len = 0;	390	count_t len = 0;
390	size_t offset = 0;	391	size_t offset = 0;
391		392
392	while (str_decode(str, &offset, size) != 0)	393	while (str_decode(str, &offset, size) != 0)
393	len++;	394	len++;
394		395
395	return len;	396	return len;
396	}	397	}
397		398
398	/** Get number of characters in a string with size limit.	399	/** Get number of characters in a string with size limit.
399	*	400	*
400	* @param str NULL-terminated string.	401	* @param str NULL-terminated string.
401	* @param size Maximum number of bytes to consider.	402	* @param size Maximum number of bytes to consider.
402	*	403	*
403	* @return Number of characters in string.	404	* @return Number of characters in string.
404	*	405	*
405	*/	406	*/
406	count_t wstr_nlength(const wchar_t *str, size_t size)	407	count_t wstr_nlength(const wchar_t *str, size_t size)
407	{	408	{
408	count_t len = 0;	409	count_t len = 0;
409	count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));	410	count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
410	count_t offset = 0;	411	count_t offset = 0;
411		412
412	while ((offset < limit) && (*str++ != 0)) {	413	while ((offset < limit) && (*str++ != 0)) {
413	len++;	414	len++;
414	offset += sizeof(wchar_t);	415	offset += sizeof(wchar_t);
415	}	416	}
416		417
417	return len;	418	return len;
418	}	419	}
419		420
420	/** Check whether character is plain ASCII.	421	/** Check whether character is plain ASCII.
421	*	422	*
422	* @return True if character is plain ASCII.	423	* @return True if character is plain ASCII.
423	*	424	*
424	*/	425	*/
425	bool ascii_check(wchar_t ch)	426	bool ascii_check(wchar_t ch)
426	{	427	{
427	if ((ch >= 0) && (ch <= 127))	428	if ((ch >= 0) && (ch <= 127))
428	return true;	429	return true;
429		430
430	return false;	431	return false;
431	}	432	}
432		433
433	/** Check whether character is valid	434	/** Check whether character is valid
434	*	435	*
435	* @return True if character is a valid Unicode code point.	436	* @return True if character is a valid Unicode code point.
436	*	437	*
437	*/	438	*/
438	bool chr_check(wchar_t ch)	439	bool chr_check(wchar_t ch)
439	{	440	{
440	if ((ch >= 0) && (ch <= 1114111))	441	if ((ch >= 0) && (ch <= 1114111))
441	return true;	442	return true;
442		443
443	return false;	444	return false;
444	}	445	}
445		446
446	/** Compare two NULL terminated strings.	447	/** Compare two NULL terminated strings.
447	*	448	*
448	* Do a char-by-char comparison of two NULL-terminated strings.	449	* Do a char-by-char comparison of two NULL-terminated strings.
449	* The strings are considered equal iff they consist of the same	450	* The strings are considered equal iff they consist of the same
450	* characters on the minimum of their lengths.	451	* characters on the minimum of their lengths.
451	*	452	*
452	* @param s1 First string to compare.	453	* @param s1 First string to compare.
453	* @param s2 Second string to compare.	454	* @param s2 Second string to compare.
454	*	455	*
455	* @return 0 if the strings are equal, -1 if first is smaller,	456	* @return 0 if the strings are equal, -1 if first is smaller,
456	* 1 if second smaller.	457	* 1 if second smaller.
457	*	458	*
458	*/	459	*/
459	int str_cmp(const char s1, const char s2)	460	int str_cmp(const char s1, const char s2)
460	{	461	{
461	wchar_t c1 = 0;	462	wchar_t c1 = 0;
462	wchar_t c2 = 0;	463	wchar_t c2 = 0;
463		464
464	size_t off1 = 0;	465	size_t off1 = 0;
465	size_t off2 = 0;	466	size_t off2 = 0;
466		467
467	while (true) {	468	while (true) {
468	c1 = str_decode(s1, &off1, STR_NO_LIMIT);	469	c1 = str_decode(s1, &off1, STR_NO_LIMIT);
469	c2 = str_decode(s2, &off2, STR_NO_LIMIT);	470	c2 = str_decode(s2, &off2, STR_NO_LIMIT);
470		471
471	if (c1 < c2)	472	if (c1 < c2)
472	return -1;	473	return -1;
473		474
474	if (c1 > c2)	475	if (c1 > c2)
475	return 1;	476	return 1;
476		477
477	if (c1 == 0 \|\| c2 == 0)	478	if (c1 == 0 \|\| c2 == 0)
478	break;	479	break;
479	}	480	}
480		481
481	return 0;	482	return 0;
482	}	483	}
483		484
484	/** Compare two NULL terminated strings with length limit.	485	/** Compare two NULL terminated strings with length limit.
485	*	486	*
486	* Do a char-by-char comparison of two NULL-terminated strings.	487	* Do a char-by-char comparison of two NULL-terminated strings.
487	* The strings are considered equal iff they consist of the same	488	* The strings are considered equal iff they consist of the same
488	* characters on the minimum of their lengths and the length limit.	489	* characters on the minimum of their lengths and the length limit.
489	*	490	*
490	* @param s1 First string to compare.	491	* @param s1 First string to compare.
491	* @param s2 Second string to compare.	492	* @param s2 Second string to compare.
492	* @param max_len Maximum number of characters to consider.	493	* @param max_len Maximum number of characters to consider.
493	*	494	*
494	* @return 0 if the strings are equal, -1 if first is smaller,	495	* @return 0 if the strings are equal, -1 if first is smaller,
495	* 1 if second smaller.	496	* 1 if second smaller.
496	*	497	*
497	*/	498	*/
498	int str_lcmp(const char s1, const char s2, count_t max_len)	499	int str_lcmp(const char s1, const char s2, count_t max_len)
499	{	500	{

Subversion Repositories HelenOS

(root)/branches/network/kernel/generic/src/lib/string.c – Rev 4263 → 4327