Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4220 → Rev 4221

/branches/dd/kernel/generic/include/string.h
42,14 → 42,14
extern char invalch;
 
extern wchar_t chr_decode(const char *, size_t *, size_t);
extern bool chr_encode(const wchar_t, char *, size_t *, size_t limit);
extern size_t utf8_count_bytes(const char *str, count_t count);
extern bool chr_encode(const wchar_t, char *, size_t *, size_t);
extern size_t str_lsize(const char *, count_t);
extern bool ascii_check(const wchar_t ch);
extern bool unicode_check(const wchar_t ch);
 
extern size_t strlen(const char *str);
extern size_t strlen_utf8(const char *str);
extern size_t strlen_utf32(const wchar_t *str);
extern count_t str_length(const char *str);
extern count_t wstr_length(const wchar_t *str);
 
extern int strcmp(const char *src, const char *dst);
extern int strncmp(const char *src, const char *dst, size_t len);
/branches/dd/kernel/generic/src/printf/printf_core.c
254,7 → 254,7
return printf_putstr(nullstr, ps);
/* Print leading spaces */
size_t size = strlen_utf8(str);
size_t size = str_length(str);
if (precision == 0)
precision = size;
 
268,7 → 268,7
}
 
int retval;
size_t bytes = utf8_count_bytes(str, min(size, precision));
size_t bytes = str_lsize(str, min(size, precision));
if ((retval = printf_putnchars_utf8(str, bytes, ps)) < 0)
return -counter;
298,7 → 298,7
return printf_putstr(nullstr, ps);
/* Print leading spaces */
size_t size = strlen_utf32(str);
size_t size = wstr_length(str);
if (precision == 0)
precision = size;
/branches/dd/kernel/generic/src/lib/string.c
199,37 → 199,35
return true;
}
 
/** Get bytes used by UTF-8 characters.
/** Get size of string, with length limit.
*
* Get the number of bytes (count of plain characters) which
* are used by a given count of UTF-8 characters in a string.
* As UTF-8 encoding is multibyte, there is no constant
* correspondence between number of characters and used bytes.
* 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.
*
* @param str UTF-8 string to consider.
* @param count Number of UTF-8 characters to count.
* @param str String to consider.
* @param count Maximum number of characters to measure.
*
* @return Number of bytes used by the characters.
*
*/
size_t utf8_count_bytes(const char *str, count_t count)
size_t str_lsize(const char *str, count_t max_len)
{
size_t size = 0;
index_t index = 0;
index_t iprev;
count_t len = 0;
size_t cur = 0;
size_t prev;
wchar_t ch;
 
while (true) {
iprev = index;
if (size >= count)
prev = cur;
if (len >= max_len)
break;
ch = chr_decode(str, &index, UTF8_NO_LIMIT);
ch = chr_decode(str, &cur, UTF8_NO_LIMIT);
if (ch == '\0') break;
 
size++;
len++;
}
return iprev;
 
return prev;
}
 
/** Check whether character is plain ASCII.
262,7 → 260,7
*
* @param str NULL-terminated string.
*
* @return Number of characters in str.
* @return Number of characters in @a str.
*
*/
size_t strlen(const char *str)
273,38 → 271,37
return size;
}
 
/** Return number of UTF-8 characters in a string.
/** Return number of characters in a string.
*
* @param str NULL-terminated UTF-8 string.
*
* @return Number of UTF-8 characters in str.
*
* @param str NULL-terminated string.
* @return Number of characters in string.
*/
size_t strlen_utf8(const char *str)
count_t str_length(const char *str)
{
size_t size = 0;
index_t index = 0;
while (chr_decode(str, &index, UTF8_NO_LIMIT) != 0) {
size++;
count_t len = 0;
size_t offset = 0;
 
while (chr_decode(str, &offset, UTF8_NO_LIMIT) != 0) {
len++;
}
return size;
 
return len;
}
 
/** Return number of UTF-32 characters in a string.
/** Return number of characters in a wide string.
*
* @param str NULL-terminated UTF-32 string.
*
* @return Number of UTF-32 characters in str.
*
* @param str NULL-terminated wide string.
* @return Number of characters in @a str.
*/
size_t strlen_utf32(const wchar_t *str)
count_t wstr_length(const wchar_t *wstr)
{
size_t size;
for (size = 0; str[size]; size++);
return size;
count_t len;
 
len = 0;
while (*wstr++ != '\0')
++len;
 
return len;
}
 
/** Compare two NULL terminated strings
/branches/dd/kernel/arch/sparc64/include/memstr.h
26,7 → 26,7
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/** @addtogroup sparc64
/** @addtogroup sparc64
* @{
*/
/** @file
/branches/dd/kernel/arch/sparc64/src/asm.S
228,7 → 228,12
b _memsetb
nop
 
.global memsetw
memsetw:
b _memsetw
nop
 
 
.macro WRITE_ALTERNATE_REGISTER reg, bit
rdpr %pstate, %g1 ! save PSTATE.PEF
wrpr %g0, (\bit | PSTATE_PRIV_BIT), %pstate
/branches/dd/kernel/arch/sparc64/src/drivers/sgcn.c
130,7 → 130,7
 
 
/* functions referenced from definitions of I/O operations structures */
static void sgcn_putchar(outdev_t *, const char, bool);
static void sgcn_putchar(outdev_t *, const wchar_t, bool);
 
/** SGCN output device operations */
static outdev_operations_t sgcnout_ops = {
264,18 → 264,20
}
 
/**
* SGCN output operation. Prints a single character to the SGCN. If the line
* feed character is written ('\n'), the carriage return character ('\r') is
* written straight away.
* SGCN output operation. Prints a single character to the SGCN. Newline
* character is converted to CRLF.
*/
static void sgcn_putchar(outdev_t *od, const char c, bool silent)
static void sgcn_putchar(outdev_t *od, const wchar_t ch, bool silent)
{
if (!silent) {
spinlock_lock(&sgcn_output_lock);
sgcn_do_putchar(c);
if (c == '\n')
sgcn_do_putchar('\r');
if (ascii_check(ch)) {
if (ch == '\n')
sgcn_do_putchar('\r');
sgcn_do_putchar(ch);
} else
sgcn_do_putchar(invalch);
spinlock_unlock(&sgcn_output_lock);
}