summaryrefslogtreecommitdiff
path: root/libc/string/wstring.c
diff options
context:
space:
mode:
authorPeter S. Mazinger <ps.m@gmx.net>2006-01-03 14:50:18 +0000
committerPeter S. Mazinger <ps.m@gmx.net>2006-01-03 14:50:18 +0000
commit167d5e33fcb821e51e2f9dcf460591737c3c7972 (patch)
tree79acefdd8c9781098adbf77278415eda6365fd3d /libc/string/wstring.c
parentfe68563b9a070fedf117c8738652587945427bb3 (diff)
Complete split of all the string functions. Hope haven't broken too much. wcscoll/strcoll needs some love ...
Diffstat (limited to 'libc/string/wstring.c')
-rw-r--r--libc/string/wstring.c3247
1 files changed, 0 insertions, 3247 deletions
diff --git a/libc/string/wstring.c b/libc/string/wstring.c
deleted file mode 100644
index 89c533951..000000000
--- a/libc/string/wstring.c
+++ /dev/null
@@ -1,3247 +0,0 @@
-/*
- * Copyright (C) 2002 Manuel Novoa III
- * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org>
- *
- * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
- */
-
-/* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION!
- *
- * Besides uClibc, I'm using this code in my libc for elks, which is
- * a 16-bit environment with a fairly limited compiler. It would make
- * things much easier for me if this file isn't modified unnecessarily.
- * In particular, please put any new or replacement functions somewhere
- * else, and modify the makefile to use your version instead.
- * Thanks. Manuel
- *
- * ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */
-
-/* Dec 20, 2002
- * Initial test implementation of strcoll, strxfrm, wcscoll, and wcsxfrm.
- * The code needs to be cleaned up a good bit, but I'd like to see people
- * test it out.
- *
- * Sep 11, 2003
- * Patch by Atsushi Nemoto <anemo@mba.ocn.ne.jp> to do arch-required
- * mapping of signal strings (alpha, mips, hppa, sparc).
- */
-
-#define _GNU_SOURCE
-#include <features.h>
-#include <string.h>
-#include <strings.h>
-#include <stdio.h>
-#include <limits.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <signal.h>
-#include <assert.h>
-#include <locale.h>
-#include <bits/uClibc_uintmaxtostr.h>
-
-#ifdef WANT_WIDE
-#include <wchar.h>
-#include <wctype.h>
-#include <bits/uClibc_uwchar.h>
-
-#define Wvoid wchar_t
-#define Wchar wchar_t
-#define Wuchar __uwchar_t
-#define Wint wchar_t
-
-#else
-
-#define Wvoid void
-#define Wchar char
-typedef unsigned char __string_uchar_t;
-#define Wuchar __string_uchar_t
-#define Wint int
-
-#endif
-
-
-extern size_t __strnlen (__const char *__string, size_t __maxlen) attribute_hidden;
-extern char *__strpbrk (__const char *__s, __const char *__accept) attribute_hidden;
-extern size_t __strspn (__const char *__s, __const char *__accept) attribute_hidden;
-extern char *__strsignal (int __sig) attribute_hidden;
-extern char *__strtok_r (char *__restrict __s,
- __const char *__restrict __delim,
- char **__restrict __save_ptr) attribute_hidden;
-extern size_t __strlcpy(char *__restrict dst, const char *__restrict src,
- size_t n) attribute_hidden;
-
-#ifdef WANT_WIDE
-extern wchar_t *__wcsdup (__const wchar_t *__s) attribute_hidden;
-extern size_t __wcslen (__const wchar_t *__s) attribute_hidden;
-extern wchar_t *__wcscpy (wchar_t *__restrict __dest,
- __const wchar_t *__restrict __src) attribute_hidden;
-extern size_t __wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept) attribute_hidden;
-extern wchar_t *__wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept) attribute_hidden;
-extern int __wcscmp (__const wchar_t *__s1, __const wchar_t *__s2) attribute_hidden;
-extern size_t __wcsxfrm (wchar_t *__restrict __s1,
- __const wchar_t *__restrict __s2, size_t __n) attribute_hidden;
-extern wint_t __towlower (wint_t __wc) __THROW attribute_hidden;
-#endif
-#ifdef __UCLIBC_HAS_XLOCALE__
-extern int __strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l) attribute_hidden;
-extern size_t __strxfrm_l (char *__dest, __const char *__src, size_t __n, __locale_t __l) attribute_hidden;
-extern int __strcasecmp_l (__const char *__s1, __const char *__s2, __locale_t __loc) attribute_hidden;
-extern int __strncasecmp_l (__const char *__s1, __const char *__s2, size_t __n, __locale_t __loc) attribute_hidden;
-extern int __wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, __locale_t __loc) attribute_hidden;
-extern int __wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n, __locale_t __loc) attribute_hidden;
-extern int __wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2, __locale_t __loc) attribute_hidden;
-extern size_t __wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2, size_t __n, __locale_t __loc) attribute_hidden;
-#ifdef __UCLIBC_DO_XLOCALE
-extern wint_t __towlower_l(wint_t __wc, __locale_t __locale) __THROW;
-#endif
-#endif
-
-/**********************************************************************/
-/* NOTE: If we ever do internationalized syserr messages, this will
- * have to be changed! */
-
-#define _SYS_NERR 125
-#if defined(__mips__) || defined(__sparc__)
-/* sparce and mips have an extra error entry, as EDEADLK and EDEADLOCK have
- * different meanings on those platforms. */
-#undef _SYS_NERR
-#define _SYS_NERR 126
-#endif
-
-#ifdef __UCLIBC_HAS_ERRNO_MESSAGES__
-#define _SYS_ERRMSG_MAXLEN 50
-#else /* __UCLIBC_HAS_ERRNO_MESSAGES__ */
-#define _SYS_ERRMSG_MAXLEN 0
-#endif /* __UCLIBC_HAS_ERRNO_MESSAGES__ */
-
-
-extern const char _string_syserrmsgs[];
-
-#define _SYS_NSIG 32
-
-#ifdef __UCLIBC_HAS_SIGNUM_MESSAGES__
-#define _SYS_SIGMSG_MAXLEN 25
-#else /* __UCLIBC_HAS_SIGNUM_MESSAGES__ */
-#define _SYS_SIGMSG_MAXLEN 0
-#endif /* __UCLIBC_HAS_SIGNUM_MESSAGES__ */
-
-extern const char _string_syssigmsgs[];
-
-
-#if _SYS_ERRMSG_MAXLEN < __UIM_BUFLEN_INT + 14
-#define _STRERROR_BUFSIZE (__UIM_BUFLEN_INT + 14)
-#else
-#define _STRERROR_BUFSIZE _SYS_ERRMSG_MAXLEN
-#endif
-
-#if _SYS_SIGMSG_MAXLEN < __UIM_BUFLEN_INT + 15
-#define _STRSIGNAL_BUFSIZE (__UIM_BUFLEN_INT + 15)
-#else
-#define _STRSIGNAL_BUFSIZE _SYS_SIGMSG_MAXLEN
-#endif
-
-/**********************************************************************/
-#if defined(L__string_syserrmsgs) && defined(__UCLIBC_HAS_ERRNO_MESSAGES__)
-
-const char _string_syserrmsgs[] = {
- /* 0: 0, 8 */ "Success\0"
- /* 1: 8, 24 */ "Operation not permitted\0"
- /* 2: 32, 26 */ "No such file or directory\0"
- /* 3: 58, 16 */ "No such process\0"
- /* 4: 74, 24 */ "Interrupted system call\0"
- /* 5: 98, 19 */ "Input/output error\0"
- /* 6: 117, 26 */ "No such device or address\0"
- /* 7: 143, 23 */ "Argument list too long\0"
- /* 8: 166, 18 */ "Exec format error\0"
- /* 9: 184, 20 */ "Bad file descriptor\0"
- /* 10: 204, 19 */ "No child processes\0"
- /* 11: 223, 33 */ "Resource temporarily unavailable\0"
- /* 12: 256, 23 */ "Cannot allocate memory\0"
- /* 13: 279, 18 */ "Permission denied\0"
- /* 14: 297, 12 */ "Bad address\0"
- /* 15: 309, 22 */ "Block device required\0"
- /* 16: 331, 24 */ "Device or resource busy\0"
- /* 17: 355, 12 */ "File exists\0"
- /* 18: 367, 26 */ "Invalid cross-device link\0"
- /* 19: 393, 15 */ "No such device\0"
- /* 20: 408, 16 */ "Not a directory\0"
- /* 21: 424, 15 */ "Is a directory\0"
- /* 22: 439, 17 */ "Invalid argument\0"
- /* 23: 456, 30 */ "Too many open files in system\0"
- /* 24: 486, 20 */ "Too many open files\0"
- /* 25: 506, 31 */ "Inappropriate ioctl for device\0"
- /* 26: 537, 15 */ "Text file busy\0"
- /* 27: 552, 15 */ "File too large\0"
- /* 28: 567, 24 */ "No space left on device\0"
- /* 29: 591, 13 */ "Illegal seek\0"
- /* 30: 604, 22 */ "Read-only file system\0"
- /* 31: 626, 15 */ "Too many links\0"
- /* 32: 641, 12 */ "Broken pipe\0"
- /* 33: 653, 33 */ "Numerical argument out of domain\0"
- /* 34: 686, 30 */ "Numerical result out of range\0"
- /* 35: 716, 26 */ "Resource deadlock avoided\0"
- /* 36: 742, 19 */ "File name too long\0"
- /* 37: 761, 19 */ "No locks available\0"
- /* 38: 780, 25 */ "Function not implemented\0"
- /* 39: 805, 20 */ "Directory not empty\0"
- /* 40: 825, 34 */ "Too many levels of symbolic links\0"
- /* 41: 859, 1 */ "\0"
- /* 42: 860, 27 */ "No message of desired type\0"
- /* 43: 887, 19 */ "Identifier removed\0"
- /* 44: 906, 28 */ "Channel number out of range\0"
- /* 45: 934, 25 */ "Level 2 not synchronized\0"
- /* 46: 959, 15 */ "Level 3 halted\0"
- /* 47: 974, 14 */ "Level 3 reset\0"
- /* 48: 988, 25 */ "Link number out of range\0"
- /* 49: 1013, 29 */ "Protocol driver not attached\0"
- /* 50: 1042, 27 */ "No CSI structure available\0"
- /* 51: 1069, 15 */ "Level 2 halted\0"
- /* 52: 1084, 17 */ "Invalid exchange\0"
- /* 53: 1101, 27 */ "Invalid request descriptor\0"
- /* 54: 1128, 14 */ "Exchange full\0"
- /* 55: 1142, 9 */ "No anode\0"
- /* 56: 1151, 21 */ "Invalid request code\0"
- /* 57: 1172, 13 */ "Invalid slot\0"
- /* 58: 1185, 1 */ "\0"
- /* 59: 1186, 21 */ "Bad font file format\0"
- /* 60: 1207, 20 */ "Device not a stream\0"
- /* 61: 1227, 18 */ "No data available\0"
- /* 62: 1245, 14 */ "Timer expired\0"
- /* 63: 1259, 25 */ "Out of streams resources\0"
- /* 64: 1284, 30 */ "Machine is not on the network\0"
- /* 65: 1314, 22 */ "Package not installed\0"
- /* 66: 1336, 17 */ "Object is remote\0"
- /* 67: 1353, 22 */ "Link has been severed\0"
- /* 68: 1375, 16 */ "Advertise error\0"
- /* 69: 1391, 14 */ "Srmount error\0"
- /* 70: 1405, 28 */ "Communication error on send\0"
- /* 71: 1433, 15 */ "Protocol error\0"
- /* 72: 1448, 19 */ "Multihop attempted\0"
- /* 73: 1467, 19 */ "RFS specific error\0"
- /* 74: 1486, 12 */ "Bad message\0"
- /* 75: 1498, 38 */ "Value too large for defined data type\0"
- /* 76: 1536, 27 */ "Name not unique on network\0"
- /* 77: 1563, 29 */ "File descriptor in bad state\0"
- /* 78: 1592, 23 */ "Remote address changed\0"
- /* 79: 1615, 39 */ "Can not access a needed shared library\0"
- /* 80: 1654, 37 */ "Accessing a corrupted shared library\0"
- /* 81: 1691, 32 */ ".lib section in a.out corrupted\0"
- /* 82: 1723, 48 */ "Attempting to link in too many shared libraries\0"
- /* 83: 1771, 38 */ "Cannot exec a shared library directly\0"
- /* 84: 1809, 50 */ "Invalid or incomplete multibyte or wide character\0"
- /* 85: 1859, 44 */ "Interrupted system call should be restarted\0"
- /* 86: 1903, 19 */ "Streams pipe error\0"
- /* 87: 1922, 15 */ "Too many users\0"
- /* 88: 1937, 31 */ "Socket operation on non-socket\0"
- /* 89: 1968, 29 */ "Destination address required\0"
- /* 90: 1997, 17 */ "Message too long\0"
- /* 91: 2014, 31 */ "Protocol wrong type for socket\0"
- /* 92: 2045, 23 */ "Protocol not available\0"
- /* 93: 2068, 23 */ "Protocol not supported\0"
- /* 94: 2091, 26 */ "Socket type not supported\0"
- /* 95: 2117, 24 */ "Operation not supported\0"
- /* 96: 2141, 30 */ "Protocol family not supported\0"
- /* 97: 2171, 41 */ "Address family not supported by protocol\0"
- /* 98: 2212, 23 */ "Address already in use\0"
- /* 99: 2235, 32 */ "Cannot assign requested address\0"
- /* 100: 2267, 16 */ "Network is down\0"
- /* 101: 2283, 23 */ "Network is unreachable\0"
- /* 102: 2306, 36 */ "Network dropped connection on reset\0"
- /* 103: 2342, 33 */ "Software caused connection abort\0"
- /* 104: 2375, 25 */ "Connection reset by peer\0"
- /* 105: 2400, 26 */ "No buffer space available\0"
- /* 106: 2426, 40 */ "Transport endpoint is already connected\0"
- /* 107: 2466, 36 */ "Transport endpoint is not connected\0"
- /* 108: 2502, 46 */ "Cannot send after transport endpoint shutdown\0"
- /* 109: 2548, 35 */ "Too many references: cannot splice\0"
- /* 110: 2583, 21 */ "Connection timed out\0"
- /* 111: 2604, 19 */ "Connection refused\0"
- /* 112: 2623, 13 */ "Host is down\0"
- /* 113: 2636, 17 */ "No route to host\0"
- /* 114: 2653, 30 */ "Operation already in progress\0"
- /* 115: 2683, 26 */ "Operation now in progress\0"
- /* 116: 2709, 22 */ "Stale NFS file handle\0"
- /* 117: 2731, 25 */ "Structure needs cleaning\0"
- /* 118: 2756, 28 */ "Not a XENIX named type file\0"
- /* 119: 2784, 30 */ "No XENIX semaphores available\0"
- /* 120: 2814, 21 */ "Is a named type file\0"
- /* 121: 2835, 17 */ "Remote I/O error\0"
- /* 122: 2852, 20 */ "Disk quota exceeded\0"
- /* 123: 2872, 16 */ "No medium found\0"
- /* 124: 2888, 18 */ "Wrong medium type"
-#if defined(__mips__) || defined(__sparc__)
- "\0"
- /* 125: 2906, 28 */ "File locking deadlock error"
-#endif
- /* Note: for mips we are ignoring ECANCELED since glibc doesn't have a
- * corresponsding message.*/
-};
-
-#endif
-/**********************************************************************/
-#if defined(L_sys_errlist) && defined(__UCLIBC_HAS_SYS_ERRLIST__)
-
-link_warning(_sys_errlist, "sys_nerr and sys_errlist are obsolete and uClibc support for them (in at least some configurations) will probably be unavailable in the near future.")
-
-const char *const sys_errlist[] = {
- [0] = _string_syserrmsgs + 0,
- [EPERM] = _string_syserrmsgs + 8,
- [ENOENT] = _string_syserrmsgs + 32,
- [ESRCH] = _string_syserrmsgs + 58,
- [EINTR] = _string_syserrmsgs + 74,
- [EIO] = _string_syserrmsgs + 98,
- [ENXIO] = _string_syserrmsgs + 117,
- [E2BIG] = _string_syserrmsgs + 143,
- [ENOEXEC] = _string_syserrmsgs + 166,
- [EBADF] = _string_syserrmsgs + 184,
- [ECHILD] = _string_syserrmsgs + 204,
- [EAGAIN] = _string_syserrmsgs + 223,
- [ENOMEM] = _string_syserrmsgs + 256,
- [EACCES] = _string_syserrmsgs + 279,
- [EFAULT] = _string_syserrmsgs + 297,
- [ENOTBLK] = _string_syserrmsgs + 309,
- [EBUSY] = _string_syserrmsgs + 331,
- [EEXIST] = _string_syserrmsgs + 355,
- [EXDEV] = _string_syserrmsgs + 367,
- [ENODEV] = _string_syserrmsgs + 393,
- [ENOTDIR] = _string_syserrmsgs + 408,
- [EISDIR] = _string_syserrmsgs + 424,
- [EINVAL] = _string_syserrmsgs + 439,
- [ENFILE] = _string_syserrmsgs + 456,
- [EMFILE] = _string_syserrmsgs + 486,
- [ENOTTY] = _string_syserrmsgs + 506,
- [ETXTBSY] = _string_syserrmsgs + 537,
- [EFBIG] = _string_syserrmsgs + 552,
- [ENOSPC] = _string_syserrmsgs + 567,
- [ESPIPE] = _string_syserrmsgs + 591,
- [EROFS] = _string_syserrmsgs + 604,
- [EMLINK] = _string_syserrmsgs + 626,
- [EPIPE] = _string_syserrmsgs + 641,
- [EDOM] = _string_syserrmsgs + 653,
- [ERANGE] = _string_syserrmsgs + 686,
- [EDEADLK] = _string_syserrmsgs + 716,
- [ENAMETOOLONG] = _string_syserrmsgs + 742,
- [ENOLCK] = _string_syserrmsgs + 761,
- [ENOSYS] = _string_syserrmsgs + 780,
- [ENOTEMPTY] = _string_syserrmsgs + 805,
- [ELOOP] = _string_syserrmsgs + 825,
- /* _string_syserrmsgs + 859, */
- [ENOMSG] = _string_syserrmsgs + 860,
- [EIDRM] = _string_syserrmsgs + 887,
- [ECHRNG] = _string_syserrmsgs + 906,
- [EL2NSYNC] = _string_syserrmsgs + 934,
- [EL3HLT] = _string_syserrmsgs + 959,
- [EL3RST] = _string_syserrmsgs + 974,
- [ELNRNG] = _string_syserrmsgs + 988,
- [EUNATCH] = _string_syserrmsgs + 1013,
- [ENOCSI] = _string_syserrmsgs + 1042,
- [EL2HLT] = _string_syserrmsgs + 1069,
- [EBADE] = _string_syserrmsgs + 1084,
- [EBADR] = _string_syserrmsgs + 1101,
- [EXFULL] = _string_syserrmsgs + 1128,
- [ENOANO] = _string_syserrmsgs + 1142,
- [EBADRQC] = _string_syserrmsgs + 1151,
- [EBADSLT] = _string_syserrmsgs + 1172,
- /* _string_syserrmsgs + 1185, */
- [EBFONT] = _string_syserrmsgs + 1186,
- [ENOSTR] = _string_syserrmsgs + 1207,
- [ENODATA] = _string_syserrmsgs + 1227,
- [ETIME] = _string_syserrmsgs + 1245,
- [ENOSR] = _string_syserrmsgs + 1259,
- [ENONET] = _string_syserrmsgs + 1284,
- [ENOPKG] = _string_syserrmsgs + 1314,
- [EREMOTE] = _string_syserrmsgs + 1336,
- [ENOLINK] = _string_syserrmsgs + 1353,
- [EADV] = _string_syserrmsgs + 1375,
- [ESRMNT] = _string_syserrmsgs + 1391,
- [ECOMM] = _string_syserrmsgs + 1405,
- [EPROTO] = _string_syserrmsgs + 1433,
- [EMULTIHOP] = _string_syserrmsgs + 1448,
- [EDOTDOT] = _string_syserrmsgs + 1467,
- [EBADMSG] = _string_syserrmsgs + 1486,
- [EOVERFLOW] = _string_syserrmsgs + 1498,
- [ENOTUNIQ] = _string_syserrmsgs + 1536,
- [EBADFD] = _string_syserrmsgs + 1563,
- [EREMCHG] = _string_syserrmsgs + 1592,
- [ELIBACC] = _string_syserrmsgs + 1615,
- [ELIBBAD] = _string_syserrmsgs + 1654,
- [ELIBSCN] = _string_syserrmsgs + 1691,
- [ELIBMAX] = _string_syserrmsgs + 1723,
- [ELIBEXEC] = _string_syserrmsgs + 1771,
- [EILSEQ] = _string_syserrmsgs + 1809,
- [ERESTART] = _string_syserrmsgs + 1859,
- [ESTRPIPE] = _string_syserrmsgs + 1903,
- [EUSERS] = _string_syserrmsgs + 1922,
- [ENOTSOCK] = _string_syserrmsgs + 1937,
- [EDESTADDRREQ] = _string_syserrmsgs + 1968,
- [EMSGSIZE] = _string_syserrmsgs + 1997,
- [EPROTOTYPE] = _string_syserrmsgs + 2014,
- [ENOPROTOOPT] = _string_syserrmsgs + 2045,
- [EPROTONOSUPPORT] = _string_syserrmsgs + 2068,
- [ESOCKTNOSUPPORT] = _string_syserrmsgs + 2091,
- [EOPNOTSUPP] = _string_syserrmsgs + 2117,
- [EPFNOSUPPORT] = _string_syserrmsgs + 2141,
- [EAFNOSUPPORT] = _string_syserrmsgs + 2171,
- [EADDRINUSE] = _string_syserrmsgs + 2212,
- [EADDRNOTAVAIL] = _string_syserrmsgs + 2235,
- [ENETDOWN] = _string_syserrmsgs + 2267,
- [ENETUNREACH] = _string_syserrmsgs + 2283,
- [ENETRESET] = _string_syserrmsgs + 2306,
- [ECONNABORTED] = _string_syserrmsgs + 2342,
- [ECONNRESET] = _string_syserrmsgs + 2375,
- [ENOBUFS] = _string_syserrmsgs + 2400,
- [EISCONN] = _string_syserrmsgs + 2426,
- [ENOTCONN] = _string_syserrmsgs + 2466,
- [ESHUTDOWN] = _string_syserrmsgs + 2502,
- [ETOOMANYREFS] = _string_syserrmsgs + 2548,
- [ETIMEDOUT] = _string_syserrmsgs + 2583,
- [ECONNREFUSED] = _string_syserrmsgs + 2604,
- [EHOSTDOWN] = _string_syserrmsgs + 2623,
- [EHOSTUNREACH] = _string_syserrmsgs + 2636,
- [EALREADY] = _string_syserrmsgs + 2653,
- [EINPROGRESS] = _string_syserrmsgs + 2683,
- [ESTALE] = _string_syserrmsgs + 2709,
- [EUCLEAN] = _string_syserrmsgs + 2731,
- [ENOTNAM] = _string_syserrmsgs + 2756,
- [ENAVAIL] = _string_syserrmsgs + 2784,
- [EISNAM] = _string_syserrmsgs + 2814,
- [EREMOTEIO] = _string_syserrmsgs + 2835,
- [EDQUOT] = _string_syserrmsgs + 2852,
- [ENOMEDIUM] = _string_syserrmsgs + 2872,
- [EMEDIUMTYPE] = _string_syserrmsgs + 2888,
-
-#if EDEADLOCK != EDEADLK
- [EDEADLOCK] = _string_syserrmsgs + 2906,
-#endif
-
-#if EWOULDBLOCK != EAGAIN
-#error EWOULDBLOCK does not equal EAGAIN
-#endif
-
- /* For now, ignore the other arch-specific errors. glibc only maps EPROCLIM. */
-
- /* some other mips errors */
-#ifdef ECANCELED
-#endif
-#ifdef EINIT
-#endif
-#ifdef EREMDEV
-#endif
-
- /* some other sparc errors */
-#ifdef EPROCLIM
-#endif
-#ifdef ERREMOTE
-#endif
-};
-
-int sys_nerr = sizeof(sys_errlist)/sizeof(sys_errlist[0]);
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmemcpy
-#define L_memcpy
-#define Wmemcpy wmemcpy
-#else
-#define Wmemcpy memcpy
-#endif
-#endif
-
-#ifdef L_memcpy
-
-#ifndef WANT_WIDE
-#undef memcpy
-#else
-#undef wmemcpy
-#endif
-Wvoid attribute_hidden *Wmemcpy(Wvoid * __restrict s1, const Wvoid * __restrict s2, size_t n)
-{
- register Wchar *r1 = s1;
- register const Wchar *r2 = s2;
-
-#ifdef __BCC__
- while (n--) {
- *r1++ = *r2++;
- }
-#else
- while (n) {
- *r1++ = *r2++;
- --n;
- }
-#endif
-
- return s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmemmove
-#define L_memmove
-#define Wmemmove wmemmove
-#else
-#define Wmemmove memmove
-#endif
-#endif
-
-#ifdef L_memmove
-
-#ifndef WANT_WIDE
-#undef memmove
-#else
-#undef wmemmove
-#endif
-Wvoid attribute_hidden *Wmemmove(Wvoid *s1, const Wvoid *s2, size_t n)
-{
-#ifdef __BCC__
- register Wchar *s = (Wchar *) s1;
- register const Wchar *p = (const Wchar *) s2;
-
- if (p >= s) {
- while (n--) {
- *s++ = *p++;
- }
- } else {
- s += n;
- p += n;
- while (n--) {
- *--s = *--p;
- }
- }
-
- return s1;
-#else
- register Wchar *s = (Wchar *) s1;
- register const Wchar *p = (const Wchar *) s2;
-
- if (p >= s) {
- while (n) {
- *s++ = *p++;
- --n;
- }
- } else {
- while (n) {
- --n;
- s[n] = p[n];
- }
- }
-
- return s1;
-#endif
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcscpy
-#define L_strcpy
-#define Wstrcpy wcscpy
-#else
-#define Wstrcpy strcpy
-#endif
-#endif
-
-#ifdef L_strcpy
-
-#ifndef WANT_WIDE
-#undef strcpy
-#else
-#undef wcscpy
-#endif
-Wchar attribute_hidden *Wstrcpy(Wchar * __restrict s1, const Wchar * __restrict s2)
-{
- register Wchar *s = s1;
-
-#ifdef __BCC__
- do {
- *s = *s2++;
- } while (*s++ != 0);
-#else
- while ( (*s++ = *s2++) != 0 );
-#endif
-
- return s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsncpy
-#define L_strncpy
-#define Wstrncpy wcsncpy
-#else
-#define Wstrncpy strncpy
-#endif
-#endif
-
-#ifdef L_strncpy
-
-#ifndef WANT_WIDE
-#undef strncpy
-#else
-#undef wcsncpy
-#endif
-Wchar attribute_hidden *Wstrncpy(Wchar * __restrict s1, register const Wchar * __restrict s2,
- size_t n)
-{
- register Wchar *s = s1;
-
-#ifdef __BCC__
- while (n--) {
- if ((*s = *s2) != 0) s2++; /* Need to fill tail with 0s. */
- ++s;
- }
-#else
- while (n) {
- if ((*s = *s2) != 0) s2++; /* Need to fill tail with 0s. */
- ++s;
- --n;
- }
-#endif
-
- return s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcscat
-#define L_strcat
-#define Wstrcat wcscat
-#else
-#define Wstrcat strcat
-#endif
-#endif
-
-#ifdef L_strcat
-
-#ifndef WANT_WIDE
-#undef strcat
-#else
-#undef wcscat
-#endif
-Wchar attribute_hidden *Wstrcat(Wchar * __restrict s1, register const Wchar * __restrict s2)
-{
- register Wchar *s = s1;
-
- while (*s++);
- --s;
- while ((*s++ = *s2++) != 0);
-
- return s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsncat
-#define L_strncat
-#define Wstrncat wcsncat
-#else
-#define Wstrncat strncat
-#endif
-#endif
-
-#ifdef L_strncat
-
-#ifndef WANT_WIDE
-#undef strncat
-#else
-#undef wcsncat
-#endif
-Wchar attribute_hidden *Wstrncat(Wchar * __restrict s1, register const Wchar * __restrict s2,
- size_t n)
-{
- register Wchar *s = s1;
-
- while (*s++);
- --s;
-#if __BCC__
- while (n-- && ((*s = *s2++) != 0)) ++s;
-#else
- while (n && ((*s = *s2++) != 0)) {
- --n;
- ++s;
- }
-#endif
- *s = 0;
-
- return s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmemcmp
-#define L_memcmp
-#define Wmemcmp wmemcmp
-#else
-#define Wmemcmp memcmp
-#endif
-#endif
-
-#ifdef L_memcmp
-
-#ifndef WANT_WIDE
-#undef memcmp
-#else
-#undef wmemcmp
-#endif
-int attribute_hidden Wmemcmp(const Wvoid *s1, const Wvoid *s2, size_t n)
-{
- register const Wuchar *r1 = (const Wuchar *) s1;
- register const Wuchar *r2 = (const Wuchar *) s2;
-
-#ifdef WANT_WIDE
- while (n && (*r1 == *r2)) {
- ++r1;
- ++r2;
- --n;
- }
-
- return (n == 0) ? 0 : ((*r1 < *r2) ? -1 : 1);
-#else
- int r = 0;
-
- while (n-- && ((r = ((int)(*r1++)) - *r2++) == 0));
-
- return r;
-#endif
-}
-
-#if 0 /* ndef L_wmemcmp */
-weak_alias(memcmp, bcmp)
-#endif
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcscmp
-#define L_strcmp
-#define Wstrcmp wcscmp
-#else
-#define Wstrcmp strcmp
-#endif
-#endif
-
-#ifdef L_strcmp
-
-#ifndef WANT_WIDE
-#undef strcmp
-#else
-#undef wcscmp
-#endif
-int attribute_hidden Wstrcmp(register const Wchar *s1, register const Wchar *s2)
-{
-#ifdef WANT_WIDE
- while (*((Wuchar *)s1) == *((Wuchar *)s2)) {
- if (!*s1++) {
- return 0;
- }
- ++s2;
- }
-
- return (*((Wuchar *)s1) < *((Wuchar *)s2)) ? -1 : 1;
-#else
- int r;
-
- while (((r = ((int)(*((Wuchar *)s1))) - *((Wuchar *)s2++))
- == 0) && *s1++);
-
- return r;
-#endif
-}
-
-#if 0 /* def __LOCALE_C_ONLY */
-#ifdef L_wcscmp
-weak_alias(wcscmp, wcscoll)
-#else /* L_wcscmp */
-weak_alias(strcmp, strcoll)
-#endif /* L_wcscmp */
-#endif /* __LOCALE_C_ONLY */
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsncmp
-#define L_strncmp
-#define Wstrncmp wcsncmp
-#else
-#define Wstrncmp strncmp
-#endif
-#endif
-
-#ifdef L_strncmp
-
-#ifndef WANT_WIDE
-#undef strncmp
-#else
-#undef wcsncmp
-#endif
-int attribute_hidden Wstrncmp(register const Wchar *s1, register const Wchar *s2, size_t n)
-{
-#ifdef WANT_WIDE
- while (n && (*((Wuchar *)s1) == *((Wuchar *)s2))) {
- if (!*s1++) {
- return 0;
- }
- ++s2;
- --n;
- }
-
- return (n == 0) ? 0 : ((*((Wuchar *)s1) < *((Wuchar *)s2)) ? -1 : 1);
-#else
- int r = 0;
-
- while (n--
- && ((r = ((int)(*((unsigned char *)s1))) - *((unsigned char *)s2++))
- == 0)
- && *s1++);
-
- return r;
-#endif
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmemchr
-#define L_memchr
-#define Wmemchr wmemchr
-#else
-#define Wmemchr memchr
-#endif
-#endif
-
-#ifdef L_memchr
-
-#ifndef WANT_WIDE
-#undef memchr
-#else
-#undef wmemchr
-#endif
-Wvoid attribute_hidden *Wmemchr(const Wvoid *s, Wint c, size_t n)
-{
- register const Wuchar *r = (const Wuchar *) s;
-#ifdef __BCC__
- /* bcc can optimize the counter if it thinks it is a pointer... */
- register const char *np = (const char *) n;
-#else
-#define np n
-#endif
-
- while (np) {
- if (*r == ((Wuchar)c)) {
- return (Wvoid *) r; /* silence the warning */
- }
- ++r;
- --np;
- }
-
- return NULL;
-}
-#undef np
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcschr
-#define L_strchr
-#define Wstrchr wcschr
-#else
-#define Wstrchr strchr
-#endif
-#endif
-
-#ifdef L_strchr
-
-#ifndef WANT_WIDE
-#undef strchr
-#else
-#undef wcschr
-#endif
-Wchar attribute_hidden *Wstrchr(register const Wchar *s, Wint c)
-{
- do {
- if (*s == ((Wchar)c)) {
- return (Wchar *) s; /* silence the warning */
- }
- } while (*s++);
-
- return NULL;
-}
-
-#if 0 /* ndef L_wcschr */
-weak_alias(strchr, index)
-#endif
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcscspn
-#define L_strcspn
-#define Wstrcspn wcscspn
-#else
-#define Wstrcspn strcspn
-#endif
-#endif
-
-#ifdef L_strcspn
-
-#ifndef WANT_WIDE
-#undef strcspn
-#else
-#undef wcscspn
-#endif
-size_t attribute_hidden Wstrcspn(const Wchar *s1, const Wchar *s2)
-{
- register const Wchar *s;
- register const Wchar *p;
-
- for ( s=s1 ; *s ; s++ ) {
- for ( p=s2 ; *p ; p++ ) {
- if (*p == *s) goto done;
- }
- }
- done:
- return s - s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcspbrk
-#define L_strpbrk
-#define Wstrpbrk wcspbrk
-#else
-#define Wstrpbrk strpbrk
-#endif
-#endif
-
-#ifdef L_strpbrk
-
-#ifndef WANT_WIDE
-#undef strpbrk
-#else
-#undef wcspbrk
-#endif
-Wchar attribute_hidden *Wstrpbrk(const Wchar *s1, const Wchar *s2)
-{
- register const Wchar *s;
- register const Wchar *p;
-
- for ( s=s1 ; *s ; s++ ) {
- for ( p=s2 ; *p ; p++ ) {
- if (*p == *s) return (Wchar *) s; /* silence the warning */
- }
- }
- return NULL;
-}
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsrchr
-#define L_strrchr
-#define Wstrrchr wcsrchr
-#else
-#define Wstrrchr strrchr
-#endif
-#endif
-
-#ifdef L_strrchr
-
-#ifndef WANT_WIDE
-#undef strrchr
-#else
-#undef wcsrchr
-#endif
-Wchar attribute_hidden *Wstrrchr(register const Wchar *s, Wint c)
-{
- register const Wchar *p;
-
- p = NULL;
- do {
- if (*s == (Wchar) c) {
- p = s;
- }
- } while (*s++);
-
- return (Wchar *) p; /* silence the warning */
-}
-
-#if 0 /* ndef L_wcsrchr */
-weak_alias(strrchr, rindex)
-#endif
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsspn
-#define L_strspn
-#define Wstrspn wcsspn
-#else
-#define Wstrspn strspn
-#endif
-#endif
-
-#ifdef L_strspn
-
-#ifndef WANT_WIDE
-#undef strspn
-#else
-#undef wcsspn
-#endif
-size_t attribute_hidden Wstrspn(const Wchar *s1, const Wchar *s2)
-{
- register const Wchar *s = s1;
- register const Wchar *p = s2;
-
- while (*p) {
- if (*p++ == *s) {
- ++s;
- p = s2;
- }
- }
- return s - s1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsstr
-#define L_strstr
-#define Wstrstr wcsstr
-#else
-#define Wstrstr strstr
-#endif
-#endif
-
-#ifdef L_strstr
-
-/* NOTE: This is the simple-minded O(len(s1) * len(s2)) worst-case approach. */
-
-#ifndef WANT_WIDE
-#undef strstr
-#else
-#undef wcsstr
-#endif
-Wchar attribute_hidden *Wstrstr(const Wchar *s1, const Wchar *s2)
-{
- register const Wchar *s = s1;
- register const Wchar *p = s2;
-
- do {
- if (!*p) {
- return (Wchar *) s1;;
- }
- if (*p == *s) {
- ++p;
- ++s;
- } else {
- p = s2;
- if (!*s) {
- return NULL;
- }
- s = ++s1;
- }
- } while (1);
-}
-
-#if 0 /* def L_wcsstr */
-weak_alias(wcsstr, wcswcs)
-#endif
-
-#endif
-/**********************************************************************/
-#if 0
-#undef Wstrspn
-#undef Wstrpbrk
-
-#ifdef L_wcstok
-#define L_strtok_r
-#define Wstrtok_r wcstok
-#define Wstrspn wcsspn
-#define Wstrpbrk wcspbrk
-#else
-#define Wstrtok_r __strtok_r
-#define Wstrspn strspn
-#define Wstrpbrk strpbrk
-#endif
-#endif
-
-#ifdef L_strtok_r
-
-#ifndef WANT_WIDE
-#undef strtok_r
-#else
-#undef wcstok
-#endif
-Wchar attribute_hidden *Wstrtok_r(Wchar * __restrict s1, const Wchar * __restrict s2,
- Wchar ** __restrict next_start)
-{
- register Wchar *s;
- register Wchar *p;
-
-#if 1
- if (((s = s1) != NULL) || ((s = *next_start) != NULL)) {
- if (*(s += Wstrspn(s, s2))) {
- if ((p = Wstrpbrk(s, s2)) != NULL) {
- *p++ = 0;
- }
- } else {
- p = s = NULL;
- }
- *next_start = p;
- }
- return s;
-#else
- if (!(s = s1)) {
- s = *next_start;
- }
- if (s && *(s += Wstrspn(s, s2))) {
- if (*(p = s + Wstrcspn(s, s2))) {
- *p++ = 0;
- }
- *next_start = p;
- return s;
- }
- return NULL; /* TODO: set *next_start = NULL for safety? */
-#endif
-}
-
-#if 0 /* ndef L_wcstok */
-weak_alias(__strtok_r, strtok_r)
-#endif
-
-#endif
-/**********************************************************************/
-/* #ifdef L_wcstok */
-/* #define L_strtok */
-/* #define Wstrtok wcstok */
-/* #define Wstrtok_r wcstok_r */
-/* #else */
-/* #define Wstrtok strtok */
-/* #define Wstrtok_r strtok_r */
-/* #endif */
-
-#ifdef L_strtok
-#define Wstrtok strtok
-#define Wstrtok_r __strtok_r
-
-Wchar *Wstrtok(Wchar * __restrict s1, const Wchar * __restrict s2)
-{
- static Wchar *next_start; /* Initialized to 0 since in bss. */
- return Wstrtok_r(s1, s2, &next_start);
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmemset
-#define L_memset
-#define Wmemset wmemset
-#else
-#define Wmemset memset
-#endif
-#endif
-
-#ifdef L_memset
-
-#ifndef WANT_WIDE
-#undef memset
-#else
-#undef wmemset
-#endif
-Wvoid attribute_hidden *Wmemset(Wvoid *s, Wint c, size_t n)
-{
- register Wuchar *p = (Wuchar *) s;
-#ifdef __BCC__
- /* bcc can optimize the counter if it thinks it is a pointer... */
- register const char *np = (const char *) n;
-#else
-#define np n
-#endif
-
- while (np) {
- *p++ = (Wuchar) c;
- --np;
- }
-
- return s;
-}
-#undef np
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcslen
-#define L_strlen
-#define Wstrlen wcslen
-#else
-#define Wstrlen strlen
-#endif
-#endif
-
-#ifdef L_strlen
-
-#ifndef WANT_WIDE
-#undef strlen
-#else
-#undef wcslen
-#endif
-size_t attribute_hidden Wstrlen(const Wchar *s)
-{
- register const Wchar *p;
-
- for (p=s ; *p ; p++);
-
- return p - s;
-}
-
-#endif
-/**********************************************************************/
-/* ANSI/ISO end here */
-/**********************************************************************/
-#ifdef L_ffs
-
-#undef ffs
-int attribute_hidden __ffs(int i)
-{
-#if 1
- /* inlined binary search method */
- char n = 1;
-#if UINT_MAX == 0xffffU
- /* nothing to do here -- just trying to avoiding possible problems */
-#elif UINT_MAX == 0xffffffffU
- if (!(i & 0xffff)) {
- n += 16;
- i >>= 16;
- }
-#else
-#error ffs needs rewriting!
-#endif
-
- if (!(i & 0xff)) {
- n += 8;
- i >>= 8;
- }
- if (!(i & 0x0f)) {
- n += 4;
- i >>= 4;
- }
- if (!(i & 0x03)) {
- n += 2;
- i >>= 2;
- }
- return (i) ? (n + ((i+1) & 0x01)) : 0;
-
-#else
- /* linear search -- slow, but small */
- int n;
-
- for (n = 0 ; i ; ++n) {
- i >>= 1;
- }
-
- return n;
-#endif
-}
-
-strong_alias(__ffs, ffs)
-
-#endif
-/**********************************************************************/
-#if defined(L_strcasecmp) || defined(L_strcasecmp_l) || defined(L_wcscasecmp) || defined(L_wcscasecmp_l)
-
-#if defined(L_wcscasecmp) || defined(L_wcscasecmp_l)
-
-#define strcasecmp wcscasecmp
-#define __strcasecmp __wcscasecmp
-#define strcasecmp_l wcscasecmp_l
-#define __strcasecmp_l __wcscasecmp_l
-#ifdef __UCLIBC_DO_XLOCALE
-#define TOLOWER(C) __towlower_l((C), locale_arg)
-#else
-#define TOLOWER(C) __towlower((C))
-#endif
-
-#else /* defined(L_wcscasecmp) || defined(L_wcscasecmp_l) */
-
-#ifdef __UCLIBC_DO_XLOCALE
-#define TOLOWER(C) __tolower_l((C), locale_arg)
-#else
-#define TOLOWER(C) tolower((C))
-#endif
-
-#endif /* defined(L_wcscasecmp) || defined(L_wcscasecmp_l) */
-
-
-#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-
-int attribute_hidden __strcasecmp(register const Wchar *s1, register const Wchar *s2)
-{
- return __strcasecmp_l(s1, s2, __UCLIBC_CURLOCALE);
-}
-strong_alias(__strcasecmp,strcasecmp)
-
-#else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-int attribute_hidden __UCXL(strcasecmp)(register const Wchar *s1, register const Wchar *s2
- __LOCALE_PARAM )
-{
-#ifdef WANT_WIDE
- while ((*s1 == *s2) || (TOLOWER(*s1) == TOLOWER(*s2))) {
- if (!*s1++) {
- return 0;
- }
- ++s2;
- }
-
- return (((Wuchar)TOLOWER(*s1)) < ((Wuchar)TOLOWER(*s2))) ? -1 : 1;
- /* TODO -- should wide cmp funcs do wchar or Wuchar compares? */
-#else
- int r = 0;
-
- while ( ((s1 == s2) ||
- !(r = ((int)( TOLOWER(*((Wuchar *)s1))))
- - TOLOWER(*((Wuchar *)s2))))
- && (++s2, *s1++));
-
- return r;
-#endif
-}
-__UCXL_ALIAS(strcasecmp)
-
-#endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-#endif
-/**********************************************************************/
-#if defined(L_strncasecmp) || defined(L_strncasecmp_l) || defined(L_wcsncasecmp) || defined(L_wcsncasecmp_l)
-
-#if defined(L_wcsncasecmp) || defined(L_wcsncasecmp_l)
-
-#define strncasecmp wcsncasecmp
-#define __strncasecmp __wcsncasecmp
-#define strncasecmp_l wcsncasecmp_l
-#define __strncasecmp_l __wcsncasecmp_l
-#ifdef __UCLIBC_DO_XLOCALE
-#define TOLOWER(C) __towlower_l((C), locale_arg)
-#else
-#define TOLOWER(C) __towlower((C))
-#endif
-
-#else /* defined(L_wcsncasecmp) || defined(L_wcsncasecmp_l) */
-
-#ifdef __UCLIBC_DO_XLOCALE
-#define TOLOWER(C) __tolower_l((C), locale_arg)
-#else
-#define TOLOWER(C) tolower((C))
-#endif
-
-#endif /* defined(L_wcsncasecmp) || defined(L_wcsncasecmp_l) */
-
-
-#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-
-int attribute_hidden __strncasecmp(register const Wchar *s1, register const Wchar *s2, size_t n)
-{
- return __strncasecmp_l(s1, s2, n, __UCLIBC_CURLOCALE);
-}
-strong_alias(__strncasecmp,strncasecmp)
-
-#else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-int attribute_hidden __UCXL(strncasecmp)(register const Wchar *s1, register const Wchar *s2,
- size_t n __LOCALE_PARAM )
-{
-#ifdef WANT_WIDE
- while (n && ((*s1 == *s2) || (TOLOWER(*s1) == TOLOWER(*s2)))) {
- if (!*s1++) {
- return 0;
- }
- ++s2;
- --n;
- }
-
- return (n == 0)
- ? 0
- : ((((Wuchar)TOLOWER(*s1)) < ((Wuchar)TOLOWER(*s2))) ? -1 : 1);
- /* TODO -- should wide cmp funcs do wchar or Wuchar compares? */
-#else
- int r = 0;
-
- while ( n
- && ((s1 == s2) ||
- !(r = ((int)( TOLOWER(*((unsigned char *)s1))))
- - TOLOWER(*((unsigned char *)s2))))
- && (--n, ++s2, *s1++));
- return r;
-#endif
-}
-__UCXL_ALIAS(strncasecmp)
-
-#endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcsnlen
-#define L_strnlen
-#define Wstrnlen wcsnlen
-#else
-#define Wstrnlen strnlen
-#endif
-#endif
-
-#ifdef L_strnlen
-
-#ifndef WANT_WIDE
-#undef strnlen
-#else
-#undef wcsnlen
-#endif
-size_t attribute_hidden Wstrnlen(const Wchar *s, size_t max)
-{
- register const Wchar *p = s;
-#ifdef __BCC__
- /* bcc can optimize the counter if it thinks it is a pointer... */
- register const char *maxp = (const char *) max;
-#else
-#define maxp max
-#endif
-
- while (maxp && *p) {
- ++p;
- --maxp;
- }
-
- return p - s;
-}
-#undef maxp
-#endif
-/**********************************************************************/
-/* No wide analog. */
-
-#ifdef L_memccpy
-
-#undef memccpy
-void attribute_hidden *__memccpy(void * __restrict s1, const void * __restrict s2, int c, size_t n)
-{
- register char *r1 = s1;
- register const char *r2 = s2;
-
- while (n-- && (((unsigned char)(*r1++ = *r2++)) != ((unsigned char) c)));
-
- return (n == (size_t) -1) ? NULL : r1;
-}
-
-strong_alias(__memccpy, memccpy)
-
-#endif
-/**********************************************************************/
-#if 0
-#undef Wstrlen
-#undef Wstrcpy
-
-#ifdef L_wcsdup
-#define L_strdup
-#define Wstrdup wcsdup
-#define Wstrlen wcslen
-#define Wstrcpy wcscpy
-#else
-#define Wstrdup strdup
-#define Wstrlen strlen
-#define Wstrcpy strcpy
-#endif
-#endif
-
-#ifdef L_strdup
-
-#ifndef WANT_WIDE
-#undef strdup
-#else
-#undef wcsdup
-#endif
-Wchar attribute_hidden *Wstrdup(register const Wchar *s1)
-{
- register Wchar *s;
-
- if ((s = malloc((Wstrlen(s1) + 1) * sizeof(Wchar))) != NULL) {
- Wstrcpy(s, s1);
- }
-
- return s;
-}
-
-#endif
-/**********************************************************************/
-#ifdef L_strerror
-
-#undef strerror
-char attribute_hidden *__strerror(int errnum)
-{
- static char buf[_STRERROR_BUFSIZE];
-
- __xpg_strerror_r_internal(errnum, buf, sizeof(buf));
-
- return buf;
-}
-
-strong_alias(__strerror, strerror)
-
-#endif
-/**********************************************************************/
-/* SUSv3 functions. */
-/**********************************************************************/
-#ifdef L___xpg_strerror_r
-
-#ifdef __UCLIBC_HAS_ERRNO_MESSAGES__
-#if defined(__alpha__) || defined(__mips__) || defined(__sparc__)
-
-static const unsigned char estridx[] = {
- 0, /* success is always 0 */
- EPERM,
- ENOENT,
- ESRCH,
- EINTR,
- EIO,
- ENXIO,
- E2BIG,
- ENOEXEC,
- EBADF,
- ECHILD,
- EAGAIN,
- ENOMEM,
- EACCES,
- EFAULT,
- ENOTBLK,
- EBUSY,
- EEXIST,
- EXDEV,
- ENODEV,
- ENOTDIR,
- EISDIR,
- EINVAL,
- ENFILE,
- EMFILE,
- ENOTTY,
- ETXTBSY,
- EFBIG,
- ENOSPC,
- ESPIPE,
- EROFS,
- EMLINK,
- EPIPE,
- EDOM,
- ERANGE,
- EDEADLK,
- ENAMETOOLONG,
- ENOLCK,
- ENOSYS,
- ENOTEMPTY,
- ELOOP,
- 0,
- ENOMSG,
- EIDRM,
- ECHRNG,
- EL2NSYNC,
- EL3HLT,
- EL3RST,
- ELNRNG,
- EUNATCH,
- ENOCSI,
- EL2HLT,
- EBADE,
- EBADR,
- EXFULL,
- ENOANO,
- EBADRQC,
- EBADSLT,
- 0,
- EBFONT,
- ENOSTR,
- ENODATA,
- ETIME,
- ENOSR,
- ENONET,
- ENOPKG,
- EREMOTE,
- ENOLINK,
- EADV,
- ESRMNT,
- ECOMM,
- EPROTO,
- EMULTIHOP,
- EDOTDOT,
- EBADMSG,
- EOVERFLOW,
- ENOTUNIQ,
- EBADFD,
- EREMCHG,
- ELIBACC,
- ELIBBAD,
- ELIBSCN,
- ELIBMAX,
- ELIBEXEC,
- EILSEQ,
- ERESTART,
- ESTRPIPE,
- EUSERS,
- ENOTSOCK,
- EDESTADDRREQ,
- EMSGSIZE,
- EPROTOTYPE,
- ENOPROTOOPT,
- EPROTONOSUPPORT,
- ESOCKTNOSUPPORT,
- EOPNOTSUPP,
- EPFNOSUPPORT,
- EAFNOSUPPORT,
- EADDRINUSE,
- EADDRNOTAVAIL,
- ENETDOWN,
- ENETUNREACH,
- ENETRESET,
- ECONNABORTED,
- ECONNRESET,
- ENOBUFS,
- EISCONN,
- ENOTCONN,
- ESHUTDOWN,
- ETOOMANYREFS,
- ETIMEDOUT,
- ECONNREFUSED,
- EHOSTDOWN,
- EHOSTUNREACH,
- EALREADY,
- EINPROGRESS,
- ESTALE,
- EUCLEAN,
- ENOTNAM,
- ENAVAIL,
- EISNAM,
- EREMOTEIO,
-#ifdef __mips__
- 0, /* mips has an outrageous value for this... */
-#else
- EDQUOT,
-#endif
- ENOMEDIUM,
- EMEDIUMTYPE,
-#if defined(__mips__) || defined(__sparc__)
- EDEADLOCK,
-#endif
-};
-
-#endif
-
-/* __xpg_strerror_r is used in header */
-int attribute_hidden __xpg_strerror_r_internal(int errnum, char *strerrbuf, size_t buflen)
-{
- register char *s;
- int i, retval;
- char buf[_STRERROR_BUFSIZE];
- static const char unknown[] = {
- 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r', ' '
- };
-
- retval = EINVAL;
-
-
-#ifdef __UCLIBC_HAS_ERRNO_MESSAGES__
-
-#if defined(__alpha__) || defined(__mips__) || defined(__sparc__)
- /* Need to translate errno to string index. */
- for (i = 0 ; i < sizeof(estridx)/sizeof(estridx[0]) ; i++) {
- if (estridx[i] == errnum) {
- goto GOT_ESTRIDX;
- }
- }
- i = INT_MAX; /* Failed, but may need to check mips special case. */
-#ifdef __mips__
- if (errnum == EDQUOT) { /* Deal with large EDQUOT value on mips */
- i = 122;
- }
-#endif /* __mips__ */
- GOT_ESTRIDX:
-#else
- /* No errno to string index translation needed. */
- i = errnum;
-#endif
-
- if (((unsigned int) i) < _SYS_NERR) {
- /* Trade time for space. This function should rarely be called
- * so rather than keeping an array of pointers for the different
- * messages, just run through the buffer until we find the
- * correct string. */
- for (s = (char *) _string_syserrmsgs ; i ; ++s) {
- if (!*s) {
- --i;
- }
- }
- if (*s) { /* Make sure we have an actual message. */
- retval = 0;
- goto GOT_MESG;
- }
- }
-
-#endif /* __UCLIBC_HAS_ERRNO_MESSAGES__ */
-
- s = _int10tostr(buf+sizeof(buf)-1, errnum) - sizeof(unknown);
- __memcpy(s, unknown, sizeof(unknown));
-
- GOT_MESG:
- if (!strerrbuf) { /* SUSv3 */
- buflen = 0;
- }
- i = __strlen(s) + 1;
- if (i > buflen) {
- i = buflen;
- retval = ERANGE;
- }
-
- if (i) {
- __memcpy(strerrbuf, s, i);
- strerrbuf[i-1] = 0; /* In case buf was too small. */
- }
-
- if (retval) {
- __set_errno(retval);
- }
-
- return retval;
-}
-
-#else /* __UCLIBC_HAS_ERRNO_MESSAGES__ */
-
-int attribute_hidden __xpg_strerror_r_internal(int errnum, char *strerrbuf, size_t buflen)
-{
- register char *s;
- int i, retval;
- char buf[_STRERROR_BUFSIZE];
- static const char unknown[] = {
- 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'e', 'r', 'r', 'o', 'r', ' '
- };
-
- s = _int10tostr(buf+sizeof(buf)-1, errnum) - sizeof(unknown);
- __memcpy(s, unknown, sizeof(unknown));
-
- if (!strerrbuf) { /* SUSv3 */
- buflen = 0;
- }
-
- retval = EINVAL;
-
- i = buf + sizeof(buf) - s;
-
- if (i > buflen) {
- i = buflen;
- retval = ERANGE;
- }
-
- if (i) {
- __memcpy(strerrbuf, s, i);
- strerrbuf[i-1] = 0; /* In case buf was too small. */
- }
-
- __set_errno(retval);
-
- return retval;
-}
-
-#endif /* __UCLIBC_HAS_ERRNO_MESSAGES__ */
-strong_alias(__xpg_strerror_r_internal,__xpg_strerror_r)
-
-#endif
-/**********************************************************************/
-/* GNU extension functions. */
-/**********************************************************************/
-#ifdef L___glibc_strerror_r
-
-char attribute_hidden *__glibc_strerror_r_internal(int errnum, char *strerrbuf, size_t buflen)
-{
- __xpg_strerror_r_internal(errnum, strerrbuf, buflen);
-
- return strerrbuf;
-}
-
-strong_alias(__glibc_strerror_r_internal,__glibc_strerror_r)
-weak_alias(__glibc_strerror_r_internal, __strerror_r)
-#endif
-/**********************************************************************/
-#ifdef L_memmem
-
-#undef memmem
-void attribute_hidden *__memmem(const void *haystack, size_t haystacklen,
- const void *needle, size_t needlelen)
-{
- register const char *ph;
- register const char *pn;
- const char *plast;
- size_t n;
-
- if (needlelen == 0) {
- return (void *) haystack;
- }
-
- if (haystacklen >= needlelen) {
- ph = (const char *) haystack;
- pn = (const char *) needle;
- plast = ph + (haystacklen - needlelen);
-
- do {
- n = 0;
- while (ph[n] == pn[n]) {
- if (++n == needlelen) {
- return (void *) ph;
- }
- }
- } while (++ph <= plast);
- }
-
- return NULL;
-}
-
-strong_alias(__memmem, memmem)
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wmempcpy
-#define L_mempcpy
-#define Wmempcpy wmempcpy
-#else
-#define Wmempcpy __mempcpy
-#endif
-#endif
-
-#ifdef L_mempcpy
-
-#ifndef WANT_WIDE
-#undef mempcpy
-#else
-#undef wmempcpy
-#endif
-Wvoid attribute_hidden *Wmempcpy(Wvoid * __restrict s1, const Wvoid * __restrict s2, size_t n)
-{
- register Wchar *r1 = s1;
- register const Wchar *r2 = s2;
-
-#ifdef __BCC__
- while (n--) {
- *r1++ = *r2++;
- }
-#else
- while (n) {
- *r1++ = *r2++;
- --n;
- }
-#endif
-
- return r1;
-}
-
-#if 0 /* ndef L_wmempcpy */
-weak_alias(__mempcpy, mempcpy)
-#endif
-
-#endif
-/**********************************************************************/
-#ifdef L_memrchr
-
-#undef memrchr
-void attribute_hidden *__memrchr(const void *s, int c, size_t n)
-{
- register const unsigned char *r;
-#ifdef __BCC__
- /* bcc can optimize the counter if it thinks it is a pointer... */
- register const char *np = (const char *) n;
-#else
-#define np n
-#endif
-
- r = ((unsigned char *)s) + ((size_t) np);
-
- while (np) {
- if (*--r == ((unsigned char)c)) {
- return (void *) r; /* silence the warning */
- }
- --np;
- }
-
- return NULL;
-}
-#undef np
-
-strong_alias(__memrchr, memrchr)
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcpcpy
-#define L_stpcpy
-#define Wstpcpy wcpcpy
-#else
-#define Wstpcpy stpcpy
-#endif
-#endif
-
-#ifdef L_stpcpy
-
-#ifndef WANT_WIDE
-#undef stpcpy
-#else
-#undef wcpcpy
-#endif
-Wchar attribute_hidden *Wstpcpy(register Wchar * __restrict s1, const Wchar * __restrict s2)
-{
-#ifdef __BCC__
- do {
- *s1 = *s2++;
- } while (*s1++ != 0);
-#else
- while ( (*s1++ = *s2++) != 0 );
-#endif
-
- return s1 - 1;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcpncpy
-#define L_stpncpy
-#define Wstpncpy wcpncpy
-#else
-#define Wstpncpy stpncpy
-#endif
-#endif
-
-#ifdef L_stpncpy
-
-#ifndef WANT_WIDE
-#undef stpncpy
-#else
-#undef wcpncpy
-#endif
-Wchar attribute_hidden *Wstpncpy(register Wchar * __restrict s1,
- register const Wchar * __restrict s2,
- size_t n)
-{
- Wchar *s = s1;
- const Wchar *p = s2;
-
-#ifdef __BCC__
- while (n--) {
- if ((*s = *s2) != 0) s2++; /* Need to fill tail with 0s. */
- ++s;
- }
- return s1 + (s2 - p);
-#else
- while (n) {
- if ((*s = *s2) != 0) s2++; /* Need to fill tail with 0s. */
- ++s;
- --n;
- }
- return s1 + (s2 - p);
-#endif
-}
-
-#endif
-/**********************************************************************/
-#ifdef L_bzero
-
-#undef bzero
-void attribute_hidden __bzero(void *s, size_t n)
-{
-#if 1
- (void)__memset(s, 0, n);
-#else
- register unsigned char *p = s;
-#ifdef __BCC__
- /* bcc can optimize the counter if it thinks it is a pointer... */
- register const char *np = (const char *) n;
-#else
-#define np n
-#endif
-
- while (np) {
- *p++ = 0;
- --np;
- }
-#endif
-}
-#if 0
-weak_alias(__bzero, bzero)
-#else
-strong_alias(__bzero, bzero)
-#endif
-#undef np
-
-#endif
-/**********************************************************************/
-#ifdef L_bcopy
-
-#undef bcopy
-void attribute_hidden __bcopy(const void *s2, void *s1, size_t n)
-{
-#if 1
- __memmove(s1, s2, n);
-#else
-#ifdef __BCC__
- register char *s;
- register const char *p;
-
- s = s1;
- p = s2;
- if (p >= s) {
- while (n--) {
- *s++ = *p++;
- }
- } else {
- s += n;
- p += n;
- while (n--) {
- *--s = *--p;
- }
- }
-#else
- register char *s;
- register const char *p;
-
- s = s1;
- p = s2;
- if (p >= s) {
- while (n) {
- *s++ = *p++;
- --n;
- }
- } else {
- while (n) {
- --n;
- s[n] = p[n];
- }
- }
-#endif
-#endif
-}
-
-strong_alias(__bcopy, bcopy)
-
-#endif
-/**********************************************************************/
-#ifdef L_strcasestr
-
-#undef strcasestr
-char attribute_hidden *__strcasestr(const char *s1, const char *s2)
-{
- register const char *s = s1;
- register const char *p = s2;
-
-#if 1
- do {
- if (!*p) {
- return (char *) s1;;
- }
- if ((*p == *s)
- || (tolower(*((unsigned char *)p)) == tolower(*((unsigned char *)s)))
- ) {
- ++p;
- ++s;
- } else {
- p = s2;
- if (!*s) {
- return NULL;
- }
- s = ++s1;
- }
- } while (1);
-#else
- while (*p && *s) {
- if ((*p == *s)
- || (tolower(*((unsigned char *)p)) == tolower(*((unsigned char *)s)))
- ) {
- ++p;
- ++s;
- } else {
- p = s2;
- s = ++s1;
- }
- }
-
- return (*p) ? NULL : (char *) s1;
-#endif
-}
-
-strong_alias(__strcasestr, strcasestr)
-
-#endif
-/**********************************************************************/
-#ifdef L_strndup
-
-#undef strndup
-char attribute_hidden *__strndup(register const char *s1, size_t n)
-{
- register char *s;
-
- n = __strnlen(s1,n); /* Avoid problems if s1 not nul-terminated. */
-
- if ((s = malloc(n + 1)) != NULL) {
- __memcpy(s, s1, n);
- s[n] = 0;
- }
-
- return s;
-}
-
-strong_alias(__strndup, strndup)
-
-#endif
-/**********************************************************************/
-#ifdef L_strsep
-
-#undef strsep
-char attribute_hidden *__strsep(char ** __restrict s1, const char * __restrict s2)
-{
- register char *s = *s1;
- register char *p;
-
-#if 1
- p = NULL;
- if (s && *s && (p = __strpbrk(s, s2))) {
- *p++ = 0;
- }
-#else
- if (s && *s && *(p = s + __strcspn(s, s2))) {
- *p++ = 0;
- } else {
- p = NULL;
- }
-#endif
- *s1 = p;
- return s;
-}
-
-strong_alias(__strsep, strsep)
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef L_wcschrnul
-#define L_strchrnul
-#define __Wstrchrnul __wcschrnul
-#define Wstrchrnul wcschrnul
-#else
-#define __Wstrchrnul __strchrnul
-#define Wstrchrnul strchrnul
-#endif
-#endif
-
-#ifdef L_strchrnul
-
-#ifndef WANT_WIDE
-#undef strchrnul
-#else
-#undef wcschrnul
-#endif
-Wchar attribute_hidden *Wstrchrnul(register const Wchar *s, Wint c)
-{
- --s;
- while (*++s && (*s != ((Wchar)c)));
- return (Wchar *) s;
-}
-#if 0
-weak_alias(__Wstrchrnul, Wstrchrnul)
-#endif
-
-#endif
-/**********************************************************************/
-#ifdef L_rawmemchr
-
-#undef rawmemchr
-void attribute_hidden *__rawmemchr(const void *s, int c)
-{
- register const unsigned char *r = s;
-
- while (*r != ((unsigned char)c)) ++r;
-
- return (void *) r; /* silence the warning */
-}
-
-strong_alias(__rawmemchr, rawmemchr)
-
-#endif
-/**********************************************************************/
-#ifdef L_basename
-
-#undef basename
-char attribute_hidden *__basename(const char *path)
-{
- register const char *s;
- register const char *p;
-
- p = s = path;
-
- while (*s) {
- if (*s++ == '/') {
- p = s;
- }
- }
-
- return (char *) p;
-}
-
-strong_alias(__basename, basename)
-
-#endif
-/**********************************************************************/
-#ifdef L___xpg_basename
-
-char *__xpg_basename(register char *path)
-{
- static const char null_or_empty[] = ".";
- char *first;
- register char *last;
-
- first = (char *) null_or_empty;
-
- if (path && *path) {
- first = path;
- last = path - 1;
-
- do {
- if ((*path != '/') && (path > ++last)) {
- last = first = path;
- }
- } while (*++path);
-
- if (*first == '/') {
- last = first;
- }
- last[1] = 0;
- }
-
- return first;
-}
-
-#endif
-/**********************************************************************/
-#ifdef L_dirname
-
-char *dirname(char *path)
-{
- static const char null_or_empty_or_noslash[] = ".";
- register char *s;
- register char *last;
- char *first;
-
- last = s = path;
-
- if (s != NULL) {
-
- LOOP:
- while (*s && (*s != '/')) ++s;
- first = s;
- while (*s == '/') ++s;
- if (*s) {
- last = first;
- goto LOOP;
- }
-
- if (last == path) {
- if (*last != '/') {
- goto DOT;
- }
- if ((*++last == '/') && (last[1] == 0)) {
- ++last;
- }
- }
- *last = 0;
- return path;
- }
- DOT:
- return (char *) null_or_empty_or_noslash;
-}
-
-#endif
-/**********************************************************************/
-#ifdef L_strlcat
-
-/* OpenBSD function:
- * Append at most n-1-strlen(dst) chars from src to dst and nul-terminate dst.
- * Returns strlen(src) + strlen({original} dst), so truncation occurred if the
- * return val is >= n.
- * Note: If dst doesn't contain a nul in the first n chars, strlen(dst) is
- * taken as n. */
-
-size_t strlcat(register char *__restrict dst,
- register const char *__restrict src,
- size_t n)
-{
- size_t len;
- char dummy[1];
-
- len = 0;
-
- while (1) {
- if (len >= n) {
- dst = dummy;
- break;
- }
- if (!*dst) {
- break;
- }
- ++dst;
- ++len;
- }
-
- while ((*dst = *src) != 0) {
- if (++len < n) {
- ++dst;
- }
- ++src;
- }
-
- return len;
-}
-
-#endif
-/**********************************************************************/
-#if 0
-#ifdef WANT_WIDE
-extern size_t __wcslcpy(wchar_t *__restrict dst,
- const wchar_t *__restrict src,
- size_t n);
-#endif
-
-
-#ifdef L___wcslcpy
-#define L_strlcpy
-#define Wstrlcpy __wcslcpy
-#else
-#define Wstrlcpy strlcpy
-#endif
-#endif
-
-#ifdef L_strlcpy
-
-/* OpenBSD function:
- * Copy at most n-1 chars from src to dst and nul-terminate dst.
- * Returns strlen(src), so truncation occurred if the return value is >= n. */
-
-#ifndef WANT_WIDE
-#undef strlcpy
-#else
-#undef wcslcpy
-#endif
-size_t attribute_hidden Wstrlcpy(register Wchar *__restrict dst,
- register const Wchar *__restrict src,
- size_t n)
-{
- const Wchar *src0 = src;
- Wchar dummy[1];
-
- if (!n) {
- dst = dummy;
- } else {
- --n;
- }
-
- while ((*dst = *src) != 0) {
- if (n) {
- --n;
- ++dst;
- }
- ++src;
- }
-
- return src - src0;
-}
-
-#if 0 /* def __LOCALE_C_ONLY */
-#ifdef L___wcslcpy
-weak_alias(__wcslcpy,wcsxfrm)
-#else
-weak_alias(strlcpy,strxfrm)
-#endif
-#endif
-
-#endif
-/**********************************************************************/
-#if defined(L__string_syssigmsgs) && defined(__UCLIBC_HAS_SIGNUM_MESSAGES__)
-
-const char _string_syssigmsgs[] = {
- /* 0: 0, 1 */ "\0"
- /* 1: 1, 7 */ "Hangup\0"
- /* 2: 8, 10 */ "Interrupt\0"
- /* 3: 18, 5 */ "Quit\0"
- /* 4: 23, 20 */ "Illegal instruction\0"
- /* 5: 43, 22 */ "Trace/breakpoint trap\0"
- /* 6: 65, 8 */ "Aborted\0"
- /* 7: 73, 10 */ "Bus error\0"
- /* 8: 83, 25 */ "Floating point exception\0"
- /* 9: 108, 7 */ "Killed\0"
- /* 10: 115, 22 */ "User defined signal 1\0"
- /* 11: 137, 19 */ "Segmentation fault\0"
- /* 12: 156, 22 */ "User defined signal 2\0"
- /* 13: 178, 12 */ "Broken pipe\0"
- /* 14: 190, 12 */ "Alarm clock\0"
- /* 15: 202, 11 */ "Terminated\0"
- /* 16: 213, 12 */ "Stack fault\0"
- /* 17: 225, 13 */ "Child exited\0"
- /* 18: 238, 10 */ "Continued\0"
- /* 19: 248, 17 */ "Stopped (signal)\0"
- /* 20: 265, 8 */ "Stopped\0"
- /* 21: 273, 20 */ "Stopped (tty input)\0"
- /* 22: 293, 21 */ "Stopped (tty output)\0"
- /* 23: 314, 21 */ "Urgent I/O condition\0"
- /* 24: 335, 24 */ "CPU time limit exceeded\0"
- /* 25: 359, 25 */ "File size limit exceeded\0"
- /* 26: 384, 22 */ "Virtual timer expired\0"
- /* 27: 406, 24 */ "Profiling timer expired\0"
- /* 28: 430, 15 */ "Window changed\0"
- /* 29: 445, 13 */ "I/O possible\0"
- /* 30: 458, 14 */ "Power failure\0"
- /* 31: 472, 16 */ "Bad system call"
-#if defined(__alpha__) || defined(__mips__) || defined(__hppa__) || defined(__sparc__)
- /* 32: 488, 9 */ "\0EMT trap"
-#endif
-};
-
-#endif
-
-/**********************************************************************/
-#if defined(L_sys_siglist) && defined(__UCLIBC_HAS_SYS_SIGLIST__)
-
-const char *const sys_siglist[_NSIG] = {
- [0] = NULL,
- [SIGHUP] = _string_syssigmsgs + 1,
- [SIGINT] = _string_syssigmsgs + 8,
- [SIGQUIT] = _string_syssigmsgs + 18,
- [SIGILL] = _string_syssigmsgs + 23,
- [SIGTRAP] = _string_syssigmsgs + 43,
- [SIGABRT] = _string_syssigmsgs + 65,
- [SIGBUS] = _string_syssigmsgs + 73,
- [SIGFPE] = _string_syssigmsgs + 83,
- [SIGKILL] = _string_syssigmsgs + 108,
- [SIGUSR1] = _string_syssigmsgs + 115,
- [SIGSEGV] = _string_syssigmsgs + 137,
- [SIGUSR2] = _string_syssigmsgs + 156,
- [SIGPIPE] = _string_syssigmsgs + 178,
- [SIGALRM] = _string_syssigmsgs + 190,
- [SIGTERM] = _string_syssigmsgs + 202,
-#if !(defined(__alpha__) || defined(__mips__) || defined(__sparc__))
- [SIGSTKFLT] = _string_syssigmsgs + 213,
-#endif
- [SIGCHLD] = _string_syssigmsgs + 225,
- [SIGCONT] = _string_syssigmsgs + 238,
- [SIGSTOP] = _string_syssigmsgs + 248,
- [SIGTSTP] = _string_syssigmsgs + 265,
- [SIGTTIN] = _string_syssigmsgs + 273,
- [SIGTTOU] = _string_syssigmsgs + 293,
- [SIGURG] = _string_syssigmsgs + 314,
- [SIGXCPU] = _string_syssigmsgs + 335,
- [SIGXFSZ] = _string_syssigmsgs + 359,
- [SIGVTALRM] = _string_syssigmsgs + 384,
- [SIGPROF] = _string_syssigmsgs + 406,
- [SIGWINCH] = _string_syssigmsgs + 430,
- [SIGIO] = _string_syssigmsgs + 445,
- [SIGPWR] = _string_syssigmsgs + 458,
- [SIGSYS] = _string_syssigmsgs + 472,
-#if defined(__alpha__) || defined(__mips__) || defined(__hppa__) || defined(__sparc__)
- [SIGEMT] = _string_syssigmsgs + 488,
-#endif
-};
-
-#endif
-/**********************************************************************/
-#ifdef L_strsignal
-
-/* TODO: make a threadsafe version? */
-
-#undef strsignal
-#ifdef __UCLIBC_HAS_SIGNUM_MESSAGES__
-
-#if defined(__alpha__) || defined(__mips__) || defined(__hppa__) || defined(__sparc__)
-static const unsigned char sstridx[] = {
- 0,
- SIGHUP,
- SIGINT,
- SIGQUIT,
- SIGILL,
- SIGTRAP,
- SIGIOT,
- SIGBUS,
- SIGFPE,
- SIGKILL,
- SIGUSR1,
- SIGSEGV,
- SIGUSR2,
- SIGPIPE,
- SIGALRM,
- SIGTERM,
-#if defined(__alpha__) || defined(__mips__) || defined(__sparc__)
- 0,
-#else
- SIGSTKFLT,
-#endif
- SIGCHLD,
- SIGCONT,
- SIGSTOP,
- SIGTSTP,
- SIGTTIN,
- SIGTTOU,
- SIGURG,
- SIGXCPU,
- SIGXFSZ,
- SIGVTALRM,
- SIGPROF,
- SIGWINCH,
- SIGIO,
- SIGPWR,
- SIGSYS,
-#if defined(__alpha__) || defined(__mips__) || defined(__hppa__) || defined(__sparc__)
- SIGEMT,
-#endif
-};
-#endif
-
-char attribute_hidden *__strsignal(int signum)
-{
- register char *s;
- int i;
- static char buf[_STRSIGNAL_BUFSIZE];
- static const char unknown[] = {
- 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 's', 'i', 'g', 'n', 'a', 'l', ' '
- };
-
-#if defined(__alpha__) || defined(__mips__) || defined(__hppa__) || defined(__sparc__)
- /* Need to translate signum to string index. */
- for (i = 0 ; i < sizeof(sstridx)/sizeof(sstridx[0]) ; i++) {
- if (sstridx[i] == signum) {
- goto GOT_SSTRIDX;
- }
- }
- i = INT_MAX; /* Failed. */
- GOT_SSTRIDX:
-#else
- /* No signum to string index translation needed. */
- i = signum;
-#endif
-
- if (((unsigned int) signum) < _SYS_NSIG) {
- /* Trade time for space. This function should rarely be called
- * so rather than keeping an array of pointers for the different
- * messages, just run through the buffer until we find the
- * correct string. */
- for (s = (char *) _string_syssigmsgs ; i ; ++s) {
- if (!*s) {
- --i;
- }
- }
- if (*s) { /* Make sure we have an actual message. */
- goto DONE;
- }
- }
-
- s = _int10tostr(buf+sizeof(buf)-1, signum) - sizeof(unknown);
- __memcpy(s, unknown, sizeof(unknown));
-
- DONE:
- return s;
-}
-
-#else /* __UCLIBC_HAS_SIGNUM_MESSAGES__ */
-
-char attribute_hidden *__strsignal(int signum)
-{
- static char buf[_STRSIGNAL_BUFSIZE];
- static const char unknown[] = {
- 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 's', 'i', 'g', 'n', 'a', 'l', ' '
- };
-
- return (char *) __memcpy(_int10tostr(buf+sizeof(buf)-1, signum)
- - sizeof(unknown),
- unknown, sizeof(unknown));
-}
-
-#endif /* __UCLIBC_HAS_SIGNUM_MESSAGES__ */
-
-strong_alias(__strsignal, strsignal)
-
-#endif
-/**********************************************************************/
-#ifdef L_psignal
-
-/* TODO: make this threadsafe with a reentrant version of strsignal? */
-
-void psignal(int signum, register const char *message)
-{
- /* If the program is calling psignal, it's a safe bet that printf and
- * friends are used as well. It is also possible that the calling
- * program could buffer stderr, or reassign it. */
-
- register const char *sep;
-
- sep = ": ";
- if (!(message && *message)) { /* Caller did not supply a prefix message */
- message = (sep += 2); /* or passed an empty string. */
- }
-
- fprintf(stderr, "%s%s%s\n", message, sep, __strsignal(signum));
-}
-
-#endif
-/**********************************************************************/
-#ifndef __LOCALE_C_ONLY
-#if defined(L_strxfrm) || defined(L_strxfrm_l) || defined(L_wcsxfrm) || defined(L_wcsxfrm_l)
-
-#ifdef L_strxfrm
-#ifndef WANT_WIDE
-#error WANT_WIDE should be defined for L_strxfrm
-#endif
-#ifdef L_wcsxfrm
-#error L_wcsxfrm already defined for L_strxfrm
-#endif
-#endif /* L_strxfrm */
-
-#if defined(L_strxfrm) || defined(L_strxfrm_l)
-
-#define wcscoll strcoll
-#define __wcscoll __strcoll
-#define wcscoll_l strcoll_l
-#define __wcscoll_l __strcoll_l
-#define wcsxfrm strxfrm
-#define __wcsxfrm __strxfrm
-#define wcsxfrm_l strxfrm_l
-#define __wcsxfrm_l __strxfrm_l
-
-#undef WANT_WIDE
-#undef Wvoid
-#undef Wchar
-#undef Wuchar
-#undef Wint
-
-#define Wchar char
-
-#endif /* defined(L_strxfrm) || defined(L_strxfrm_l) */
-
-#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-
-int attribute_hidden __wcscoll (const Wchar *s0, const Wchar *s1)
-{
- return __wcscoll_l(s0, s1, __UCLIBC_CURLOCALE );
-}
-strong_alias(__wcscoll,wcscoll)
-
-size_t attribute_hidden __wcsxfrm(Wchar *__restrict ws1, const Wchar *__restrict ws2, size_t n)
-{
- return __wcsxfrm_l(ws1, ws2, n, __UCLIBC_CURLOCALE );
-}
-strong_alias(__wcsxfrm,wcsxfrm)
-
-#else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-
-#if 0
-#define CUR_COLLATE (&__UCLIBC_CURLOCALE_DATA.collate)
-#else
-#define CUR_COLLATE (& __LOCALE_PTR->collate)
-#endif
-
-#define MAX_PENDING 8
-
-typedef struct {
- const Wchar *s;
- const Wchar *eob; /* end of backward */
-
- __uwchar_t weight;
- __uwchar_t ui_weight; /* undefined or invalid */
- int colitem;
- int weightidx;
- int rule;
- size_t position;
- /* should be wchar_t. if wchar < 0 do EILSEQ? */
- __uwchar_t *cip;
- __uwchar_t ci_pending[MAX_PENDING]; /* nul-terminated */
-
- char *back_buf;
- char *bbe; /* end of back_buf (actual last... not 1 past end) */
- char *bp; /* ptr into backbuf, NULL if not in backward mode */
- char ibb[128];
- size_t bb_size;
-
- int ru_pushed;
-} col_state_t;
-
-
-#define WEIGHT_MASK 0x3fffU
-#define RULE_MASK 0xc000U
-
-#define RULE_FORWARD (1 << 14)
-#define RULE_POSITION (1 << 15)
-
-#define UI_IDX (WEIGHT_MASK-6)
-#define POSIT_IDX (WEIGHT_MASK-5)
-#define RANGE_IDX (WEIGHT_MASK-4)
-#define UNDEF_IDX (WEIGHT_MASK-3)
-#define INVAL_IDX (WEIGHT_MASK-2)
-#define DITTO_IDX (WEIGHT_MASK-1)
-
-
-#undef TRACE
-#if 0
-#define TRACE(X) printf X
-#else
-#define TRACE(X) ((void)0)
-#endif
-
-static int lookup(wchar_t wc __LOCALE_PARAM )
-{
- unsigned int sc, n, i0, i1;
-
- if (((__uwchar_t) wc) > 0xffffU) {
- return 0;
- }
-
- sc = wc & CUR_COLLATE->ti_mask;
- wc >>= CUR_COLLATE->ti_shift;
- n = wc & CUR_COLLATE->ii_mask;
- wc >>= CUR_COLLATE->ii_shift;
-
- i0 = CUR_COLLATE->wcs2colidt_tbl[wc];
- i0 <<= CUR_COLLATE->ii_shift;
- i1 = CUR_COLLATE->wcs2colidt_tbl[CUR_COLLATE->ii_len + i0 + n];
- i1 <<= CUR_COLLATE->ti_shift;
- return CUR_COLLATE->wcs2colidt_tbl[CUR_COLLATE->ii_len + CUR_COLLATE->ti_len + i1 + sc];
-
-}
-
-static void init_col_state(col_state_t *cs, const Wchar *wcs)
-{
- __memset(cs, 0, sizeof(col_state_t));
- cs->s = wcs;
- cs->bp = cs->back_buf = cs->ibb;
- cs->bb_size = 128;
- cs->bbe = cs->back_buf + (cs->bb_size -1);
-}
-
-static void next_weight(col_state_t *cs, int pass __LOCALE_PARAM )
-{
- int r, w, ru, ri, popping_backup_stack;
- ssize_t n;
- const uint16_t *p;
-#ifdef WANT_WIDE
-#define WC (*cs->s)
-#define N (1)
-#else /* WANT_WIDE */
- wchar_t WC;
- size_t n0, nx;
-#define N n0
-
-#endif /* WANT_WIDE */
-
- do {
-
- if (cs->ru_pushed) {
- ru = cs->ru_pushed;
- TRACE(("ru_pushed = %d\n", ru));
- cs->ru_pushed = 0;
- goto POSITION_SKIP;
- }
-
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning should we walk pendings backwards?
-#endif
- if (cs->cip) { /* possible pending weight */
- if ((r = *(cs->cip++)) == 0) {
- cs->cip = NULL;
- continue;
- }
- cs->weightidx = r & WEIGHT_MASK;
- assert(cs->weightidx);
-/* assert(cs->weightidx != WEIGHT_MASK); */
- } else { /* get the next collation item from the string */
- TRACE(("clearing popping flag\n"));
- popping_backup_stack = 0;
-
- IGNORE_LOOP:
- /* keep first pos as 0 for a sentinal */
- if (*cs->bp) { /* pending backward chars */
- POP_BACKUP:
- popping_backup_stack = 1;
- TRACE(("setting popping flag\n"));
- n = 0;
- if (*cs->bp > 0) { /* singles pending */
- cs->s -= 1;
- if ((*cs->bp -= 1) == 0) {
- cs->bp -= 1;
- }
- } else { /* last was a multi */
- cs->s += *cs->bp;
- cs->bp -= 1;
- }
- } else if (!*cs->s) { /* not in backward mode and end of string */
- cs->weight = 0;
- return;
- } else {
- cs->position += 1;
- }
-
- BACK_LOOP:
-#ifdef WANT_WIDE
- n = 1;
- cs->colitem = r = lookup(*cs->s __LOCALE_ARG );
-#else /* WANT_WIDE */
- n = n0 = __locale_mbrtowc_l(&WC, cs->s, __LOCALE_PTR);
- if (n < 0) {
- __set_errno(EILSEQ);
- cs->weight = 0;
- return;
- }
- cs->colitem = r = lookup(WC __LOCALE_ARG );
-#endif /* WANT_WIDE */
-
- TRACE((" r=%d WC=%#lx\n", r, (unsigned long)(WC)));
-
- if (r > CUR_COLLATE->max_col_index) { /* starting char for one or more sequences */
- p = CUR_COLLATE->multistart_tbl;
- p += p[r-CUR_COLLATE->max_col_index -1];
- do {
- n = N;
- r = *p++;
- do {
- if (!*p) { /* found it */
- cs->colitem = r;
- TRACE((" found multi %d\n", n));
- goto FOUND;
- }
-#ifdef WANT_WIDE
- /* the lookup check here is safe since we're assured that *p is a valid colidx */
- if (!cs->s[n] || (lookup(cs->s[n] __LOCALE_ARG ) != *p)) {
- do {} while (*p++);
- break;
- }
- ++p;
- ++n;
-#else /* WANT_WIDE */
- if (cs->s[n]) {
- nx = __locale_mbrtowc_l(&WC, cs->s + n, __LOCALE_PTR);
- if (nx < 0) {
- __set_errno(EILSEQ);
- cs->weight = 0;
- return;
- }
- }
- if (!cs->s[n] || (lookup(WC __LOCALE_ARG ) != *p)) {
- do {} while (*p++);
- break;
- }
- ++p;
- n += nx; /* Only gets here if cs->s[n] != 0, so nx is set. */
-#endif /* WANT_WIDE */
- } while (1);
- } while (1);
- } else if (r == 0) { /* illegal, undefined, or part of a range */
- if ((CUR_COLLATE->range_count)
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning .. need to introduce range as a collating item?
-#endif
- && (((__uwchar_t)(WC - CUR_COLLATE->range_low)) <= CUR_COLLATE->range_count)
- ) { /* part of a range */
- /* Note: cs->colitem = 0 already. */
- TRACE((" found range\n"));
- ru = CUR_COLLATE->ruletable[CUR_COLLATE->range_rule_offset*CUR_COLLATE->MAX_WEIGHTS + pass];
- assert((ru & WEIGHT_MASK) != DITTO_IDX);
- if ((ru & WEIGHT_MASK) == WEIGHT_MASK) {
- ru = (ru & RULE_MASK) | RANGE_IDX;
- cs->weight = CUR_COLLATE->range_base_weight + (WC - CUR_COLLATE->range_low);
- }
- goto RANGE_SKIP_TO;
- } else if (((__uwchar_t)(WC)) <= 0x7fffffffUL) { /* legal but undefined */
- UNDEFINED:
- /* Note: cs->colitem = 0 already. */
- ri = CUR_COLLATE->undefined_idx;
- assert(ri != 0); /* implicit undefined isn't supported */
-
- TRACE((" found explicit UNDEFINED\n"));
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning right now single weight locales do not support ..
-#endif
- if (CUR_COLLATE->num_weights == 1) {
- TRACE((" single weight UNDEFINED\n"));
- cs->weightidx = RANGE_IDX;
- cs->weight = ri;
- cs->s += n;
- goto PROCESS_WEIGHT;
- }
-
- ri = CUR_COLLATE->index2ruleidx[ri - 1];
- ru = CUR_COLLATE->ruletable[ri * CUR_COLLATE->MAX_WEIGHTS + pass];
- assert((ru & WEIGHT_MASK) != WEIGHT_MASK); /* TODO: handle ".." */
- if ((ru & WEIGHT_MASK) == DITTO_IDX) {
- cs->colitem = CUR_COLLATE->undefined_idx;
- }
- goto RANGE_SKIP_TO;
- } else { /* illegal */
- TRACE((" found illegal\n"));
- __set_errno(EINVAL);
- /* We put all illegals in the same equiv class with maximal weight,
- * and ignore them after the first pass. */
- if (pass > 0) {
- cs->s += n;
- goto IGNORE_LOOP;
- }
- ru = (RULE_FORWARD | RANGE_IDX);
- cs->weight = 0xffffU;
- goto RANGE_SKIP_TO;
- }
- } else if (CUR_COLLATE->num_weights == 1) {
- TRACE((" single weight\n"));
- cs->weightidx = RANGE_IDX;
- cs->weight = cs->colitem;
- cs->s += n;
- goto PROCESS_WEIGHT;
- } else {
- TRACE((" normal\n"));
- }
-
- /* if we get here, it is a normal char either singlely weighted, undefined, or in a range */
- FOUND:
- ri = CUR_COLLATE->index2ruleidx[cs->colitem - 1];
- TRACE((" ri=%d ", ri));
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning make sure this is correct
-#endif
- if (!ri) {
- TRACE(("NOT IN THIS LOCALE\n"));
- goto UNDEFINED;
- }
- ru = CUR_COLLATE->ruletable[ri * CUR_COLLATE->MAX_WEIGHTS + pass];
-
- RANGE_SKIP_TO:
-
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning ignoreables probably should not interrupt backwards processing, but this is wrong
-#endif
-/* if (!(ru & WEIGHT_MASK)) { */
-/* TRACE(("IGNORE\n")); */
-/* cs->s += n; */
-/* continue; */
-/* } */
-
-
- TRACE((" rule = %#x weight = %#x popping = %d s = %p eob = %p\n",
- ru & RULE_MASK, ru & WEIGHT_MASK, popping_backup_stack,
- cs->s, cs->eob));
- /* now we need to check if we're going backwards... */
-
- if (!popping_backup_stack) {
- if (!(ru & RULE_MASK)) { /* backward */
- TRACE(("backwards\n"));
- assert(cs->bp <= cs->bbe);
- if (cs->bp == cs->bbe) {
- if (cs->back_buf == cs->ibb) { /* was using internal buffer */
- cs->bp = malloc(cs->bb_size + 128);
- if (!cs->bp) {
- __set_errno(ENOMEM);
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning what to do here?
-#endif
- cs->weight = 0;
- return;
- }
- __memcpy(cs->bp, cs->back_buf, cs->bb_size);
-
- } else {
- cs->bp = realloc(cs->back_buf, cs->bb_size + 128);
- if (!cs->bp) {
- __set_errno(ENOMEM);
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning what to do here?
-#endif
- cs->weight = 0;
- return;
- }
- }
- cs->bb_size += 128;
- cs->bbe = cs->bp + (cs->bbe - cs->back_buf);
- cs->back_buf = cs->bp;
- cs->bp = cs->bbe;
-
- }
- if (n==1) { /* single char */
- if (*cs->bp && (((unsigned char)(*cs->bp)) < CHAR_MAX)) {
- *cs->bp += 1; /* increment last single's count */
- } else { /* last was a multi, or just starting */
- if (!cs->bp) {
- cs->bp = cs->back_buf;
- } else {
- assert(cs->bp < cs->bbe);
- ++cs->bp;
- }
- *cs->bp = 1;
- }
- } else { /* multichar */
- assert(n>1);
- assert(cs->bp < cs->bbe);
- *++cs->bp = -n;
- }
- cs->s += n;
- if (*cs->s) {
- goto BACK_LOOP;
- }
- /* end-of-string so start popping */
- cs->eob = cs->s;
- TRACE(("popping\n"));
- goto POP_BACKUP;
- } else if (*cs->bp) { /* was going backward but this element isn't */
- /* discard current and use previous backward element */
- assert(!cs->cip);
- cs->eob = cs->s;
- TRACE(("popping\n"));
- goto POP_BACKUP;
- } else { /* was and still going forward */
- TRACE(("forwards\n"));
- if ((ru & (RULE_POSITION|WEIGHT_MASK)) > RULE_POSITION) {
- assert(ru & WEIGHT_MASK);
- cs->ru_pushed = ru;
- cs->weight = cs->position;
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning devel code
-#endif
- cs->position = 0; /* reset to reduce size for strcoll? */
- cs->s += n;
- cs->weightidx = RANGE_IDX;
- goto PROCESS_WEIGHT;
- }
- }
- } else { /* popping backwards stack */
- TRACE(("popping (continued)\n"));
- if (!*cs->bp) {
- cs->s = cs->eob;
- }
- cs->s -= n;
- }
-
- cs->s += n;
- POSITION_SKIP:
- cs->weightidx = ru & WEIGHT_MASK;
- cs->rule = ru & RULE_MASK;
- }
-
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning for pending we only want the weight... _not_ the rule
-#endif
- if (!cs->weightidx) { /* ignore */
- continue;
- }
-
- PROCESS_WEIGHT:
- assert(cs->weightidx);
-
-
- if (((unsigned int)(cs->weightidx - UI_IDX)) <= (INVAL_IDX-UI_IDX)) {
- if (cs->weightidx == UI_IDX) {
- cs->weight = cs->ui_weight;
- }
- return;
- }
-
- assert(cs->weightidx != WEIGHT_MASK);
- if (cs->weightidx == DITTO_IDX) { /* want the weight of the current collating item */
- TRACE(("doing ditto\n"));
- w = CUR_COLLATE->index2weight[cs->colitem -1];
- } else if (cs->weightidx <= CUR_COLLATE->max_col_index) { /* normal */
- TRACE(("doing normal\n"));
- w = CUR_COLLATE->index2weight[cs->weightidx -1];
- } else { /* a string */
- TRACE(("doing string\n"));
- assert(!(cs->weightidx & RULE_MASK));
- /* note: iso14561 allows null string here */
- p = CUR_COLLATE->weightstr + (cs->weightidx - (CUR_COLLATE->max_col_index + 2));
- if (*p & WEIGHT_MASK) {
- r = 0;
- do {
- assert(r < MAX_PENDING);
- cs->ci_pending[r++] = *p++;
- } while (*p & WEIGHT_MASK);
- cs->cip = cs->ci_pending;
- }
- continue;
- }
-
- cs->weight = w;
- return;
- } while (1);
-}
-
-int attribute_hidden __UCXL(wcscoll) (const Wchar *s0, const Wchar *s1 __LOCALE_PARAM )
-{
- col_state_t ws[2];
- int pass;
-
- if (!CUR_COLLATE->num_weights) { /* C locale */
-#ifdef WANT_WIDE
- return __wcscmp(s0, s1);
-#else /* WANT_WIDE */
- return __strcmp(s0, s1);
-#endif /* WANT_WIDE */
- }
-
- pass = 0;
- do { /* loop through the weights levels */
- init_col_state(ws, s0);
- init_col_state(ws+1, s1);
- do { /* loop through the strings */
- /* for each string, get the next weight */
- next_weight(ws, pass __LOCALE_ARG );
- next_weight(ws+1, pass __LOCALE_ARG );
- TRACE(("w0=%lu w1=%lu\n",
- (unsigned long) ws[0].weight,
- (unsigned long) ws[1].weight));
-
- if (ws[0].weight != ws[1].weight) {
- return ws[0].weight - ws[1].weight;
- }
- } while (ws[0].weight);
- } while (++pass < CUR_COLLATE->num_weights);
-
- return 0;
-}
-__UCXL_ALIAS(wcscoll)
-
-#ifdef WANT_WIDE
-
-size_t attribute_hidden __UCXL(wcsxfrm)(wchar_t *__restrict ws1, const wchar_t *__restrict ws2,
- size_t n __LOCALE_PARAM )
-{
- col_state_t cs;
- size_t count;
- int pass;
-
- if (!CUR_COLLATE->num_weights) { /* C locale */
- return __wcsxfrm(ws1, ws2, n);
- }
-
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning handle empty string as a special case
-#endif
-
- count = pass = 0;
- do { /* loop through the weights levels */
- init_col_state(&cs, ws2);
- do { /* loop through the string */
- next_weight(&cs, pass __LOCALE_ARG );
- TRACE(("weight=%lu (%#lx)\n", (unsigned long) cs.weight, (unsigned long) cs.weight));
- if (count < n) {
- ws1[count] = cs.weight +1;
- }
- ++count;
- TRACE(("--------------------------------------------\n"));
- } while (cs.weight);
- if (count <= n) { /* overwrite the trailing 0 end-of-pass marker */
- ws1[count-1] = 1;
- }
- TRACE(("-------------------- pass %d --------------------\n", pass));
- } while (++pass < CUR_COLLATE->num_weights);
- if (count <= n) { /* oops... change it back */
- ws1[count-1] = 0;
- }
- return count-1;
-}
-
-__UCXL_ALIAS(wcsxfrm)
-
-#else /* WANT_WIDE */
-
-static const unsigned long bound[] = {
- 1UL << 7,
- 1UL << 11,
- 1UL << 16,
- 1UL << 21,
- 1UL << 26,
-};
-
-static unsigned char first[] = {
- 0x0, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
-};
-
-/* Use an extension of UTF-8 to store a 32 bit val in max 6 bytes. */
-
-static size_t store(unsigned char *s, size_t count, size_t n, __uwchar_t weight)
-{
- int i, r;
-
- i = 0;
- do {
- if (weight < bound[i]) {
- break;
- }
- } while (++i < sizeof(bound)/sizeof(bound[0]));
-
- r = i+1;
- if (i + count < n) {
- s += count;
- s[0] = first[i];
- while (i) {
- s[i] = 0x80 | (weight & 0x3f);
- weight >>= 6;
- --i;
- }
- s[0] |= weight;
- }
-
- return r;
-}
-
-size_t attribute_hidden __UCXL(strxfrm)(char *__restrict ws1, const char *__restrict ws2, size_t n
- __LOCALE_PARAM )
-{
- col_state_t cs;
- size_t count, inc;
- int pass;
-
- if (!CUR_COLLATE->num_weights) { /* C locale */
- return __strlcpy(ws1, ws2, n);
- }
-
-#ifdef __UCLIBC_MJN3_ONLY__
-#warning handle empty string as a special case
-#endif
-
- inc = count = pass = 0;
- do { /* loop through the weights levels */
- init_col_state(&cs, ws2);
- do { /* loop through the string */
- next_weight(&cs, pass __LOCALE_ARG );
- TRACE(("weight=%lu (%#lx)\n", (unsigned long) cs.weight, (unsigned long) cs.weight));
- inc = store((unsigned char *)ws1, count, n, cs.weight + 1);
- count += inc;
- TRACE(("--------------------------------------------\n"));
- } while (cs.weight);
- /* overwrite the trailing 0 end-of-pass marker */
- assert(inc == 1);
- if (count <= n) {
- ws1[count-1] = 1;
- }
- TRACE(("-------------------- pass %d --------------------\n", pass));
- } while (++pass < CUR_COLLATE->num_weights);
- if (count <= n) { /* oops... change it back */
- ws1[count-1] = 0;
- }
- return count-1;
-}
-
-__UCXL_ALIAS(strxfrm)
-
-#endif /* WANT_WIDE */
-
-#endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
-
-#endif /* defined(L_strxfrm) || defined(L_strxfrm_l) || defined(L_wcsxfrm) || defined(L_wcsxfrm_l) */
-
-#endif /* __LOCALE_C_ONLY */
-/**********************************************************************/