diff --git a/contrib/sdk/sources/newlib/libc/Makefile b/contrib/sdk/sources/newlib/libc/Makefile index 00d73b1203..52328de7d4 100644 --- a/contrib/sdk/sources/newlib/libc/Makefile +++ b/contrib/sdk/sources/newlib/libc/Makefile @@ -211,42 +211,93 @@ STDLIB_SRCS= \ wctomb_r.c -STRING_SRCS= memcpy.c \ - memcmp.c \ - memmove.c \ - memset.c \ - memchr.c \ - stpcpy.c \ +STRING_SRCS= \ + bcmp.c \ + bcopy.c \ + bzero.c \ + explicit_bzero.c \ + gnu_basename.c \ + index.c \ + memccpy.c \ + memchr.c \ + memcmp.c \ + memcpy.c \ + memmem.c \ + memmove.c \ + mempcpy.c \ + memrchr.c \ + memset.c \ + rawmemchr.c \ + rindex.c \ + stpcpy.c \ stpncpy.c \ - strcat.c \ - strchr.c \ - strcmp.c \ - strcoll.c \ - strcasecmp.c \ - strncasecmp.c \ - strncat.c \ - strncmp.c \ - strncpy.c \ - strndup.c \ - strndup_r.c \ - strnlen.c \ - strcasestr.c \ - strdup.c \ - strdup_r.c \ - strerror.c \ - strlen.c \ - strrchr.c \ - strpbrk.c \ - strsep.c \ - strstr.c \ - strtok.c \ - strtok_r.c \ - strupr.c \ - strxfrm.c \ - strcspn.c \ - strspn.c \ - strcpy.c \ - u_strerr.c + strcasecmp.c \ + strcasestr.c \ + strcat.c \ + strchr.c \ + strchrnul.c \ + strcmp.c \ + strcoll.c \ + strcpy.c \ + strcspn.c \ + strdup.c \ + strdup_r.c \ + strerror.c \ + strerror_r.c \ + strlcat.c \ + strlcpy.c \ + strlen.c \ + strlwr.c \ + strncasecmp.c \ + strncat.c \ + strncmp.c \ + strncpy.c \ + strndup.c \ + strndup_r.c \ + strnlen.c \ + strpbrk.c \ + strrchr.c \ + strsep.c \ + strspn.c \ + strstr.c \ + strtok.c \ + strtok_r.c \ + strupr.c \ + strxfrm.c \ + swab.c \ + u_strerr.c \ + wcpcpy.c \ + wcpncpy.c \ + wcscasecmp.c \ + wcscat.c \ + wcschr.c \ + wcscmp.c \ + wcscoll.c \ + wcscpy.c \ + wcscspn.c \ + wcsdup.c \ + wcslcat.c \ + wcslcpy.c \ + wcslen.c \ + wcsncasecmp.c \ + wcsncat.c \ + wcsncmp.c \ + wcsncpy.c \ + wcsnlen.c \ + wcspbrk.c \ + wcsrchr.c \ + wcsspn.c \ + wcsstr.c \ + wcstok.c \ + wcswidth.c \ + wcsxfrm.c \ + wcwidth.c \ + wmemchr.c \ + wmemcmp.c \ + wmemcpy.c \ + wmemmove.c \ + wmemset.c + STDIO_SRCS= \ asiprintf.c \ diff --git a/contrib/sdk/sources/newlib/libc/Tupfile.lua b/contrib/sdk/sources/newlib/libc/Tupfile.lua index e847ddb1bc..72b3789ab0 100644 --- a/contrib/sdk/sources/newlib/libc/Tupfile.lua +++ b/contrib/sdk/sources/newlib/libc/Tupfile.lua @@ -112,18 +112,43 @@ STDLIB_SRCS = { "wctomb_r.c" } STRING_SRCS = { - "memcpy.c", - "memcmp.c", - "memmove.c", - "memset.c", + "bcmp.c", + "bcopy.c", + + "bzero.c", + "explicit_bzero.c", + "gnu_basename.c", + "index.c", + "memccpy.c", "memchr.c", + "memcmp.c", + "memcpy.c", + "memmem.c", + "memmove.c", + "mempcpy.c", + "memrchr.c", + "memset.c", + "rawmemchr.c", + "rindex.c", "stpcpy.c", "stpncpy.c", + "strcasecmp.c", + "strcasestr.c", "strcat.c", "strchr.c", + "strchrnul.c", "strcmp.c", "strcoll.c", - "strcasecmp.c", + "strcpy.c", + "strcspn.c", + "strdup.c", + "strdup_r.c", + "strerror.c", + "strerror_r.c", + "strlcat.c", + "strlcpy.c", + "strlen.c", + "strlwr.c", "strncasecmp.c", "strncat.c", "strncmp.c", @@ -131,23 +156,48 @@ STRING_SRCS = { "strndup.c", "strndup_r.c", "strnlen.c", - "strcasestr.c", - "strdup.c", - "strdup_r.c", - "strerror.c", - "strlen.c", - "strrchr.c", "strpbrk.c", + "strrchr.c", "strsep.c", + "strspn.c", "strstr.c", "strtok.c", "strtok_r.c", "strupr.c", "strxfrm.c", - "strcspn.c", - "strspn.c", - "strcpy.c", - "u_strerr.c" + "swab.c", + "u_strerr.c", + "wcpcpy.c", + "wcpncpy.c", + "wcscasecmp.c", + "wcscat.c", + "wcschr.c", + "wcscmp.c", + "wcscoll.c", + "wcscpy.c", + "wcscspn.c", + "wcsdup.c", + "wcslcat.c", + "wcslcpy.c", + "wcslen.c", + "wcsncasecmp.c", + "wcsncat.c", + "wcsncmp.c", + "wcsncpy.c", + "wcsnlen.c", + "wcspbrk.c", + "wcsrchr.c", + "wcsspn.c", + "wcsstr.c", + "wcstok.c", + "wcswidth.c", + "wcsxfrm.c", + "wcwidth.c", + "wmemchr.c", + "wmemcmp.c", + "wmemcpy.c", + "wmemmove.c", + "wmemset.c" } STDIO_SRCS = { diff --git a/contrib/sdk/sources/newlib/libc/include/newlib.h b/contrib/sdk/sources/newlib/libc/include/newlib.h index e800437fdf..873431933e 100644 --- a/contrib/sdk/sources/newlib/libc/include/newlib.h +++ b/contrib/sdk/sources/newlib/libc/include/newlib.h @@ -15,7 +15,7 @@ /* C99 formats support (such as %a, %zu, ...) in IO functions like * printf/scanf enabled */ -/* #undef _WANT_IO_C99_FORMATS */ +#define _WANT_IO_C99_FORMATS #define __DYNAMIC_REENT__ @@ -56,7 +56,7 @@ #define _ATEXIT_DYNAMIC_ALLOC 1 /* True if long double supported. */ -#define _HAVE_LONG_DOUBLE 1 +//#define _HAVE_LONG_DOUBLE 1 /* Define if compiler supports -fno-tree-loop-distribute-patterns. */ #define _HAVE_CC_INHIBIT_LOOP_TO_LIBCALL 1 diff --git a/contrib/sdk/sources/newlib/libc/libcdll.lds b/contrib/sdk/sources/newlib/libc/libcdll.lds index cddba2bee0..e89ce92a2c 100644 --- a/contrib/sdk/sources/newlib/libc/libcdll.lds +++ b/contrib/sdk/sources/newlib/libc/libcdll.lds @@ -1,4 +1,5 @@ OUTPUT_FORMAT(pei-i386) +SEARCH_DIR("=/mingw32/lib") ENTRY("_libc_crt_startup") diff --git a/contrib/sdk/sources/newlib/libc/string/bcmp.c b/contrib/sdk/sources/newlib/libc/string/bcmp.c new file mode 100644 index 0000000000..8d6e12ffb4 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/bcmp.c @@ -0,0 +1,49 @@ +/* +FUNCTION + <>---compare two memory areas + +INDEX + bcmp + +ANSI_SYNOPSIS + #include + int bcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + #include + int bcmp(<[s1]>, <[s2]>, <[n]>) + const void *<[s1]>; + const void *<[s2]>; + size_t <[n]>; + +DESCRIPTION + This function compares not more than <[n]> bytes of the + object pointed to by <[s1]> with the object pointed to by <[s2]>. + + This function is identical to <>. + +RETURNS + The function returns an integer greater than, equal to or + less than zero according to whether the object pointed to by + <[s1]> is greater than, equal to or less than the object + pointed to by <[s2]>. + +PORTABILITY +<> requires no supporting OS subroutines. + +QUICKREF + bcmp ansi pure +*/ + +#include +#include + +int +_DEFUN (bcmp, (m1, m2, n), + _CONST void *m1 _AND + _CONST void *m2 _AND + size_t n) + +{ + return memcmp (m1, m2, n); +} diff --git a/contrib/sdk/sources/newlib/libc/string/bcopy.c b/contrib/sdk/sources/newlib/libc/string/bcopy.c new file mode 100644 index 0000000000..2881fd92cc --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/bcopy.c @@ -0,0 +1,39 @@ +/* +FUNCTION + <>---copy memory regions + +ANSI_SYNOPSIS + #include + void bcopy(const void *<[in]>, void *<[out]>, size_t <[n]>); + +TRAD_SYNOPSIS + void bcopy(<[in]>, <[out]>, <[n]> + const void *<[in]>; + void *<[out]>; + size_t <[n]>; + +DESCRIPTION + This function copies <[n]> bytes from the memory region + pointed to by <[in]> to the memory region pointed to by + <[out]>. + + This function is implemented in term of <>. + +PORTABILITY +<> requires no supporting OS subroutines. + +QUICKREF + bcopy - pure +*/ + +#include +#include + +void +_DEFUN (bcopy, (b1, b2, length), + _CONST void *b1 _AND + void *b2 _AND + size_t length) +{ + memmove (b2, b1, length); +} diff --git a/contrib/sdk/sources/newlib/libc/string/bzero.c b/contrib/sdk/sources/newlib/libc/string/bzero.c new file mode 100644 index 0000000000..dbcae02d64 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/bzero.c @@ -0,0 +1,43 @@ +/* +FUNCTION +<>---initialize memory to zero + +INDEX + bzero + +ANSI_SYNOPSIS + #include + void bzero(void *<[b]>, size_t <[length]>); + +TRAD_SYNOPSIS + #include + void bzero(<[b]>, <[length]>) + void *<[b]>; + size_t <[length]>; + +DESCRIPTION +<> initializes <[length]> bytes of memory, starting at address +<[b]>, to zero. + +RETURNS +<> does not return a result. + +PORTABILITY +<> is in the Berkeley Software Distribution. +Neither ANSI C nor the System V Interface Definition (Issue 2) require +<>. + +<> requires no supporting OS subroutines. +*/ + +#include + +_VOID +_DEFUN (bzero, (b, length), + void *b _AND + size_t length) +{ + char *ptr = (char *)b; + while (length--) + *ptr++ = 0; +} diff --git a/contrib/sdk/sources/newlib/libc/string/explicit_bzero.c b/contrib/sdk/sources/newlib/libc/string/explicit_bzero.c new file mode 100644 index 0000000000..5124df23ca --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/explicit_bzero.c @@ -0,0 +1,16 @@ +/* $OpenBSD: explicit_bzero.c,v 1.2 2014/06/10 04:17:37 deraadt Exp $ */ +/* + * Public domain. + * Written by Ted Unangst + */ + +#include + +/* + * explicit_bzero - don't let the compiler optimize away bzero + */ +void +explicit_bzero(void *p, size_t n) +{ + bzero(p, n); +} diff --git a/contrib/sdk/sources/newlib/libc/string/gnu_basename.c b/contrib/sdk/sources/newlib/libc/string/gnu_basename.c new file mode 100644 index 0000000000..90e22ccdf6 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/gnu_basename.c @@ -0,0 +1,26 @@ +#ifndef _NO_BASENAME +/* Copyright 2015 Red Hat, Inc. + * Permission to use, copy, modify, and distribute this software + * is freely granted, provided that this notice is preserved. + */ + +/* The differences with the POSIX version (unix/basename.c): + * - declared in (instead of ); + * - the argument is never modified, and therefore is marked const; + * - the empty string is returned if path is an empty string, "/", or ends + * with a trailing slash. + */ + +#include + +char * +_DEFUN (__gnu_basename, (path), + const char *path) +{ + char *p; + if ((p = strrchr (path, '/'))) + return p + 1; + return (char *) path; +} + +#endif /* !_NO_BASENAME */ diff --git a/contrib/sdk/sources/newlib/libc/string/index.c b/contrib/sdk/sources/newlib/libc/string/index.c new file mode 100644 index 0000000000..ec241ffa80 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/index.c @@ -0,0 +1,45 @@ +/* +FUNCTION + <>---search for character in string + +INDEX + index + +ANSI_SYNOPSIS + #include + char * index(const char *<[string]>, int <[c]>); + +TRAD_SYNOPSIS + #include + char * index(<[string]>, <[c]>); + char *<[string]>; + int *<[c]>; + +DESCRIPTION + This function finds the first occurence of <[c]> (converted to + a char) in the string pointed to by <[string]> (including the + terminating null character). + + This function is identical to <>. + +RETURNS + Returns a pointer to the located character, or a null pointer + if <[c]> does not occur in <[string]>. + +PORTABILITY +<> requires no supporting OS subroutines. + +QUICKREF + index - pure +*/ + +#include +#include + +char * +_DEFUN (index, (s, c), + _CONST char *s _AND + int c) +{ + return strchr (s, c); +} diff --git a/contrib/sdk/sources/newlib/libc/string/memccpy.c b/contrib/sdk/sources/newlib/libc/string/memccpy.c new file mode 100644 index 0000000000..332ed46604 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/memccpy.c @@ -0,0 +1,144 @@ +/* +FUNCTION + <>---copy memory regions with end-token check + +ANSI_SYNOPSIS + #include + void* memccpy(void *restrict <[out]>, const void *restrict <[in]>, + int <[endchar]>, size_t <[n]>); + +TRAD_SYNOPSIS + void *memccpy(<[out]>, <[in]>, <[endchar]>, <[n]> + void *<[out]>; + void *<[in]>; + int <[endchar]>; + size_t <[n]>; + +DESCRIPTION + This function copies up to <[n]> bytes from the memory region + pointed to by <[in]> to the memory region pointed to by + <[out]>. If a byte matching the <[endchar]> is encountered, + the byte is copied and copying stops. + + If the regions overlap, the behavior is undefined. + +RETURNS + <> returns a pointer to the first byte following the + <[endchar]> in the <[out]> region. If no byte matching + <[endchar]> was copied, then <> is returned. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. + + */ + +#include <_ansi.h> +#include +#include +#include + +/* Nonzero if either X or Y is not aligned on a "long" boundary. */ +#define UNALIGNED(X, Y) \ + (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1))) + +/* How many bytes are copied each iteration of the word copy loop. */ +#define LITTLEBLOCKSIZE (sizeof (long)) + +/* Threshhold for punting to the byte copier. */ +#define TOO_SMALL(LEN) ((LEN) < LITTLEBLOCKSIZE) + +/* Macros for detecting endchar */ +#if LONG_MAX == 2147483647L +#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080) +#else +#if LONG_MAX == 9223372036854775807L +/* Nonzero if X (a long int) contains a NULL byte. */ +#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080) +#else +#error long int is not a 32bit or 64bit type. +#endif +#endif + + +_PTR +_DEFUN (memccpy, (dst0, src0, endchar, len0), + _PTR __restrict dst0 _AND + _CONST _PTR __restrict src0 _AND + int endchar0 _AND + size_t len0) +{ + +#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) + _PTR ptr = NULL; + char *dst = (char *) dst0; + char *src = (char *) src0; + char endchar = endchar0 & 0xff; + + while (len0--) + { + if ((*dst++ = *src++) == endchar) + { + ptr = dst; + break; + } + } + + return ptr; +#else + _PTR ptr = NULL; + char *dst = dst0; + _CONST char *src = src0; + long *aligned_dst; + _CONST long *aligned_src; + char endchar = endchar0 & 0xff; + + /* If the size is small, or either SRC or DST is unaligned, + then punt into the byte copy loop. This should be rare. */ + if (!TOO_SMALL(len0) && !UNALIGNED (src, dst)) + { + unsigned int i; + unsigned long mask = 0; + + aligned_dst = (long*)dst; + aligned_src = (long*)src; + + /* The fast code reads the ASCII one word at a time and only + performs the bytewise search on word-sized segments if they + contain the search character, which is detected by XORing + the word-sized segment with a word-sized block of the search + character and then detecting for the presence of NULL in the + result. */ + for (i = 0; i < LITTLEBLOCKSIZE; i++) + mask = (mask << 8) + endchar; + + + /* Copy one long word at a time if possible. */ + while (len0 >= LITTLEBLOCKSIZE) + { + unsigned long buffer = (unsigned long)(*aligned_src); + buffer ^= mask; + if (DETECTNULL (buffer)) + break; /* endchar is found, go byte by byte from here */ + *aligned_dst++ = *aligned_src++; + len0 -= LITTLEBLOCKSIZE; + } + + /* Pick up any residual with a byte copier. */ + dst = (char*)aligned_dst; + src = (char*)aligned_src; + } + + while (len0--) + { + if ((*dst++ = *src++) == endchar) + { + ptr = dst; + break; + } + } + + return ptr; +#endif /* not PREFER_SIZE_OVER_SPEED */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/memmem.c b/contrib/sdk/sources/newlib/libc/string/memmem.c new file mode 100644 index 0000000000..25704e467d --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/memmem.c @@ -0,0 +1,102 @@ +/* Byte-wise substring search, using the Two-Way algorithm. + * Copyright (C) 2008 Eric Blake + * Permission to use, copy, modify, and distribute this software + * is freely granted, provided that this notice is preserved. + */ + +/* +FUNCTION + <>---find memory segment + +INDEX + memmem + +ANSI_SYNOPSIS + #include + char *memmem(const void *<[s1]>, size_t <[l1]>, const void *<[s2]>, + size_t <[l2]>); + +DESCRIPTION + + Locates the first occurrence in the memory region pointed to + by <[s1]> with length <[l1]> of the sequence of bytes pointed + to by <[s2]> of length <[l2]>. If you already know the + lengths of your haystack and needle, <> can be much + faster than <>. + +RETURNS + Returns a pointer to the located segment, or a null pointer if + <[s2]> is not found. If <[l2]> is 0, <[s1]> is returned. + +PORTABILITY +<> is a newlib extension. + +<> requires no supporting OS subroutines. + +QUICKREF + memmem pure +*/ + +#include + +#if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__) +# define RETURN_TYPE void * +# define AVAILABLE(h, h_l, j, n_l) ((j) <= (h_l) - (n_l)) +# include "str-two-way.h" +#endif + +void * +_DEFUN (memmem, (haystack_start, haystack_len, needle_start, needle_len), + const void *haystack_start _AND + size_t haystack_len _AND + const void *needle_start _AND + size_t needle_len) +{ + /* Abstract memory is considered to be an array of 'unsigned char' values, + not an array of 'char' values. See ISO C 99 section 6.2.6.1. */ + const unsigned char *haystack = (const unsigned char *) haystack_start; + const unsigned char *needle = (const unsigned char *) needle_start; + + if (needle_len == 0) + /* The first occurrence of the empty string is deemed to occur at + the beginning of the string. */ + return (void *) haystack; + +#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) + + /* Less code size, but quadratic performance in the worst case. */ + while (needle_len <= haystack_len) + { + if (!memcmp (haystack, needle, needle_len)) + return (void *) haystack; + haystack++; + haystack_len--; + } + return NULL; + +#else /* compilation for speed */ + + /* Larger code size, but guaranteed linear performance. */ + + /* Sanity check, otherwise the loop might search through the whole + memory. */ + if (haystack_len < needle_len) + return NULL; + + /* Use optimizations in memchr when possible, to reduce the search + size of haystack using a linear algorithm with a smaller + coefficient. However, avoid memchr for long needles, since we + can often achieve sublinear performance. */ + if (needle_len < LONG_NEEDLE_THRESHOLD) + { + haystack = memchr (haystack, *needle, haystack_len); + if (!haystack || needle_len == 1) + return (void *) haystack; + haystack_len -= haystack - (const unsigned char *) haystack_start; + if (haystack_len < needle_len) + return NULL; + return two_way_short_needle (haystack, haystack_len, needle, needle_len); + } + return two_way_long_needle (haystack, haystack_len, needle, needle_len); +#endif /* compilation for speed */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/mempcpy.c b/contrib/sdk/sources/newlib/libc/string/mempcpy.c new file mode 100644 index 0000000000..5c6738f22a --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/mempcpy.c @@ -0,0 +1,107 @@ +/* +FUNCTION + <>---copy memory regions and return end pointer + +ANSI_SYNOPSIS + #include + void* mempcpy(void *<[out]>, const void *<[in]>, size_t <[n]>); + +TRAD_SYNOPSIS + void *mempcpy(<[out]>, <[in]>, <[n]> + void *<[out]>; + void *<[in]>; + size_t <[n]>; + +DESCRIPTION + This function copies <[n]> bytes from the memory region + pointed to by <[in]> to the memory region pointed to by + <[out]>. + + If the regions overlap, the behavior is undefined. + +RETURNS + <> returns a pointer to the byte following the + last byte copied to the <[out]> region. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. + + */ + +#include <_ansi.h> +#include +#include +#include + +/* Nonzero if either X or Y is not aligned on a "long" boundary. */ +#define UNALIGNED(X, Y) \ + (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1))) + +/* How many bytes are copied each iteration of the 4X unrolled loop. */ +#define BIGBLOCKSIZE (sizeof (long) << 2) + +/* How many bytes are copied each iteration of the word copy loop. */ +#define LITTLEBLOCKSIZE (sizeof (long)) + +/* Threshhold for punting to the byte copier. */ +#define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE) + +_PTR +_DEFUN (mempcpy, (dst0, src0, len0), + _PTR dst0 _AND + _CONST _PTR src0 _AND + size_t len0) +{ +#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) + char *dst = (char *) dst0; + char *src = (char *) src0; + + while (len0--) + { + *dst++ = *src++; + } + + return dst; +#else + char *dst = dst0; + _CONST char *src = src0; + long *aligned_dst; + _CONST long *aligned_src; + + /* If the size is small, or either SRC or DST is unaligned, + then punt into the byte copy loop. This should be rare. */ + if (!TOO_SMALL(len0) && !UNALIGNED (src, dst)) + { + aligned_dst = (long*)dst; + aligned_src = (long*)src; + + /* Copy 4X long words at a time if possible. */ + while (len0 >= BIGBLOCKSIZE) + { + *aligned_dst++ = *aligned_src++; + *aligned_dst++ = *aligned_src++; + *aligned_dst++ = *aligned_src++; + *aligned_dst++ = *aligned_src++; + len0 -= BIGBLOCKSIZE; + } + + /* Copy one long word at a time if possible. */ + while (len0 >= LITTLEBLOCKSIZE) + { + *aligned_dst++ = *aligned_src++; + len0 -= LITTLEBLOCKSIZE; + } + + /* Pick up any residual with a byte copier. */ + dst = (char*)aligned_dst; + src = (char*)aligned_src; + } + + while (len0--) + *dst++ = *src++; + + return dst; +#endif /* not PREFER_SIZE_OVER_SPEED */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/memrchr.c b/contrib/sdk/sources/newlib/libc/string/memrchr.c new file mode 100644 index 0000000000..60dee42ed1 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/memrchr.c @@ -0,0 +1,134 @@ +/* +FUNCTION + <>---reverse search for character in memory + +INDEX + memrchr + +ANSI_SYNOPSIS + #include + void *memrchr(const void *<[src]>, int <[c]>, size_t <[length]>); + +TRAD_SYNOPSIS + #include + void *memrchr(<[src]>, <[c]>, <[length]>) + void *<[src]>; + void *<[c]>; + size_t <[length]>; + +DESCRIPTION + This function searches memory starting at <[length]> bytes + beyond <<*<[src]>>> backwards for the character <[c]>. + The search only ends with the first occurrence of <[c]>; in + particular, <> does not terminate the search. + +RETURNS + If the character <[c]> is found within <[length]> characters + of <<*<[src]>>>, a pointer to the character is returned. If + <[c]> is not found, then <> is returned. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. + +QUICKREF + memrchr +*/ + +#include <_ansi.h> +#include +#include + +/* Nonzero if X is not aligned on a "long" boundary. */ +#define UNALIGNED(X) ((long)(X + 1) & (sizeof (long) - 1)) + +/* How many bytes are loaded each iteration of the word copy loop. */ +#define LBLOCKSIZE (sizeof (long)) + +/* Threshhold for punting to the bytewise iterator. */ +#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) + +#if LONG_MAX == 2147483647L +#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080) +#else +#if LONG_MAX == 9223372036854775807L +/* Nonzero if X (a long int) contains a NULL byte. */ +#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080) +#else +#error long int is not a 32bit or 64bit type. +#endif +#endif + +#ifndef DETECTNULL +#error long int is not a 32bit or 64bit byte +#endif + +/* DETECTCHAR returns nonzero if (long)X contains the byte used + to fill (long)MASK. */ +#define DETECTCHAR(X,MASK) (DETECTNULL(X ^ MASK)) + +_PTR +_DEFUN (memrchr, (src_void, c, length), + _CONST _PTR src_void _AND + int c _AND + size_t length) +{ + _CONST unsigned char *src = (_CONST unsigned char *) src_void + length - 1; + unsigned char d = c; + +#if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__) + unsigned long *asrc; + unsigned long mask; + unsigned int i; + + while (UNALIGNED (src)) + { + if (!length--) + return NULL; + if (*src == d) + return (void *) src; + src--; + } + + if (!TOO_SMALL (length)) + { + /* If we get this far, we know that length is large and src is + word-aligned. */ + /* The fast code reads the source one word at a time and only + performs the bytewise search on word-sized segments if they + contain the search character, which is detected by XORing + the word-sized segment with a word-sized block of the search + character and then detecting for the presence of NUL in the + result. */ + asrc = (unsigned long *) (src - LBLOCKSIZE + 1); + mask = d << 8 | d; + mask = mask << 16 | mask; + for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) + mask = (mask << i) | mask; + + while (length >= LBLOCKSIZE) + { + if (DETECTCHAR (*asrc, mask)) + break; + length -= LBLOCKSIZE; + asrc--; + } + + /* If there are fewer than LBLOCKSIZE characters left, + then we resort to the bytewise loop. */ + + src = (unsigned char *) asrc + LBLOCKSIZE - 1; + } + +#endif /* not PREFER_SIZE_OVER_SPEED */ + + while (length--) + { + if (*src == d) + return (void *) src; + src--; + } + + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/rawmemchr.c b/contrib/sdk/sources/newlib/libc/string/rawmemchr.c new file mode 100644 index 0000000000..4b5a4cdeb3 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/rawmemchr.c @@ -0,0 +1,121 @@ +/* +FUNCTION + <>---find character in memory + +INDEX + rawmemchr + +ANSI_SYNOPSIS + #include + void *rawmemchr(const void *<[src]>, int <[c]>); + +TRAD_SYNOPSIS + #include + void *rawmemchr(<[src]>, <[c]>) + void *<[src]>; + void *<[c]>; + +DESCRIPTION + This function searches memory starting at <<*<[src]>>> for the + character <[c]>. The search only ends with the first occurrence + of <[c]>; in particular, <> does not terminate the search. + No bounds checking is performed, so this function should only + be used when it is certain that the character <[c]> will be found. + +RETURNS + A pointer to the first occurance of character <[c]>. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. + +QUICKREF + rawmemchr +*/ + +#include <_ansi.h> +#include +#include + +/* Nonzero if X is not aligned on a "long" boundary. */ +#define UNALIGNED(X) ((long)X & (sizeof (long) - 1)) + +/* How many bytes are loaded each iteration of the word copy loop. */ +#define LBLOCKSIZE (sizeof (long)) + +/* Threshhold for punting to the bytewise iterator. */ +#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) + +#if LONG_MAX == 2147483647L +#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080) +#else +#if LONG_MAX == 9223372036854775807L +/* Nonzero if X (a long int) contains a NULL byte. */ +#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080) +#else +#error long int is not a 32bit or 64bit type. +#endif +#endif + +#ifndef DETECTNULL +#error long int is not a 32bit or 64bit byte +#endif + +/* DETECTCHAR returns nonzero if (long)X contains the byte used + to fill (long)MASK. */ +#define DETECTCHAR(X,MASK) (DETECTNULL(X ^ MASK)) + +_PTR +_DEFUN (rawmemchr, (src_void, c), + _CONST _PTR src_void _AND + int c) +{ + _CONST unsigned char *src = (_CONST unsigned char *) src_void; + unsigned char d = c; + +#if !defined(PREFER_SIZE_OVER_SPEED) && !defined(__OPTIMIZE_SIZE__) + unsigned long *asrc; + unsigned long mask; + unsigned int i; + + while (UNALIGNED (src)) + { + if (*src == d) + return (void *) src; + src++; + } + + /* If we get this far, we know that src is word-aligned. */ + /* The fast code reads the source one word at a time and only + performs the bytewise search on word-sized segments if they + contain the search character, which is detected by XORing + the word-sized segment with a word-sized block of the search + character and then detecting for the presence of NUL in the + result. */ + asrc = (unsigned long *) src; + mask = d << 8 | d; + mask = mask << 16 | mask; + for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) + mask = (mask << i) | mask; + + while (1) + { + if (DETECTCHAR (*asrc, mask)) + break; + asrc++; + } + + /* We have the matching word, now we resort to a bytewise loop. */ + + src = (unsigned char *) asrc; + +#endif /* !PREFER_SIZE_OVER_SPEED && !__OPTIMIZE_SIZE__ */ + + while (1) + { + if (*src == d) + return (void *) src; + src++; + } +} diff --git a/contrib/sdk/sources/newlib/libc/string/rindex.c b/contrib/sdk/sources/newlib/libc/string/rindex.c new file mode 100644 index 0000000000..daa1c52378 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/rindex.c @@ -0,0 +1,45 @@ +/* +FUNCTION + <>---reverse search for character in string + +INDEX + rindex + +ANSI_SYNOPSIS + #include + char * rindex(const char *<[string]>, int <[c]>); + +TRAD_SYNOPSIS + #include + char * rindex(<[string]>, <[c]>); + char *<[string]>; + int *<[c]>; + +DESCRIPTION + This function finds the last occurence of <[c]> (converted to + a char) in the string pointed to by <[string]> (including the + terminating null character). + + This function is identical to <>. + +RETURNS + Returns a pointer to the located character, or a null pointer + if <[c]> does not occur in <[string]>. + +PORTABILITY +<> requires no supporting OS subroutines. + +QUICKREF + rindex - pure +*/ + +#include +#include + +char * +_DEFUN (rindex, (s, c), + _CONST char *s _AND + int c) +{ + return strrchr (s, c); +} diff --git a/contrib/sdk/sources/newlib/libc/string/strchrnul.c b/contrib/sdk/sources/newlib/libc/string/strchrnul.c new file mode 100644 index 0000000000..afeef434ec --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strchrnul.c @@ -0,0 +1,47 @@ +/* +FUNCTION + <>---search for character in string + +INDEX + strchrnul + +ANSI_SYNOPSIS + #include + char * strchrnul(const char *<[string]>, int <[c]>); + +TRAD_SYNOPSIS + #include + char * strchrnul(<[string]>, <[c]>); + const char *<[string]>; + int <[c]>; + +DESCRIPTION + This function finds the first occurence of <[c]> (converted to + a char) in the string pointed to by <[string]> (including the + terminating null character). + +RETURNS + Returns a pointer to the located character, or a pointer + to the concluding null byte if <[c]> does not occur in <[string]>. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. It uses +strchr() and strlen() from elsewhere in this library. + +QUICKREF + strchrnul +*/ + +#include + +char * +_DEFUN (strchrnul, (s1, i), + _CONST char *s1 _AND + int i) +{ + char *s = strchr(s1, i); + + return s ? s : (char *)s1 + strlen(s1); +} diff --git a/contrib/sdk/sources/newlib/libc/string/strerror_r.c b/contrib/sdk/sources/newlib/libc/string/strerror_r.c new file mode 100644 index 0000000000..d26a412a5a --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strerror_r.c @@ -0,0 +1,85 @@ +/* GNU variant of strerror_r. */ +/* +FUNCTION + <>---convert error number to string and copy to buffer + +INDEX + strerror_r + +ANSI_SYNOPSIS + #include + #ifdef _GNU_SOURCE + char *strerror_r(int <[errnum]>, char *<[buffer]>, size_t <[n]>); + #else + int strerror_r(int <[errnum]>, char *<[buffer]>, size_t <[n]>); + #endif + +TRAD_SYNOPSIS + #include + char *strerror_r(<[errnum]>, <[buffer]>, <[n]>) + int <[errnum]>; + char *<[buffer]>; + size_t <[n]>; + +DESCRIPTION +<> converts the error number <[errnum]> into a +string and copies the result into the supplied <[buffer]> for +a length up to <[n]>, including the NUL terminator. The value of +<[errnum]> is usually a copy of <>. If <> is not a known +error number, the result is the empty string. + +See <> for how strings are mapped to <>. + +RETURNS +There are two variants: the GNU version always returns a NUL-terminated +string, which is <[buffer]> if all went well, but which is another +pointer if <[n]> was too small (leaving <[buffer]> untouched). If the +return is not <[buffer]>, your application must not modify that string. +The POSIX version returns 0 on success, <[EINVAL]> if <> was not +recognized, and <[ERANGE]> if <[n]> was too small. The variant chosen +depends on macros that you define before inclusion of <>. + +PORTABILITY +<> with a <[char *]> result is a GNU extension. +<> with an <[int]> result is required by POSIX 2001. +This function is compliant only if <<_user_strerror>> is not provided, +or if it is thread-safe and uses separate storage according to whether +the second argument of that function is non-zero. For more details +on <<_user_strerror>>, see the <> documentation. + +POSIX states that the contents of <[buf]> are unspecified on error, +although this implementation guarantees a NUL-terminated string for +all except <[n]> of 0. + +POSIX recommends that unknown <[errnum]> result in a message including +that value, however it is not a requirement and this implementation +provides only an empty string (unless you provide <<_user_strerror>>). +POSIX also recommends that unknown <[errnum]> fail with EINVAL even +when providing such a message, however it is not a requirement and +this implementation will return success if <<_user_strerror>> provided +a non-empty alternate string without assigning into its third argument. + +<> requires no supporting OS subroutines. + +*/ + +#undef __STRICT_ANSI__ +#define _GNU_SOURCE +#include +#include +#undef strerror_r + +/* For backwards-compatible linking, this must be the GNU signature; + see xpg_strerror_r.c for the POSIX version. */ +char * +_DEFUN (strerror_r, (errnum, buffer, n), + int errnum _AND + char *buffer _AND + size_t n) +{ + char *error = _strerror_r (_REENT, errnum, 1, NULL); + + if (strlen (error) >= n) + return error; + return strcpy (buffer, error); +} diff --git a/contrib/sdk/sources/newlib/libc/string/strlcat.c b/contrib/sdk/sources/newlib/libc/string/strlcat.c new file mode 100644 index 0000000000..0c47bd5270 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strlcat.c @@ -0,0 +1,74 @@ +/* $OpenBSD: strlcat.c,v 1.8 2001/05/13 15:40:15 deraadt Exp $ */ + +/* + * Copyright (c) 1998 Todd C. Miller + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. 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 ``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. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char *rcsid = "$OpenBSD: strlcat.c,v 1.8 2001/05/13 15:40:15 deraadt Exp $"; +#endif /* LIBC_SCCS and not lint */ + +#include +#include + +/* + * Appends src to string dst of size siz (unlike strncat, siz is the + * full size of dst, not space left). At most siz-1 characters + * will be copied. Always NUL terminates (unless siz <= strlen(dst)). + * Returns strlen(src) + MIN(siz, strlen(initial dst)). + * If retval >= siz, truncation occurred. + */ +size_t +_DEFUN (strlcat, (dst, src, siz), + char *dst _AND + _CONST char *src _AND + size_t siz) +{ + register char *d = dst; + register const char *s = src; + register size_t n = siz; + size_t dlen; + + /* Find the end of dst and adjust bytes left but don't go past end */ + while (n-- != 0 && *d != '\0') + d++; + dlen = d - dst; + n = siz - dlen; + + if (n == 0) + return(dlen + strlen(s)); + while (*s != '\0') { + if (n != 1) { + *d++ = *s; + n--; + } + s++; + } + *d = '\0'; + + return(dlen + (s - src)); /* count does not include NUL */ +} + diff --git a/contrib/sdk/sources/newlib/libc/string/strlcpy.c b/contrib/sdk/sources/newlib/libc/string/strlcpy.c new file mode 100644 index 0000000000..c31001642e --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strlcpy.c @@ -0,0 +1,70 @@ +/* $OpenBSD: strlcpy.c,v 1.5 2001/05/13 15:40:16 deraadt Exp $ */ + +/* + * Copyright (c) 1998 Todd C. Miller + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. 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 ``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. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char *rcsid = "$OpenBSD: strlcpy.c,v 1.5 2001/05/13 15:40:16 deraadt Exp $"; +#endif /* LIBC_SCCS and not lint */ + +#include +#include + +/* + * Copy src to string dst of size siz. At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns strlen(src); if retval >= siz, truncation occurred. + */ +size_t +_DEFUN (strlcpy, (dst, src, siz), + char *dst _AND + _CONST char *src _AND + size_t siz) +{ + register char *d = dst; + register const char *s = src; + register size_t n = siz; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) { + do { + if ((*d++ = *s++) == 0) + break; + } while (--n != 0); + } + + /* Not enough room in dst, add NUL and traverse rest of src */ + if (n == 0) { + if (siz != 0) + *d = '\0'; /* NUL-terminate dst */ + while (*s++) + ; + } + + return(s - src - 1); /* count does not include NUL */ +} + diff --git a/contrib/sdk/sources/newlib/libc/string/strlwr.c b/contrib/sdk/sources/newlib/libc/string/strlwr.c new file mode 100644 index 0000000000..3b73dba4bc --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strlwr.c @@ -0,0 +1,46 @@ +/* +FUNCTION + <>---force string to lowercase + +INDEX + strlwr + +ANSI_SYNOPSIS + #include + char *strlwr(char *<[a]>); + +TRAD_SYNOPSIS + #include + char *strlwr(<[a]>) + char *<[a]>; + +DESCRIPTION + <> converts each character in the string at <[a]> to + lowercase. + +RETURNS + <> returns its argument, <[a]>. + +PORTABILITY +<> is not widely portable. + +<> requires no supporting OS subroutines. + +QUICKREF + strlwr +*/ + +#include +#include + +char * +_DEFUN (strlwr, (s), + char *s) +{ + unsigned char *ucs = (unsigned char *) s; + for ( ; *ucs != '\0'; ucs++) + { + *ucs = tolower(*ucs); + } + return s; +} diff --git a/contrib/sdk/sources/newlib/libc/string/strsignal.c b/contrib/sdk/sources/newlib/libc/string/strsignal.c new file mode 100644 index 0000000000..e03c1086b2 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/strsignal.c @@ -0,0 +1,256 @@ +/* +FUNCTION + <>---convert signal number to string + +INDEX + strsignal + +ANSI_SYNOPSIS + #include + char *strsignal(int <[signal]>); + +TRAD_SYNOPSIS + #include + char *strsignal(<[signal]>) + int <[signal]>; + +DESCRIPTION +<> converts the signal number <[signal]> into a +string. If <[signal]> is not a known signal number, the result +will be of the form "Unknown signal NN" where NN is the <[signal]> +is a decimal number. + +RETURNS +This function returns a pointer to a string. Your application must +not modify that string. + +PORTABILITY +POSIX.1-2008 C requires <>, but does not specify the strings used +for each signal number. + +<> requires no supporting OS subroutines. + +QUICKREF + strsignal pure +*/ + +/* + * Written by Joel Sherrill . + * + * COPYRIGHT (c) 2010. + * On-Line Applications Research Corporation (OAR). + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION + * OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS + * SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + * $Id$ + */ + +#include +#include +#include +#include + +char * +_DEFUN (strsignal, (signal), + int signal) +{ + char *buffer; + struct _reent *ptr; + + ptr = _REENT; + + _REENT_CHECK_SIGNAL_BUF(ptr); + buffer = _REENT_SIGNAL_BUF(ptr); + +#if defined(SIGRTMIN) && defined(SIGRTMAX) + if ((signal >= SIGRTMIN) || (signal <= SIGRTMAX)) { + siprintf (buffer, "Real-time signal %d", signal - SIGRTMIN); + return buffer; + } +#endif + + switch (signal) { +#ifdef SIGHUP + case SIGHUP: + buffer = "Hangup"; + break; +#endif +#ifdef SIGINT + case SIGINT: + buffer = "Interrupt"; + break; +#endif +#ifdef SIGQUIT + case SIGQUIT: + buffer = "Quit"; + break; +#endif +#ifdef SIGILL + case SIGILL: + buffer = "Illegal instruction"; + break; +#endif +#ifdef SIGTRAP + case SIGTRAP: + buffer = "Trace/breakpoint trap"; + break; +#endif +#ifdef SIGIOT + #if defined(SIGABRT) && (SIGIOT != SIGABRT) + case SIGABRT: + #endif + case SIGIOT: + buffer = "IOT trap"; + break; +#endif +#ifdef SIGEMT + case SIGEMT: + buffer = "EMT trap"; + break; +#endif +#ifdef SIGFPE + case SIGFPE: + buffer = "Floating point exception"; + break; +#endif +#ifdef SIGKILL + case SIGKILL: + buffer = "Killed"; + break; +#endif +#ifdef SIGBUS + case SIGBUS: + buffer = "Bus error"; + break; +#endif +#ifdef SIGSEGV + case SIGSEGV: + buffer = "Segmentation fault"; + break; +#endif +#ifdef SIGSYS + case SIGSYS: + buffer = "Bad system call"; + break; +#endif +#ifdef SIGPIPE + case SIGPIPE: + buffer = "Broken pipe"; + break; +#endif +#ifdef SIGALRM + case SIGALRM: + buffer = "Alarm clock"; + break; +#endif +#ifdef SIGTERM + case SIGTERM: + buffer = "Terminated"; + break; +#endif +#ifdef SIGURG + case SIGURG: + buffer = "Urgent I/O condition"; + break; +#endif +#ifdef SIGSTOP + case SIGSTOP: + buffer = "Stopped (signal)"; + break; +#endif +#ifdef SIGTSTP + case SIGTSTP: + buffer = "Stopped"; + break; +#endif +#ifdef SIGCONT + case SIGCONT: + buffer = "Continued"; + break; +#endif +#ifdef SIGCHLD + #if defined(SIGCLD) && (SIGCHLD != SIGCLD) + case SIGCLD: + #endif + case SIGCHLD: + buffer = "Child exited"; + break; +#endif +#ifdef SIGTTIN + case SIGTTIN: + buffer = "Stopped (tty input)"; + break; +#endif +#ifdef SIGTTOUT + case SIGTTOUT: + buffer = "Stopped (tty output)"; + break; +#endif +#ifdef SIGIO + #if defined(SIGPOLL) && (SIGIO != SIGPOLL) + case SIGPOLL: + #endif + case SIGIO: + buffer = "I/O possible"; + break; +#endif +#ifdef SIGWINCH + case SIGWINCH: + buffer = "Window changed"; + break; +#endif +#ifdef SIGUSR1 + case SIGUSR1: + buffer = "User defined signal 1"; + break; +#endif +#ifdef SIGUSR2 + case SIGUSR2: + buffer = "User defined signal 2"; + break; +#endif +#ifdef SIGPWR + case SIGPWR: + buffer = "Power Failure"; + break; +#endif +#ifdef SIGXCPU + case SIGXCPU: + buffer = "CPU time limit exceeded"; + break; +#endif +#ifdef SIGXFSZ + case SIGXFSZ: + buffer = "File size limit exceeded"; + break; +#endif +#ifdef SIGVTALRM + case SIGVTALRM : + buffer = "Virtual timer expired"; + break; +#endif +#ifdef SIGPROF + case SIGPROF: + buffer = "Profiling timer expired"; + break; +#endif +#if defined(SIGLOST) && SIGLOST != SIGPWR + case SIGLOST: + buffer = "Resource lost"; + break; +#endif + default: + siprintf (buffer, "Unknown signal %d", signal); + break; + } + + return buffer; +} diff --git a/contrib/sdk/sources/newlib/libc/string/swab.c b/contrib/sdk/sources/newlib/libc/string/swab.c new file mode 100644 index 0000000000..aee0763196 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/swab.c @@ -0,0 +1,44 @@ +/* +FUNCTION + <>---swap adjacent bytes + +ANSI_SYNOPSIS + #include + void swab(const void *<[in]>, void *<[out]>, ssize_t <[n]>); + +TRAD_SYNOPSIS + void swab(<[in]>, <[out]>, <[n]> + void *<[in]>; + void *<[out]>; + ssize_t <[n]>; + +DESCRIPTION + This function copies <[n]> bytes from the memory region + pointed to by <[in]> to the memory region pointed to by + <[out]>, exchanging adjacent even and odd bytes. + +PORTABILITY +<> requires no supporting OS subroutines. +*/ + +#include + +void +_DEFUN (swab, (b1, b2, length), + _CONST void *b1 _AND + void *b2 _AND + ssize_t length) +{ + const char *from = b1; + char *to = b2; + ssize_t ptr; + for (ptr = 1; ptr < length; ptr += 2) + { + char p = from[ptr]; + char q = from[ptr-1]; + to[ptr-1] = p; + to[ptr ] = q; + } + if (ptr == length) /* I.e., if length is odd, */ + to[ptr-1] = 0; /* then pad with a NUL. */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcpcpy.c b/contrib/sdk/sources/newlib/libc/string/wcpcpy.c new file mode 100644 index 0000000000..e1d9ad0739 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcpcpy.c @@ -0,0 +1,41 @@ +/* +FUNCTION + <>---copy a wide-character string returning a pointer to its end + +ANSI_SYNOPSIS + #include + wchar_t *wcpcpy(wchar_t *<[s1]>, const wchar_t *<[s2]>); + +TRAD_SYNOPSIS + wchar_t *wcpcpy(<[s1]>, <[s2]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + +DESCRIPTION + The <> function copies the wide-character string pointed to by + <[s2]> (including the terminating null wide-character code) into the + array pointed to by <[s1]>. If copying takes place between objects that + overlap, the behaviour is undefined. + +RETURNS + This function returns a pointer to the end of the destination string, + thus pointing to the trailing '\0'. + +PORTABILITY +<> is a GNU extension. + +No supporting OS subroutines are required. +*/ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcpcpy, (s1, s2), + wchar_t *__restrict s1 _AND + _CONST wchar_t *__restrict s2) +{ + while ((*s1++ = *s2++)) + ; + return --s1; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcpncpy.c b/contrib/sdk/sources/newlib/libc/string/wcpncpy.c new file mode 100644 index 0000000000..87843b4227 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcpncpy.c @@ -0,0 +1,62 @@ +/* +FUNCTION + <>---copy part of a wide-character string returning a pointer to its end + +ANSI_SYNOPSIS + #include + wchar_t *wcpncpy(wchar_t *__restrict <[s1]>, + const wchar_t *__restrict <[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wcpncpy(<[s1]>, <[s2]>, <[n]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + size_t <[n]>; + +DESCRIPTION + The <> function copies not more than n wide-character codes + (wide-character codes that follow a null wide-character code are not + copied) from the array pointed to by <[s2]> to the array pointed to + by <[s1]>. If copying takes place between objects that overlap, the + behaviour is undefined. + + If the array pointed to by <[s2]> is a wide-character string that is + shorter than <[n]> wide-character codes, null wide-character codes are + appended to the copy in the array pointed to by <[s1]>, until <[n]> + wide-character codes in all are written. + +RETURNS + The <> function returns <[s1]>; no return value is reserved to + indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcpncpy, (dst, src, count), + wchar_t *__restrict dst _AND + _CONST wchar_t *__restrict src _AND + size_t count) +{ + wchar_t *ret = NULL; + + while (count > 0) + { + --count; + if ((*dst++ = *src++) == L'\0') + { + ret = dst - 1; + break; + } + } + while (count-- > 0) + *dst++ = L'\0'; + + return ret ? ret : dst; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscasecmp.c b/contrib/sdk/sources/newlib/libc/string/wcscasecmp.c new file mode 100644 index 0000000000..f9f169f8bd --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscasecmp.c @@ -0,0 +1,56 @@ +/* +FUNCTION + <>---case-insensitive wide character string compare + +INDEX + wcscasecmp + +ANSI_SYNOPSIS + #include + int wcscasecmp(const wchar_t *<[a]>, const wchar_t *<[b]>); + +TRAD_SYNOPSIS + #include + int wcscasecmp(<[a]>, <[b]>) + wchar_t *<[a]>; + wchar_t *<[b]>; + +DESCRIPTION + <> compares the wide character string at <[a]> to + the wide character string at <[b]> in a case-insensitive manner. + +RETURNS + + If <<*<[a]>>> sorts lexicographically after <<*<[b]>>> (after + both are converted to uppercase), <> returns a + number greater than zero. If the two strings match, + <> returns zero. If <<*<[a]>>> sorts + lexicographically before <<*<[b]>>>, <> returns a + number less than zero. + +PORTABILITY +POSIX-1.2008 + +<> requires no supporting OS subroutines. It uses +tolower() from elsewhere in this library. + +QUICKREF + wcscasecmp +*/ + +#include +#include + +int +_DEFUN (wcscasecmp, (s1, s2), + _CONST wchar_t *s1 _AND + _CONST wchar_t *s2) +{ + while (*s1 != '\0' && towlower(*s1) == towlower(*s2)) + { + s1++; + s2++; + } + + return towlower(*s1) - towlower(*s2); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscat.c b/contrib/sdk/sources/newlib/libc/string/wcscat.c new file mode 100644 index 0000000000..11afbe3a61 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscat.c @@ -0,0 +1,86 @@ +/* +FUNCTION + <>---concatenate two wide-character strings +INDEX + wcscat + +ANSI_SYNOPSIS + #include + wchar_t *wcscat(wchar_t *__restrict <[s1]>, + const wchar_t *__restrict <[s2]>); + +TRAD_SYNOPSIS + wchar_t *wcscat(<[s1]>, <[s2]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + +DESCRIPTION + The <> function appends a copy of the wide-character string + pointed to by <[s2]> (including the terminating null wide-character + code) to the end of the wide-character string pointed to by <[s1]>. + The initial wide-character code of <[s2]> overwrites the null + wide-character code at the end of <[s1]>. If copying takes place between + objects that overlap, the behaviour is undefined. + +RETURNS + The <> function returns <[s1]>; + no return value is reserved to indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcscat.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcscat.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp + */ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcscat, (s1, s2), + wchar_t *__restrict s1 _AND + _CONST wchar_t *__restrict s2) +{ + wchar_t *p; + wchar_t *q; + _CONST wchar_t *r; + + p = s1; + while (*p) + p++; + q = p; + r = s2; + while (*r) + *q++ = *r++; + *q = '\0'; + return s1; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcschr.c b/contrib/sdk/sources/newlib/libc/string/wcschr.c new file mode 100644 index 0000000000..fb35d1f42c --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcschr.c @@ -0,0 +1,82 @@ +/* +FUNCTION + <>---wide-character string scanning operation + +ANSI_SYNOPSIS + #include + wchar_t *wcschr(const wchar_t *<[s]>, wchar_t <[c]>); + +TRAD_SYNOPSIS + wchar_t *wcschr(<[s]>, <[c]> + const wchar_t *<[s]>; + wchar_t <[c]>; + +DESCRIPTION + The <> function locates the first occurrence of <[c]> in the + wide-character string pointed to by <[s]>. The value of <[c]> must be a + character representable as a type wchar_t and must be a wide-character + code corresponding to a valid character in the current locale. + The terminating null wide-character string. + +RETURNS + Upon completion, <> returns a pointer to the wide-character + code, or a null pointer if the wide-character code is not found. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcschr.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcschr.c,v 1.2 2000/12/21 05:07:25 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wcschr, (s, c), + _CONST wchar_t * s _AND + wchar_t c) +{ + _CONST wchar_t *p; + + p = s; + do + { + if (*p == c) + { + /* LINTED interface specification */ + return (wchar_t *) p; + } + } while (*p++); + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscmp.c b/contrib/sdk/sources/newlib/libc/string/wcscmp.c new file mode 100644 index 0000000000..03089620d9 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscmp.c @@ -0,0 +1,83 @@ +/* +FUNCTION + <>---compare two wide-character strings + +ANSI_SYNOPSIS + #include + int wcscmp(const wchar_t *<[s1]>, *<[s2]>); + +TRAD_SYNOPSIS + int wcscmp(<[s1]>, <[s2]> + const wchar_t *<[s1]>, <[s2]>; + +DESCRIPTION + The <> function compares the wide-character string pointed to + by <[s1]> to the wide-character string pointed to by <[s2]>. + + The sign of a non-zero return value is determined by the sign of the + difference between the values of the first pair of wide-character codes + that differ in the objects being compared. + +RETURNS + Upon completion, <> returns an integer greater than, equal to + or less than 0, if the wide-character string pointed to by <[s1]> is + greater than, equal to or less than the wide-character string pointed + to by <[s2]> respectively. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD$ */ + +/*- + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. + */ + +#include <_ansi.h> +#include + +/* + * Compare strings. + */ +int +_DEFUN (wcscmp, (s1, s2), + _CONST wchar_t * s1 _AND + _CONST wchar_t * s2) +{ + + while (*s1 == *s2++) + if (*s1++ == 0) + return (0); + return (*s1 - *--s2); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscoll.c b/contrib/sdk/sources/newlib/libc/string/wcscoll.c new file mode 100644 index 0000000000..0f0513a58a --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscoll.c @@ -0,0 +1,48 @@ +/* +FUNCTION + <>---locale-specific wide-character string compare + +INDEX + wcscoll + +ANSI_SYNOPSIS + #include + int wcscoll(const wchar_t *<[stra]>, const wchar_t * <[strb]>); + +TRAD_SYNOPSIS + #include + int wcscoll(<[stra]>, <[strb]>) + wchar_t *<[stra]>; + wchar_t *<[strb]>; + +DESCRIPTION + <> compares the wide-character string pointed to by + <[stra]> to the wide-character string pointed to by <[strb]>, + using an interpretation appropriate to the current <> + state. + + The current implementation of <> simply uses <> + and does not support any language-specific sorting. + +RETURNS + If the first string is greater than the second string, + <> returns a number greater than zero. If the two + strings are equivalent, <> returns zero. If the first + string is less than the second string, <> returns a + number less than zero. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). +*/ + +#include <_ansi.h> +#include + +int +_DEFUN (wcscoll, (a, b), + _CONST wchar_t *a _AND + _CONST wchar_t *b) + +{ + return wcscmp (a, b); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscpy.c b/contrib/sdk/sources/newlib/libc/string/wcscpy.c new file mode 100644 index 0000000000..ed8b484bc9 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscpy.c @@ -0,0 +1,80 @@ +/* +FUNCTION + <>---copy a wide-character string + +ANSI_SYNOPSIS + #include + wchar_t *wcscpy(wchar_t *__restrict <[s1]>, + const wchar_t *__restrict <[s2]>); + +TRAD_SYNOPSIS + wchar_t *wcscpy(<[s1]>, <[s2]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + +DESCRIPTION + The <> function copies the wide-character string pointed to by + <[s2]> (including the terminating null wide-character code) into the + array pointed to by <[s1]>. If copying takes place between objects that + overlap, the behaviour is undefined. + +RETURNS + The <> function returns <[s1]>; no return value is reserved to + indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcscpy.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcscpy.c,v 1.2 2000/12/21 04:51:09 itojun Exp + */ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcscpy, (s1, s2), + wchar_t *__restrict s1 _AND + _CONST wchar_t *__restrict s2) +{ + wchar_t *p; + _CONST wchar_t *q; + + *s1 = '\0'; + p = s1; + q = s2; + while (*q) + *p++ = *q++; + *p = '\0'; + + return s1; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcscspn.c b/contrib/sdk/sources/newlib/libc/string/wcscspn.c new file mode 100644 index 0000000000..5ab9656900 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcscspn.c @@ -0,0 +1,86 @@ +/* +FUNCTION + <>---get length of a complementary wide substring + +ANSI_SYNOPSIS + #include + size_t wcscspn(const wchar_t *<[s]>, wchar_t *<[set]>); + +TRAD_SYNOPSIS + size_t wcscspn(<[s]>, <[set]> + const wchar_t *<[s]>; + const wchar_t *<[set]>; + +DESCRIPTION + The <> function computes the length of the maximum initial + segment of the wide-character string pointed to by <[s]> which consists + entirely of wide-character codes not from the wide-character string + pointed to by <[set]>. + +RETURNS + The <> function returns the length of the initial substring of + <[s1]>; no return value is reserved to indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcscspn.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcscspn.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp + */ + +#include <_ansi.h> +#include + +size_t +_DEFUN (wcscspn, (s, set), + _CONST wchar_t * s _AND + _CONST wchar_t * set) +{ + _CONST wchar_t *p; + _CONST wchar_t *q; + + p = s; + while (*p) + { + q = set; + while (*q) + { + if (*p == *q) + goto done; + q++; + } + p++; + } + +done: + return (p - s); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsdup.c b/contrib/sdk/sources/newlib/libc/string/wcsdup.c new file mode 100644 index 0000000000..90be68e023 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsdup.c @@ -0,0 +1,62 @@ +/* +FUNCTION + <>---wide character string duplicate + +INDEX + wcsdup +INDEX + _wcsdup_r + +ANSI_SYNOPSIS + #include + wchar_t *wcsdup(const wchar_t *<[str]>); + + #include + wchar_t *_wcsdup_r(struct _reent *<[ptr]>, const wchar_t *<[str]>); + +TRAD_SYNOPSIS + #include + wchar_t *wcsdup(<[ptr]>, <[str]>) + struct _reent *<[ptr]>; + wchar_t *<[str]>; + +DESCRIPTION + <> allocates a new wide character string using <>, + and copies the content of the argument <[str]> into the newly + allocated string, thus making a copy of <[str]>. + +RETURNS + <> returns a pointer to the copy of <[str]> if enough + memory for the copy was available. Otherwise it returns NULL + and errno is set to ENOMEM. + +PORTABILITY +POSIX-1.2008 + +QUICKREF + wcsdup +*/ + +#include +#include +#include + +wchar_t * +_wcsdup_r (struct _reent *p, const wchar_t *str) +{ + size_t len = wcslen (str) + 1; + wchar_t *copy = _malloc_r (p, len * sizeof (wchar_t)); + if (copy) + wmemcpy (copy, str, len); + return copy; +} + +#ifndef _REENT_ONLY + +wchar_t * +wcsdup (const wchar_t *str) +{ + return _wcsdup_r (_REENT, str); +} + +#endif /* !_REENT_ONLY */ diff --git a/contrib/sdk/sources/newlib/libc/string/wcslcat.c b/contrib/sdk/sources/newlib/libc/string/wcslcat.c new file mode 100644 index 0000000000..75c085b5b8 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcslcat.c @@ -0,0 +1,108 @@ +/* +FUNCTION + <>---concatenate wide-character strings to specified length + +ANSI_SYNOPSIS + #include + size_t wcslcat(wchar_t *<[dst]>, const wchar_t *<[src]>, size_t <[siz]>); + +TRAD_SYNOPSIS + #include + size_t wcslcat(<[dst]>, <[src]>, <[siz]> + wchar_t *<[dst]>; + const wchar_t *<[src]>; + size_t <[siz]>; + +DESCRIPTION + The <> function appends wide characters from <[src]> to + end of the <[dst]> wide-character string so that the resultant + wide-character string is not more than <[siz]> wide characters + including the terminating null wide-character code. A terminating + null wide character is always added unless <[siz]> is 0. Thus, + the maximum number of wide characters that can be appended from + <[src]> is <[siz]> - 1. If copying takes place between objects + that overlap, the behaviour is undefined. + +RETURNS + Wide-character string length of initial <[dst]> plus the + wide-character string length of <[src]> (does not include + terminating null wide-characters). If the return value is + greater than or equal to <[siz]>, then truncation occurred and + not all wide characters from <[src]> were appended. + +PORTABILITY +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcslcat.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ +/* from OpenBSD: strlcat.c,v 1.3 2000/11/24 11:10:02 itojun Exp */ + +/* + * Copyright (c) 1998 Todd C. Miller + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. 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 ``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. + */ + +#include <_ansi.h> +#include + +/* + * Appends src to string dst of size siz (unlike wcsncat, siz is the + * full size of dst, not space left). At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns wcslen(initial dst) + wcslen(src); if retval >= siz, + * truncation occurred. + */ +size_t +_DEFUN (wcslcat, (dst, src, siz), + wchar_t * dst _AND + _CONST wchar_t * src _AND + size_t siz) +{ + wchar_t *d = dst; + _CONST wchar_t *s = src; + size_t n = siz; + size_t dlen; + + /* Find the end of dst and adjust bytes left but don't go past end */ + while (*d != '\0' && n-- != 0) + d++; + dlen = d - dst; + n = siz - dlen; + + if (n == 0) + return (dlen + wcslen (s)); + while (*s != '\0') + { + if (n != 1) + { + *d++ = *s; + n--; + } + s++; + } + *d = '\0'; + + return (dlen + (s - src)); /* count does not include NUL */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcslcpy.c b/contrib/sdk/sources/newlib/libc/string/wcslcpy.c new file mode 100644 index 0000000000..21c030b386 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcslcpy.c @@ -0,0 +1,102 @@ +/* +FUNCTION + <>---copy a wide-character string to specified length + +ANSI_SYNOPSIS + #include + size_t wcslcpy(wchar_t *<[dst]>, const wchar_t *<[src]>, size_t <[siz]>); + +TRAD_SYNOPSIS + #include + size_t wcslcpy(<[dst]>, <[src]>, <[siz]>) + wchar_t *<[dst]>; + const wchar_t *<[src]>; + size_t <[siz]>; + +DESCRIPTION + <> copies wide characters from <[src]> to <[dst]> + such that up to <[siz]> - 1 characters are copied. A + terminating null is appended to the result, unless <[siz]> + is zero. + +RETURNS + <> returns the number of wide characters in <[src]>, + not including the terminating null wide character. If the + return value is greater than or equal to <[siz]>, then + not all wide characters were copied from <[src]> and truncation + occurred. + +PORTABILITY +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcslcpy.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ +/* from OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp */ + +/* + * Copyright (c) 1998 Todd C. Miller + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. 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 ``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. + */ + +#include <_ansi.h> +#include + +/* + * Copy src to string dst of size siz. At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns wcslen(src); if retval >= siz, truncation occurred. + */ +size_t +_DEFUN (wcslcpy, (dst, src, siz), + wchar_t * dst _AND + _CONST wchar_t * src _AND + size_t siz) +{ + wchar_t *d = dst; + _CONST wchar_t *s = src; + size_t n = siz; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) + { + do + { + if ((*d++ = *s++) == 0) + break; + } + while (--n != 0); + } + + /* Not enough room in dst, add NUL and traverse rest of src */ + if (n == 0) + { + if (siz != 0) + *d = '\0'; /* NUL-terminate dst */ + while (*s++) + ; + } + + return (s - src - 1); /* count does not include NUL */ +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcslen.c b/contrib/sdk/sources/newlib/libc/string/wcslen.c new file mode 100644 index 0000000000..d671551af9 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcslen.c @@ -0,0 +1,72 @@ +/* +FUNCTION + <>---get wide-character string length + +ANSI_SYNOPSIS + #include + size_t wcslen(const wchar_t *<[s]>); + +TRAD_SYNOPSIS + size_t wcslen(<[s]> + const wchar_t *<[s]>; + +DESCRIPTION + The <> function computes the number of wide-character codes + in the wide-character string to which <[s]> points, not including the + terminating null wide-character code. + +RETURNS + The <> function returns the length of <[s]>; no return value is + reserved to indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcslen.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcslen.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp + */ + +#include <_ansi.h> +#include + +size_t +_DEFUN (wcslen, (s), + _CONST wchar_t * s) +{ + _CONST wchar_t *p; + + p = s; + while (*p) + p++; + + return p - s; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsncasecmp.c b/contrib/sdk/sources/newlib/libc/string/wcsncasecmp.c new file mode 100644 index 0000000000..1634ca195f --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsncasecmp.c @@ -0,0 +1,64 @@ +/* +FUNCTION + <>---case-insensitive wide character string compare + +INDEX + wcsncasecmp + +ANSI_SYNOPSIS + #include + int wcsncasecmp(const wchar_t *<[a]>, const wchar_t * <[b]>, size_t <[length]>); + +TRAD_SYNOPSIS + #include + int wcsncasecmp(<[a]>, <[b]>, <[length]>) + wchar_t *<[a]>; + wchar_t *<[b]>; + size_t <[length]> + +DESCRIPTION + <> compares up to <[length]> wide characters + from the string at <[a]> to the string at <[b]> in a + case-insensitive manner. + +RETURNS + + If <<*<[a]>>> sorts lexicographically after <<*<[b]>>> (after + both are converted to uppercase), <> returns a + number greater than zero. If the two strings are equivalent, + <> returns zero. If <<*<[a]>>> sorts + lexicographically before <<*<[b]>>>, <> returns a + number less than zero. + +PORTABILITY +POSIX-1.2008 + +<> requires no supporting OS subroutines. It uses +tolower() from elsewhere in this library. + +QUICKREF + wcsncasecmp +*/ + +#include +#include + +int +_DEFUN (wcsncasecmp, (s1, s2, n), + _CONST wchar_t *s1 _AND + _CONST wchar_t *s2 _AND + size_t n) +{ + if (n == 0) + return 0; + + while (n-- != 0 && towlower(*s1) == towlower(*s2)) + { + if (n == 0 || *s1 == '\0' || *s2 == '\0') + break; + s1++; + s2++; + } + + return towlower(*s1) - towlower(*s2); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsncat.c b/contrib/sdk/sources/newlib/libc/string/wcsncat.c new file mode 100644 index 0000000000..b73f6e93eb --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsncat.c @@ -0,0 +1,92 @@ +/* +FUNCTION + <>---concatenate part of two wide-character strings + +ANSI_SYNOPSIS + #include + wchar_t *wcsncat(wchar_t *__restrict <[s1]>, + const wchar_t *__restrict <[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wcsncat(<[s1]>, <[s2]>, <[n]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + size_t <[n]>; + +DESCRIPTION + The <> function appends not more than <[n]> wide-character + codes (a null wide-character code and wide-character codes that follow + it are not appended) from the array pointed to by <[s2]> to the end of + the wide-character string pointed to by <[s1]>. The initial + wide-character code of <[s2]> overwrites the null wide-character code + at the end of <[s1]>. + A terminating null wide-character code is always appended to the result. + If copying takes place between objects that overlap, the behaviour is + undefined. + +RETURNS + The <> function returns <[s1]>; no return value is reserved to + indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcsncat.c,v 1.1 2000/12/23 23:14:36 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcsncat.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp + */ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcsncat, (s1, s2, n), + wchar_t *__restrict s1 _AND + _CONST wchar_t *__restrict s2 _AND + size_t n) +{ + wchar_t *p; + wchar_t *q; + _CONST wchar_t *r; + + p = s1; + while (*p) + p++; + q = p; + r = s2; + while (*r && n) + { + *q++ = *r++; + n--; + } + *q = '\0'; + return s1; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsncmp.c b/contrib/sdk/sources/newlib/libc/string/wcsncmp.c new file mode 100644 index 0000000000..1897f5c4ea --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsncmp.c @@ -0,0 +1,91 @@ +/* +FUNCTION + <>---compare part of two wide-character strings + +ANSI_SYNOPSIS + #include + int wcsncmp(const wchar_t *<[s1]>, const wchar_t *<[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + int wcsncmp(<[s1]>, <[s2]>, <[n]> + const wchar_t *<[s1]>; + const wchar_t *<[s2]>; + size_t <[n]>; + +DESCRIPTION + The <> function compares not more than <[n]> wide-character + codes (wide-character codes that follow a null wide-character code are + not compared) from the array pointed to by <[s1]> to the array pointed + to by <[s2]>. + + The sign of a non-zero return value is determined by the sign of the + difference between the values of the first pair of wide-character codes + that differ in the objects being compared. + +RETURNS + Upon successful completion, <> returns an integer greater than, + equal to or less than 0, if the possibly null-terminated array pointed + to by <[s1]> is greater than, equal to or less than the possibly + null-terminated array pointed to by <[s2]> respectively. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD$ */ + +/* + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. + */ + +#include <_ansi.h> +#include + +int +_DEFUN (wcsncmp, (s1, s2, n), + _CONST wchar_t * s1 _AND + _CONST wchar_t * s2 _AND + size_t n) +{ + + if (n == 0) + return (0); + do + { + if (*s1 != *s2++) + { + return (*s1 - *--s2); + } + if (*s1++ == 0) + break; + } + while (--n != 0); + return (0); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsncpy.c b/contrib/sdk/sources/newlib/libc/string/wcsncpy.c new file mode 100644 index 0000000000..3d6d70b7d4 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsncpy.c @@ -0,0 +1,59 @@ +/* +FUNCTION + <>---copy part of a wide-character string + +ANSI_SYNOPSIS + #include + wchar_t *wcsncpy(wchar_t *__restrict <[s1]>, + const wchar_t *__restrict <[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wcsncpy(<[s1]>, <[s2]>, <[n]> + wchar_t *__restrict <[s1]>; + const wchar_t *__restrict <[s2]>; + size_t <[n]>; + +DESCRIPTION + The <> function copies not more than <[n]> wide-character codes + (wide-character codes that follow a null wide-character code are not + copied) from the array pointed to by <[s2]> to the array pointed to + by <[s1]>. If copying takes place between objects that overlap, the + behaviour is undefined. Note that if <[s1]> contains more than <[n]> + wide characters before its terminating null, the result is not + null-terminated. + + If the array pointed to by <[s2]> is a wide-character string that is + shorter than <[n]> wide-character codes, null wide-character codes are + appended to the copy in the array pointed to by <[s1]>, until <[n]> + wide-character codes in all are written. + +RETURNS + The <> function returns <[s1]>; no return value is reserved to + indicate an error. + +PORTABILITY +ISO/IEC 9899; POSIX.1. + +No supporting OS subroutines are required. +*/ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wcsncpy, (s1, s2, n), + wchar_t *__restrict s1 _AND + _CONST wchar_t *__restrict s2 _AND + size_t n) +{ + wchar_t *dscan=s1; + + while(n > 0) + { + --n; + if((*dscan++ = *s2++) == L'\0') break; + } + while(n-- > 0) *dscan++ = L'\0'; + + return s1; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsnlen.c b/contrib/sdk/sources/newlib/libc/string/wcsnlen.c new file mode 100644 index 0000000000..9d680d603f --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsnlen.c @@ -0,0 +1,75 @@ +/* +FUNCTION + <>---get fixed-size wide-character string length + +INDEX + wcsnlen + +ANSI_SYNOPSIS + #include + size_t wcsnlen(const wchar_t *<[s]>, size_t <[maxlen]>); + +TRAD_SYNOPSIS + #include + size_t wcsnlen(<[s]>, <[maxlen]>) + wchar_t *<[s]>; + size_t <[maxlen]>; + +DESCRIPTION + The <> function computes the number of wide-character codes + in the wide-character string pointed to by <[s]> not including the + terminating L'\0' wide character but at most <[maxlen]> wide + characters. + +RETURNS + <> returns the length of <[s]> if it is less then <[maxlen]>, + or <[maxlen]> if there is no L'\0' wide character in first <[maxlen]> + characters. + +PORTABILITY +<> is a GNU extension. + +<> requires no supporting OS subroutines. +*/ + +/* + * Copyright (c) 2003, Artem B. Bityuckiy (dedekind@mail.ru). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the above copyright notice, + * this condition statement, and the following disclaimer are retained + * in any redistributions of the source code. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + */ + +#include <_ansi.h> +#include +#include + +size_t +_DEFUN(wcsnlen, (s, maxlen), + _CONST wchar_t *s _AND + size_t maxlen) +{ + _CONST wchar_t *p; + + p = s; + while (*p && maxlen-- > 0) + p++; + + return (size_t)(p - s); +} + + + diff --git a/contrib/sdk/sources/newlib/libc/string/wcspbrk.c b/contrib/sdk/sources/newlib/libc/string/wcspbrk.c new file mode 100644 index 0000000000..fbdf9e49c6 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcspbrk.c @@ -0,0 +1,88 @@ +/* +FUNCTION + <>----scan wide-character string for a wide-character code + +ANSI_SYNOPSIS + #include + wchar_t *wcspbrk(const wchar_t *<[s]>, const wchar_t *<[set]>); + +TRAD_SYNOPSIS + wchar_t *wcspbrk(<[s]>, <[set]> + const wchar_t *<[s]>; + const wchar_t *<[set]>; + +DESCRIPTION + The <> function locates the first occurrence in the + wide-character string pointed to by <[s]> of any wide-character code + from the wide-character string pointed to by <[set]>. + +RETURNS + Upon successful completion, <> returns a pointer to the + wide-character code or a null pointer if no wide-character code from + <[set]> occurs in <[s]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcspbrk.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcspbrk.c,v 1.2 2000/12/21 05:07:25 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wcspbrk, (s, set), + _CONST wchar_t * s _AND + _CONST wchar_t * set) +{ + _CONST wchar_t *p; + _CONST wchar_t *q; + + p = s; + while (*p) + { + q = set; + while (*q) + { + if (*p == *q) + { + /* LINTED interface specification */ + return (wchar_t *) p; + } + q++; + } + p++; + } + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsrchr.c b/contrib/sdk/sources/newlib/libc/string/wcsrchr.c new file mode 100644 index 0000000000..495d95a156 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsrchr.c @@ -0,0 +1,88 @@ +/* +FUNCTION + <>---wide-character string scanning operation + +ANSI_SYNOPSIS + #include + wchar_t *wcsrchr(const wchar_t *<[s]>, wchar_t <[c]>); + +TRAD_SYNOPSIS + #include + wchar_t *wcsrchr(<[s]>, <[c]> + const wchar_t *<[s]>; + wchar_t <[c]>; + +DESCRIPTION + The <> function locates the last occurrence of <[c]> in the + wide-character string pointed to by <[s]>. The value of <[c]> must be a + character representable as a type wchar_t and must be a wide-character + code corresponding to a valid character in the current locale. + The terminating null wide-character code is considered to be part of + the wide-character string. + +RETURNS + Upon successful completion, <> returns a pointer to the + wide-character code or a null pointer if <[c]> does not occur in the + wide-character string. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcsrchr.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcsrchr.c,v 1.2 2000/12/21 05:07:25 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wcsrchr, (s, c), + _CONST wchar_t * s _AND + wchar_t c) +{ + _CONST wchar_t *p; + + p = s; + while (*p) + p++; + while (s <= p) + { + if (*p == c) + { + /* LINTED interface specification */ + return (wchar_t *) p; + } + p--; + } + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsspn.c b/contrib/sdk/sources/newlib/libc/string/wcsspn.c new file mode 100644 index 0000000000..e83f42f4f5 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsspn.c @@ -0,0 +1,88 @@ +/* +FUNCTION + <>---get length of a wide substring + +ANSI_SYNOPSIS + #include + size_t wcsspn(const wchar_t *<[s]>, const wchar_t *<[set]>); + +TRAD_SYNOPSIS + size_t wcsspn(<[s]>, <[set]> + const wchar_t *<[s]>; + const wchar_t *<[set]>; + +DESCRIPTION + The <> function computes the length of the maximum initial + segment of the wide-character string pointed to by <[s]> which consists + entirely of wide-character codes from the wide-character string + pointed to by <[set]>. + +RETURNS + The wcsspn() function returns the length <[s1]>; no return value is + reserved to indicate an error. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wcsspn.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcsspn.c,v 1.1 1999/12/29 21:47:45 tshiozak Exp + */ + +#include <_ansi.h> +#include + +size_t +_DEFUN (wcsspn, (s, set), + _CONST wchar_t * s _AND + _CONST wchar_t * set) +{ + _CONST wchar_t *p; + _CONST wchar_t *q; + + p = s; + while (*p) + { + q = set; + while (*q) + { + if (*p == *q) + break; + q++; + } + if (!*q) + goto done; + p++; + } + +done: + return (p - s); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsstr.c b/contrib/sdk/sources/newlib/libc/string/wcsstr.c new file mode 100644 index 0000000000..6e891120d8 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsstr.c @@ -0,0 +1,106 @@ +/* +FUNCTION + <>---find a wide-character substring + +ANSI_SYNOPSIS + #include + wchar_t *wcsstr(const wchar_t *__restrict <[big]>, + const wchar_t *__restrict <[little]>); + +TRAD_SYNOPSIS + wchar_t *wcsstr(<[big]>, <[little]> + const wchar_t *__restrict <[big]>; + const wchar_t *__restrict <[little]>; + +DESCRIPTION + The <> function locates the first occurrence in the + wide-character string pointed to by <[big]> of the sequence of + wide characters (excluding the terminating null wide character) in the + wide-character string pointed to by <[little]>. + +RETURNS + On successful completion, <> returns a pointer to the located + wide-character string, or a null pointer if the wide-character string + is not found. + + If <[little]> points to a wide-character string with zero length, + the function returns <[big]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +*/ + +/* $NetBSD: wcsstr.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wcsstr.c,v 1.2 2000/12/21 05:07:25 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wcsstr, (big, little), + _CONST wchar_t *__restrict big _AND + _CONST wchar_t *__restrict little) +{ + _CONST wchar_t *p; + _CONST wchar_t *q; + _CONST wchar_t *r; + + if (!*little) + { + /* LINTED interface specification */ + return (wchar_t *) big; + } + if (wcslen (big) < wcslen (little)) + return NULL; + + p = big; + q = little; + while (*p) + { + q = little; + r = p; + while (*q) + { + if (*r != *q) + break; + q++; + r++; + } + if (!*q) + { + /* LINTED interface specification */ + return (wchar_t *) p; + } + p++; + } + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcstok.c b/contrib/sdk/sources/newlib/libc/string/wcstok.c new file mode 100644 index 0000000000..144b33efd1 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcstok.c @@ -0,0 +1,182 @@ +/* +FUNCTION + <>---get next token from a string + +INDEX + wcstok + + +ANSI_SYNOPSIS + #include + wchar_t *wcstok(wchar_t *__restrict <[source]>, + const wchar_t *__restrict <[delimiters]>, + wchar_t **__restrict <[lasts]>); + +TRAD_SYNOPSIS + #include + wchar_t *wcstok(<[source]>, <[delimiters]>, <[lasts]>); + wchar_t *__restrict <[source]>; + wchar_t *__restrict <[delimiters]>; + wchar_t **__restrict <[lasts]>; + +DESCRIPTION + The <> function is the wide-character equivalent of the + <> function (which in turn is the same as the <> + function with an added argument to make it thread-safe). + + The <> function is used to isolate (one at a time) + sequential tokens in a null-terminated wide-character string, + <<*<[source]>>>. A token is defined as a substring not containing + any wide-characters from <<*<[delimiters]>>>. + + The first time that <> is called, <<*<[source]>>> should + be specified with the wide-character string to be searched, and + <<*<[lasts]>>>--but not <>, which must be non-NULL--may be + random; subsequent calls, wishing to obtain further tokens from + the same string, should pass a null pointer for <<*<[source]>>> + instead but must supply <<*<[lasts]>>> unchanged from the last + call. The separator wide-character string, <<*<[delimiters]>>>, + must be supplied each time and may change between calls. + A pointer to placeholder <<*<[lasts]>>> must be supplied by + the caller, and is set each time as needed to save the state + by <>. Every call to <> with <<*<[source]>>> + == <> must pass the value of <<*<[lasts]>>> as last set + by <>. + + The <> function returns a pointer to the beginning of each + subsequent token in the string, after replacing the separator + wide-character itself with a null wide-character. When no more tokens + remain, a null pointer is returned. + +RETURNS + <> returns a pointer to the first wide character of a token, or + <> if there is no token. + +NOTES + <> is thread-safe (unlike <>, but like <>). + <> writes into the string being searched. + +PORTABILITY +<> is C99 and POSIX.1-2001. + +<> requires no supporting OS subroutines. + +QUICKREF + strtok ansi pure +*/ +/* wcstok for Newlib created by adapting strtok_r, 2008. */ +/* + * Copyright (c) 1988 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. + */ + +#include + +wchar_t * +_DEFUN (wcstok, (s, delim, lasts), + register wchar_t *__restrict s _AND + register const wchar_t *__restrict delim _AND + wchar_t **__restrict lasts) +{ + register const wchar_t *spanp; + register int c, sc; + wchar_t *tok; + + + if (s == NULL && (s = *lasts) == NULL) + return (NULL); + + /* + * Skip (span) leading delimiters (s += wcsspn(s, delim), sort of). + */ +cont: + c = *s++; + for (spanp = delim; (sc = *spanp++) != L'\0';) { + if (c == sc) goto cont; + } + + if (c == L'\0') { /* no non-delimiter characters */ + *lasts = NULL; + return (NULL); + } + tok = s - 1; + + /* + * Scan token (scan for delimiters: s += wcscspn(s, delim), sort of). + * Note that delim must have one NUL; we stop if we see that, too. + */ + for (;;) { + c = *s++; + spanp = delim; + do { + if ((sc = *spanp++) == c) { + if (c == L'\0') + s = NULL; + else + s[-1] = L'\0'; + *lasts = s; + return (tok); + } + } while (sc != L'\0'); + } + /* NOTREACHED */ +} + +/* The remainder of this file can serve as a regression test. Compile + * with -D_REGRESSION_TEST. */ +#if defined(_REGRESSION_TEST) /* [Test code: example from C99 standard */ +#include +#include + +/* example from C99 standard with minor additions to be a test */ +int +main(void) +{ +int errs=0; +static wchar_t str1[] = L"?a???b,,,#c"; +static wchar_t str2[] = L"\t \t"; +wchar_t *t, *ptr1, *ptr2; + +t = wcstok(str1, L"?", &ptr1); // t points to the token L"a" +if(wcscmp(t,L"a")) errs++; +t = wcstok(NULL, L",", &ptr1); // t points to the token L"??b" +if(wcscmp(t,L"??b")) errs++; +t = wcstok(str2, L" \t", &ptr2); // t is a null pointer +if(t != NULL) errs++; +t = wcstok(NULL, L"#,", &ptr1); // t points to the token L"c" +if(wcscmp(t,L"c")) errs++; +t = wcstok(NULL, L"?", &ptr1); // t is a null pointer +if(t != NULL) errs++; + +printf("wcstok() test "); +if(errs) printf("FAILED %d test cases", errs); + else printf("passed"); +printf(".\n"); + +return(errs); +} +#endif /* defined(_REGRESSION_TEST) ] */ diff --git a/contrib/sdk/sources/newlib/libc/string/wcswidth.c b/contrib/sdk/sources/newlib/libc/string/wcswidth.c new file mode 100644 index 0000000000..6c0efe63f1 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcswidth.c @@ -0,0 +1,73 @@ +/* +FUNCTION + <>---number of column positions of a wide-character string + +INDEX + wcswidth + +ANSI_SYNOPSIS + #include + int wcswidth(const wchar_t *<[pwcs]>, size_t <[n]>); + +TRAD_SYNOPSIS + #include + int wcswidth(<[pwcs]>, <[n]>) + wchar_t *<[wc]>; + size_t <[n]>; + +DESCRIPTION + The <> function shall determine the number of column + positions required for <[n]> wide-character codes (or fewer than <[n]> + wide-character codes if a null wide-character code is encountered + before <[n]> wide-character codes are exhausted) in the string pointed + to by <[pwcs]>. + +RETURNS + The <> function either shall return 0 (if <[pwcs]> points to a + null wide-character code), or return the number of column positions + to be occupied by the wide-character string pointed to by <[pwcs]>, or + return -1 (if any of the first <[n]> wide-character codes in the + wide-character string pointed to by <[pwcs]> is not a printable + wide-character code). + +PORTABILITY +<> has been introduced in the Single UNIX Specification Volume 2. +<> has been marked as an extension in the Single UNIX Specification Volume 3. +*/ + +#include <_ansi.h> +#include +#include "local.h" + +int +_DEFUN (wcswidth, (pwcs, n), + _CONST wchar_t *pwcs _AND + size_t n) + +{ + int w, len = 0; + if (!pwcs || n == 0) + return 0; + do { + wint_t wi = *pwcs; + +#ifdef _MB_CAPABLE + wi = _jp2uc (wi); + /* First half of a surrogate pair? */ + if (sizeof (wchar_t) == 2 && wi >= 0xd800 && wi <= 0xdbff) + { + wint_t wi2; + + /* Extract second half and check for validity. */ + if (--n == 0 || (wi2 = _jp2uc (*++pwcs)) < 0xdc00 || wi2 > 0xdfff) + return -1; + /* Compute actual unicode value to use in call to __wcwidth. */ + wi = (((wi & 0x3ff) << 10) | (wi2 & 0x3ff)) + 0x10000; + } +#endif /* _MB_CAPABLE */ + if ((w = __wcwidth (wi)) < 0) + return -1; + len += w; + } while (*pwcs++ && --n > 0); + return len; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcsxfrm.c b/contrib/sdk/sources/newlib/libc/string/wcsxfrm.c new file mode 100644 index 0000000000..d5a31728d3 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcsxfrm.c @@ -0,0 +1,53 @@ +/* +FUNCTION + <>---locale-specific wide-character string transformation + +INDEX + wcsxfrm + +ANSI_SYNOPSIS + #include + int wcsxfrm(wchar_t *__restrict <[stra]>, + const wchar_t *__restrict <[strb]>, size_t <[n]>); + +TRAD_SYNOPSIS + #include + size_t wcsxfrm(<[stra]>, <[strb]>, <[n]>) + wchar_t *__restrict <[stra]>; + wchar_t *__restrict <[strb]>; + size_t <[n]> + +DESCRIPTION + <> transforms the wide-character string pointed to by + <[strb]> to the wide-character string pointed to by <[stra]>, + Comparing two transformed wide strings with <> should return + the same result as comparing the original strings with <>. + No more than <[n]> wide characters are transformed, including the + trailing null character. + + If <[n]> is 0, <[stra]> may be a NULL pointer. + + The current implementation of <> simply uses <> + and does not support any language-specific transformations. + +RETURNS + <> returns the length of the transformed wide character + string. if the return value is greater or equal to <[n]>, the + content of <[stra]> is undefined. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). +*/ + +#include <_ansi.h> +#include + +size_t +_DEFUN (wcsxfrm, (a, b, n), + wchar_t *__restrict a _AND + _CONST wchar_t *__restrict b _AND + size_t n) + +{ + return wcslcpy (a, b, n); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wcwidth.c b/contrib/sdk/sources/newlib/libc/string/wcwidth.c new file mode 100644 index 0000000000..ac5c47f67f --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wcwidth.c @@ -0,0 +1,346 @@ +/* +FUNCTION + <>---number of column positions of a wide-character code + +INDEX + wcwidth + +ANSI_SYNOPSIS + #include + int wcwidth(const wchar_t <[wc]>); + +TRAD_SYNOPSIS + #include + int wcwidth(<[wc]>) + wchar_t *<[wc]>; + +DESCRIPTION + The <> function shall determine the number of column + positions required for the wide character <[wc]>. The application + shall ensure that the value of <[wc]> is a character representable + as a wchar_t, and is a wide-character code corresponding to a + valid character in the current locale. + +RETURNS + The <> function shall either return 0 (if <[wc]> is a null + wide-character code), or return the number of column positions to + be occupied by the wide-character code <[wc]>, or return -1 (if <[wc]> + does not correspond to a printable wide-character code). + +PORTABILITY +<> has been introduced in the Single UNIX Specification Volume 2. +<> has been marked as an extension in the Single UNIX Specification Volume 3. +*/ + +/* + * This is an implementation of wcwidth() (defined in + * IEEE Std 1002.1-2001) for Unicode. + * + * http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html + * + * In fixed-width output devices, Latin characters all occupy a single + * "cell" position of equal width, whereas ideographic CJK characters + * occupy two such cells. Interoperability between terminal-line + * applications and (teletype-style) character terminals using the + * UTF-8 encoding requires agreement on which character should advance + * the cursor by how many cell positions. No established formal + * standards exist at present on which Unicode character shall occupy + * how many cell positions on character terminals. These routines are + * a first attempt of defining such behavior based on simple rules + * applied to data provided by the Unicode Consortium. + * + * For some graphical characters, the Unicode standard explicitly + * defines a character-cell width via the definition of the East Asian + * FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes. + * In all these cases, there is no ambiguity about which width a + * terminal shall use. For characters in the East Asian Ambiguous (A) + * class, the width choice depends purely on a preference of backward + * compatibility with either historic CJK or Western practice. + * Choosing single-width for these characters is easy to justify as + * the appropriate long-term solution, as the CJK practice of + * displaying these characters as double-width comes from historic + * implementation simplicity (8-bit encoded characters were displayed + * single-width and 16-bit ones double-width, even for Greek, + * Cyrillic, etc.) and not any typographic considerations. + * + * Much less clear is the choice of width for the Not East Asian + * (Neutral) class. Existing practice does not dictate a width for any + * of these characters. It would nevertheless make sense + * typographically to allocate two character cells to characters such + * as for instance EM SPACE or VOLUME INTEGRAL, which cannot be + * represented adequately with a single-width glyph. The following + * routines at present merely assign a single-cell width to all + * neutral characters, in the interest of simplicity. This is not + * entirely satisfactory and should be reconsidered before + * establishing a formal standard in this area. At the moment, the + * decision which Not East Asian (Neutral) characters should be + * represented by double-width glyphs cannot yet be answered by + * applying a simple rule from the Unicode database content. Setting + * up a proper standard for the behavior of UTF-8 character terminals + * will require a careful analysis not only of each Unicode character, + * but also of each presentation form, something the author of these + * routines has avoided to do so far. + * + * http://www.unicode.org/unicode/reports/tr11/ + * + * Markus Kuhn -- 2007-05-26 (Unicode 5.0) + * + * Permission to use, copy, modify, and distribute this software + * for any purpose and without fee is hereby granted. The author + * disclaims all warranties with regard to this software. + * + * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c + */ + +#include <_ansi.h> +#include +#ifndef _MB_CAPABLE +#include /* iswprint, iswcntrl */ +#endif +#include "local.h" + +#ifdef _MB_CAPABLE +struct interval +{ + int first; + int last; +}; + +/* auxiliary function for binary search in interval table */ +static int +bisearch(wint_t ucs, const struct interval *table, int max) +{ + int min = 0; + int mid; + + if (ucs < table[0].first || ucs > table[max].last) + return 0; + while (max >= min) + { + mid = (min + max) / 2; + if (ucs > table[mid].last) + min = mid + 1; + else if (ucs < table[mid].first) + max = mid - 1; + else + return 1; + } + + return 0; +} +#endif /* _MB_CAPABLE */ + +/* The following function defines the column width of an ISO 10646 + * character as follows: + * + * - The null character (U+0000) has a column width of 0. + * + * - Other C0/C1 control characters and DEL will lead to a return + * value of -1. + * + * - If the current language is recognized as a language usually using + * CJK fonts, spacing characters in the East Asian Ambiguous (A) + * category as defined in Unicode Technical Report #11 have a column + * width of 2. + * + * - Non-spacing and enclosing combining characters (general + * category code Mn or Me in the Unicode database) have a + * column width of 0. + * + * - SOFT HYPHEN (U+00AD) has a column width of 1. + * + * - Other format characters (general category code Cf in the Unicode + * database) and ZERO WIDTH SPACE (U+200B) have a column width of 0. + * + * - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF) + * have a column width of 0. + * + * - Spacing characters in the East Asian Wide (W) or East Asian + * Full-width (F) category as defined in Unicode Technical + * Report #11 have a column width of 2. + * + * - All remaining characters (including all printable + * ISO 8859-1 and WGL4 characters, Unicode control characters, + * etc.) have a column width of 1. + * + * This implementation assumes that wint_t characters are encoded + * in ISO 10646. + */ + +int +_DEFUN (__wcwidth, (ucs), + _CONST wint_t ucs) +{ +#ifdef _MB_CAPABLE + /* sorted list of non-overlapping intervals of East Asian Ambiguous + * characters, generated by "uniset +WIDTH-A -cat=Me -cat=Mn -cat=Cf c" */ + static const struct interval ambiguous[] = { + { 0x00A1, 0x00A1 }, { 0x00A4, 0x00A4 }, { 0x00A7, 0x00A8 }, + { 0x00AA, 0x00AA }, { 0x00AE, 0x00AE }, { 0x00B0, 0x00B4 }, + { 0x00B6, 0x00BA }, { 0x00BC, 0x00BF }, { 0x00C6, 0x00C6 }, + { 0x00D0, 0x00D0 }, { 0x00D7, 0x00D8 }, { 0x00DE, 0x00E1 }, + { 0x00E6, 0x00E6 }, { 0x00E8, 0x00EA }, { 0x00EC, 0x00ED }, + { 0x00F0, 0x00F0 }, { 0x00F2, 0x00F3 }, { 0x00F7, 0x00FA }, + { 0x00FC, 0x00FC }, { 0x00FE, 0x00FE }, { 0x0101, 0x0101 }, + { 0x0111, 0x0111 }, { 0x0113, 0x0113 }, { 0x011B, 0x011B }, + { 0x0126, 0x0127 }, { 0x012B, 0x012B }, { 0x0131, 0x0133 }, + { 0x0138, 0x0138 }, { 0x013F, 0x0142 }, { 0x0144, 0x0144 }, + { 0x0148, 0x014B }, { 0x014D, 0x014D }, { 0x0152, 0x0153 }, + { 0x0166, 0x0167 }, { 0x016B, 0x016B }, { 0x01CE, 0x01CE }, + { 0x01D0, 0x01D0 }, { 0x01D2, 0x01D2 }, { 0x01D4, 0x01D4 }, + { 0x01D6, 0x01D6 }, { 0x01D8, 0x01D8 }, { 0x01DA, 0x01DA }, + { 0x01DC, 0x01DC }, { 0x0251, 0x0251 }, { 0x0261, 0x0261 }, + { 0x02C4, 0x02C4 }, { 0x02C7, 0x02C7 }, { 0x02C9, 0x02CB }, + { 0x02CD, 0x02CD }, { 0x02D0, 0x02D0 }, { 0x02D8, 0x02DB }, + { 0x02DD, 0x02DD }, { 0x02DF, 0x02DF }, { 0x0391, 0x03A1 }, + { 0x03A3, 0x03A9 }, { 0x03B1, 0x03C1 }, { 0x03C3, 0x03C9 }, + { 0x0401, 0x0401 }, { 0x0410, 0x044F }, { 0x0451, 0x0451 }, + { 0x2010, 0x2010 }, { 0x2013, 0x2016 }, { 0x2018, 0x2019 }, + { 0x201C, 0x201D }, { 0x2020, 0x2022 }, { 0x2024, 0x2027 }, + { 0x2030, 0x2030 }, { 0x2032, 0x2033 }, { 0x2035, 0x2035 }, + { 0x203B, 0x203B }, { 0x203E, 0x203E }, { 0x2074, 0x2074 }, + { 0x207F, 0x207F }, { 0x2081, 0x2084 }, { 0x20AC, 0x20AC }, + { 0x2103, 0x2103 }, { 0x2105, 0x2105 }, { 0x2109, 0x2109 }, + { 0x2113, 0x2113 }, { 0x2116, 0x2116 }, { 0x2121, 0x2122 }, + { 0x2126, 0x2126 }, { 0x212B, 0x212B }, { 0x2153, 0x2154 }, + { 0x215B, 0x215E }, { 0x2160, 0x216B }, { 0x2170, 0x2179 }, + { 0x2190, 0x2199 }, { 0x21B8, 0x21B9 }, { 0x21D2, 0x21D2 }, + { 0x21D4, 0x21D4 }, { 0x21E7, 0x21E7 }, { 0x2200, 0x2200 }, + { 0x2202, 0x2203 }, { 0x2207, 0x2208 }, { 0x220B, 0x220B }, + { 0x220F, 0x220F }, { 0x2211, 0x2211 }, { 0x2215, 0x2215 }, + { 0x221A, 0x221A }, { 0x221D, 0x2220 }, { 0x2223, 0x2223 }, + { 0x2225, 0x2225 }, { 0x2227, 0x222C }, { 0x222E, 0x222E }, + { 0x2234, 0x2237 }, { 0x223C, 0x223D }, { 0x2248, 0x2248 }, + { 0x224C, 0x224C }, { 0x2252, 0x2252 }, { 0x2260, 0x2261 }, + { 0x2264, 0x2267 }, { 0x226A, 0x226B }, { 0x226E, 0x226F }, + { 0x2282, 0x2283 }, { 0x2286, 0x2287 }, { 0x2295, 0x2295 }, + { 0x2299, 0x2299 }, { 0x22A5, 0x22A5 }, { 0x22BF, 0x22BF }, + { 0x2312, 0x2312 }, { 0x2460, 0x24E9 }, { 0x24EB, 0x254B }, + { 0x2550, 0x2573 }, { 0x2580, 0x258F }, { 0x2592, 0x2595 }, + { 0x25A0, 0x25A1 }, { 0x25A3, 0x25A9 }, { 0x25B2, 0x25B3 }, + { 0x25B6, 0x25B7 }, { 0x25BC, 0x25BD }, { 0x25C0, 0x25C1 }, + { 0x25C6, 0x25C8 }, { 0x25CB, 0x25CB }, { 0x25CE, 0x25D1 }, + { 0x25E2, 0x25E5 }, { 0x25EF, 0x25EF }, { 0x2605, 0x2606 }, + { 0x2609, 0x2609 }, { 0x260E, 0x260F }, { 0x2614, 0x2615 }, + { 0x261C, 0x261C }, { 0x261E, 0x261E }, { 0x2640, 0x2640 }, + { 0x2642, 0x2642 }, { 0x2660, 0x2661 }, { 0x2663, 0x2665 }, + { 0x2667, 0x266A }, { 0x266C, 0x266D }, { 0x266F, 0x266F }, + { 0x273D, 0x273D }, { 0x2776, 0x277F }, { 0xE000, 0xF8FF }, + { 0xFFFD, 0xFFFD }, { 0xF0000, 0xFFFFD }, { 0x100000, 0x10FFFD } + }; + /* sorted list of non-overlapping intervals of non-spacing characters */ + /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */ + static const struct interval combining[] = { + { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 }, + { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, + { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 }, + { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 }, + { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, + { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A }, + { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 }, + { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D }, + { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, + { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, + { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C }, + { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, + { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, + { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, + { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C }, + { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D }, + { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 }, + { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 }, + { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC }, + { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, + { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D }, + { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 }, + { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E }, + { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, + { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, + { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, + { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 }, + { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, + { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 }, + { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F }, + { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, + { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, + { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, + { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, + { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B }, + { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 }, + { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 }, + { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF }, + { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 }, + { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F }, + { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B }, + { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, + { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, + { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F }, + { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 }, + { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD }, + { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F }, + { 0xE0100, 0xE01EF } + }; + + /* Test for NUL character */ + if (ucs == 0) + return 0; + + /* Test for printable ASCII characters */ + if (ucs >= 0x20 && ucs < 0x7f) + return 1; + + /* Test for control characters */ + if (ucs < 0xa0) + return -1; + + /* Test for surrogate pair values. */ + if (ucs >= 0xd800 && ucs <= 0xdfff) + return -1; + + /* binary search in table of ambiguous characters */ + if (__locale_cjk_lang () + && bisearch(ucs, ambiguous, + sizeof(ambiguous) / sizeof(struct interval) - 1)) + return 2; + + /* binary search in table of non-spacing characters */ + if (bisearch(ucs, combining, + sizeof(combining) / sizeof(struct interval) - 1)) + return 0; + + /* if we arrive here, ucs is not a combining or C0/C1 control character */ + + return 1 + + (ucs >= 0x1100 && + (ucs <= 0x115f || /* Hangul Jamo init. consonants */ + ucs == 0x2329 || ucs == 0x232a || + (ucs >= 0x2e80 && ucs <= 0xa4cf && + ucs != 0x303f) || /* CJK ... Yi */ + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ + (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ + (ucs >= 0xffe0 && ucs <= 0xffe6) || + (ucs >= 0x20000 && ucs <= 0x2fffd) || + (ucs >= 0x30000 && ucs <= 0x3fffd))); +#else /* !_MB_CAPABLE */ + if (iswprint (ucs)) + return 1; + if (iswcntrl (ucs) || ucs == L'\0') + return 0; + return -1; +#endif /* _MB_CAPABLE */ +} + +int +_DEFUN (wcwidth, (wc), + _CONST wchar_t wc) +{ + wint_t wi = wc; + +#ifdef _MB_CAPABLE + wi = _jp2uc (wi); +#endif /* _MB_CAPABLE */ + return __wcwidth (wi); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wmemchr.c b/contrib/sdk/sources/newlib/libc/string/wmemchr.c new file mode 100644 index 0000000000..b582b89485 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wmemchr.c @@ -0,0 +1,89 @@ +/* +FUNCTION + <>---find a wide character in memory + + +ANSI_SYNOPSIS + #include + wchar_t *wmemchr(const wchar_t *<[s]>, wchar_t <[c]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wmemchr(<[s]>, <[c]>, <[n]> + const wchar_t *<[s]>; + wchar_t <[c]>; + size_t <[n]>; + +DESCRIPTION + The <> function locates the first occurrence of <[c]> in the + initial <[n]> wide characters of the object pointed to be <[s]>. This + function is not affected by locale and all wchar_t values are treated + identically. The null wide character and wchar_t values not + corresponding to valid characters are not treated specially. + + If <[n]> is zero, <[s]> must be a valid pointer and the function + behaves as if no valid occurrence of <[c]> is found. + +RETURNS + The <> function returns a pointer to the located + wide character, or a null pointer if the wide character does not occur + in the object. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wmemchr.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wmemchr.c,v 1.2 2000/12/20 14:08:31 itojun Exp + */ + + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN (wmemchr, (s, c, n), + _CONST wchar_t * s _AND + wchar_t c _AND + size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + { + if (*s == c) + { + /* LINTED const castaway */ + return (wchar_t *) s; + } + s++; + } + return NULL; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wmemcmp.c b/contrib/sdk/sources/newlib/libc/string/wmemcmp.c new file mode 100644 index 0000000000..af9ee32074 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wmemcmp.c @@ -0,0 +1,89 @@ +/* +FUNCTION + <>---compare wide characters in memory + +ANSI_SYNOPSIS + #include + int wmemcmp(const wchar_t *<[s1]>, const wchar_t *<[s2]>, size_t <[n]>); + +TRAD_SYNOPSIS + int wmemcmp(<[s1]>, <[s2]>, <[n]> + const wchar_t *<[s1]>; + const wchar_t *<[s2]>; + size_t <[n]>; + +DESCRIPTION + The <> function compares the first <[n]> wide characters of the + object pointed to by <[s1]> to the first <[n]> wide characters of the + object pointed to by <[s2]>. This function is not affected by locale + and all wchar_t values are treated identically. The null wide character + and wchar_t values not corresponding to valid characters are not treated + specially. + + If <[n]> is zero, <[s1]> and <[s2]> must be a valid pointers and the + function behaves as if the two objects compare equal. + +RETURNS + The <> function returns an integer greater than, equal to, + or less than zero, accordingly as the object pointed to by <[s1]> is + greater than, equal to, or less than the object pointed to by <[s2]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wmemcmp.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wmemcmp.c,v 1.2 2000/12/20 14:08:31 itojun Exp + */ + +#include <_ansi.h> +#include + +int +_DEFUN (wmemcmp, (s1, s2, n), + _CONST wchar_t * s1 _AND + _CONST wchar_t * s2 _AND + size_t n) +{ + size_t i; + + for (i = 0; i < n; i++) + { + if (*s1 != *s2) + { + /* wchar might be unsigned */ + return *s1 > *s2 ? 1 : -1; + } + s1++; + s2++; + } + return 0; +} diff --git a/contrib/sdk/sources/newlib/libc/string/wmemcpy.c b/contrib/sdk/sources/newlib/libc/string/wmemcpy.c new file mode 100644 index 0000000000..a57d6a5125 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wmemcpy.c @@ -0,0 +1,77 @@ +/* +FUNCTION + <>---copy wide characters in memory + +ANSI_SYNOPSIS + #include + wchar_t *wmemcpy(wchar_t *__restrict <[d]>, + const wchar_t *__restrict <[s]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wmemcpy(<[d]>, <[s]>, <[n]> + wchar_t *__restrict <[d]>; + const wchar_t *__restrict <[s]>; + size_t <[n]>; + +DESCRIPTION + The <> function copies <[n]> wide characters from the object + pointed to by <[s]> to the object pointed to be <[d]>. This function + is not affected by locale and all wchar_t values are treated + identically. The null wide character and wchar_t values not + corresponding to valid characters are not treated specially. + + If <[n]> is zero, <[d]> and <[s]> must be a valid pointers, and the + function copies zero wide characters. + +RETURNS + The <> function returns the value of <[d]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wmemcpy.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wmemcpy.c,v 1.2 2000/12/20 14:08:31 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wmemcpy, (d, s, n), + wchar_t *__restrict d _AND + _CONST wchar_t *__restrict s _AND + size_t n) +{ + + return (wchar_t *) memcpy (d, s, n * sizeof (wchar_t)); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wmemmove.c b/contrib/sdk/sources/newlib/libc/string/wmemmove.c new file mode 100644 index 0000000000..e20a26ae9b --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wmemmove.c @@ -0,0 +1,82 @@ +/* +FUNCTION + <>---copy wide characters in memory with overlapping areas + +ANSI_SYNOPSIS + #include + wchar_t *wmemmove(wchar_t *<[d]>, const wchar_t *<[s]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wmemmove(<[d]>, <[s]>, <[n]> + wchar_t *<[d]>; + const wchar_t *<[s]>; + size_t <[n]>; + +DESCRIPTION + The <> function copies <[n]> wide characters from the object + pointed to by <[s]> to the object pointed to by <[d]>. Copying takes + place as if the <[n]> wide characters from the object pointed to by + <[s]> are first copied into a temporary array of <[n]> wide characters + that does not overlap the objects pointed to by <[d]> or <[s]>, and then + the <[n]> wide characters from the temporary array are copied into the + object pointed to by <[d]>. + + This function is not affected by locale and all wchar_t values are + treated identically. The null wide character and wchar_t values not + corresponding to valid characters are not treated specially. + + If <[n]> is zero, <[d]> and <[s]> must be a valid pointers, and the + function copies zero wide characters. + +RETURNS + The <> function returns the value of <[d]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wmemmove.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wmemmove.c,v 1.2 2000/12/20 14:08:31 itojun Exp + */ + +#include <_ansi.h> +#include +#include + +wchar_t * +_DEFUN (wmemmove, (d, s, n), + wchar_t * d _AND + _CONST wchar_t * s _AND + size_t n) +{ + + return (wchar_t *) memmove (d, s, n * sizeof (wchar_t)); +} diff --git a/contrib/sdk/sources/newlib/libc/string/wmemset.c b/contrib/sdk/sources/newlib/libc/string/wmemset.c new file mode 100644 index 0000000000..0af6f91d50 --- /dev/null +++ b/contrib/sdk/sources/newlib/libc/string/wmemset.c @@ -0,0 +1,82 @@ +/* +FUNCTION + <>---set wide characters in memory + +ANSI_SYNOPSIS + #include + wchar_t *wmemset(wchar_t *<[s]>, wchar_t <[c]>, size_t <[n]>); + +TRAD_SYNOPSIS + wchar_t *wmemset(<[s]>, <[c]>, <[n]> + wchar_t *<[s]>; + wchar_t <[c]>; + size_t <[n]>; + +DESCRIPTION + The <> function copies the value of <[c]> into each of the + first <[n]> wide characters of the object pointed to by <[s]>. This + function is not affected by locale and all wchar_t values are treated + identically. The null wide character and wchar_t values not + corresponding to valid characters are not treated specially. + + If <[n]> is zero, <[s]> must be a valid pointer and the function + copies zero wide characters. + +RETURNS + The <> function returns the value of <[s]>. + +PORTABILITY +<> is ISO/IEC 9899/AMD1:1995 (ISO C). + +No supporting OS subroutines are required. +*/ + +/* $NetBSD: wmemset.c,v 1.1 2000/12/23 23:14:37 itojun Exp $ */ + +/*- + * Copyright (c)1999 Citrus Project, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + * + * citrus Id: wmemset.c,v 1.2 2000/12/20 14:08:31 itojun Exp + */ + +#include <_ansi.h> +#include + +wchar_t * +_DEFUN(wmemset, (s, c, n), + wchar_t *s _AND + wchar_t c _AND + size_t n) +{ + size_t i; + wchar_t *p; + + p = (wchar_t *)s; + for (i = 0; i < n; i++) { + *p = c; + p++; + } + return s; +}