mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-26 15:00:06 +00:00
503054c0dd
* nss/getXXbyYY_r.c (REENTRANT_NAME): Cast FCT in __nss_next call. * sysdeps/generic/sbrk.c: Always call __brk (0) to update __curbrk. * malloc/malloc-size.c (malloc_usable_size): Renamed from malloc_object_allocation_size. * malloc/malloc.h: Fix decl. * sys/select.h: New file, wrapper header. * posix/sys/types.h [__USE_BSD]: Include <sys/select.h>; remove fd_set, associated macros, and select decl. * sysdeps/posix/isfdtype.c: New file. Tue Jul 2 23:45:14 1996 Ulrich Drepper <drepper@cygnus.com> The latest Japanese proposal for POSIX locales renames the CHARMAP keyword in locale definition files to CHARCONV. * locale/programs/ld-ctype.c, locale/programs/locales.h: Rename function ctype_is_charmap to ctype_is_charconv. * locale/programs/locfile-kw.gperf: Replace charmap keyword with charconv. * locale/programs/locfile-token.h: Add definition of token charconv. * locale/programs/locfile.c: Recognize charconv keyword. Rename lables according to this. * locale/weight.h (get_weight): Cast constants to prevent warnings. * stdlib/strtod.c, stdlib/strtol.c, string/strcoll.c, string/strxfrm.c: Add some more casts to prevent signed<->unsigned warnings. New stuff described in P1003.1g. * misc/Makefile (headers): Add sys/select.h. (routines): Add pselect. * misc/sys/select.h: New file. Declare select functions and needed data types and macros. * sysdeps/generic/pselect.c: New file. Add generic implementation of pselect() function which uses select(). * posix/getconf.c: Recognize new variables from P1003.1g. * posix/posix1_lim.h: Define _POSIX_FD_SETSIZE, _POSIX_QLIMIT, _POSIX_HIWAT, and _POSIX_UIO_MAXIOV. * posix/unistd.h: Add description of the P1003.1g variables. * sysdeps/generic/confname.h: Define _SC_* values for new variables. * sysdeps/posix/fpathconf.c (fpathconf): Add handling of _PC_SOCK_MAXBUF. * sysdeps/stub/fpathconf.c (fpathconf): Ditto. * sysdeps/posix/sysconf.c (sysconf): Add handling of new P1003.1g variables. * sysdeps/stub/sysconf.c (sysconf): Ditto. * sysdeps/unix/sysv/linux/posix_opt.h: Define _POSIX_POLL and _POSIX_SELECT since Linux has this. * socket/Makefile (routines): Add isfdtype. * sysdeps/generic/sys/socket.h: Add prototype for isfdtype. * sysdeps/stub/isfdtype.c: New file. Stub implementation of isfdtype. * wcsmbs/wcrtomb.c (wcrtomb): Fix typo.
237 lines
5.9 KiB
C
237 lines
5.9 KiB
C
/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with the GNU C Library; see the file COPYING.LIB. If
|
|
not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifndef WIDE_VERSION
|
|
# define STRING_TYPE char
|
|
# define USTRING_TYPE unsigned char
|
|
# define L_(Ch) Ch
|
|
# define STRXFRM strxfrm
|
|
# define STRLEN strlen
|
|
# define STPNCPY __stpncpy
|
|
#endif
|
|
|
|
/* Include the shared helper functions. `strxfrm'/`wcsxfrm' also use
|
|
these functions. */
|
|
#include "../locale/weight.h"
|
|
|
|
|
|
#ifndef WIDE_VERSION
|
|
/* Write 32 bit value UTF-8 encoded but only if enough space is left. */
|
|
static __inline size_t
|
|
print_val (u_int32_t value, char *dest, size_t max, size_t act)
|
|
{
|
|
char tmp[6];
|
|
int idx = 0;
|
|
|
|
if (value < 0x80)
|
|
tmp[idx++] = (char) value;
|
|
else
|
|
{
|
|
tmp[idx++] = '\x80' + (char) (value & 0x3f);
|
|
value >>= 6;
|
|
|
|
if (value < 0x20)
|
|
tmp[idx++] = '\xc0' + (char) value;
|
|
else
|
|
{
|
|
tmp[idx++] = '\x80' + (char) (value & 0x3f);
|
|
value >>= 6;
|
|
|
|
if (value < 0x10)
|
|
tmp[idx++] = '\xe0' + (char) value;
|
|
else
|
|
{
|
|
tmp[idx++] = '\x80' + (char) (value & 0x3f);
|
|
value >>= 6;
|
|
|
|
if (value < 0x08)
|
|
tmp[idx++] = '\xf0' + (char) value;
|
|
else
|
|
{
|
|
tmp[idx++] = '\x80' + (char) (value & 0x3f);
|
|
value >>= 6;
|
|
|
|
if (value < 0x04)
|
|
tmp[idx++] = '\xf8' + (char) value;
|
|
else
|
|
{
|
|
tmp[idx++] = '\x80' + (char) (value & 0x3f);
|
|
tmp[idx++] = '\xfc' + (char) (value >> 6);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
while (idx-- > 0)
|
|
{
|
|
if (act < max)
|
|
dest[act] = tmp[idx];
|
|
++act;
|
|
}
|
|
|
|
return act;
|
|
}
|
|
#else
|
|
static __inline size_t
|
|
print_val (u_int32_t value, wchar_t *dest, size_t max, size_t act)
|
|
{
|
|
/* We cannot really assume wchar_t is 32 bits wide. But it is for
|
|
GCC and so we don't do much optimization for the other case. */
|
|
if (sizeof (wchar_t) == 4)
|
|
{
|
|
if (act < max)
|
|
dest[act] = (wchar_t) value;
|
|
++act;
|
|
}
|
|
else
|
|
{
|
|
wchar_t tmp[3];
|
|
size_t idx = 0;
|
|
|
|
if (value < 0x8000)
|
|
tmp[idx++] = (wchar_t) act;
|
|
else
|
|
{
|
|
tmp[idx++] = (wchar_t) (0x8000 + (value & 0x3fff));
|
|
value >>= 14;
|
|
if (value < 0x2000)
|
|
tmp[idx++] = (wchar_t) (0xc000 + value);
|
|
else
|
|
{
|
|
tmp[idx++] = (wchar_t) (0x8000 + (value & 0x3fff));
|
|
value >>= 14;
|
|
tmp[idx++] = (wchar_t) (0xe000 + value);
|
|
}
|
|
}
|
|
while (idx-- > 0)
|
|
{
|
|
if (act < max)
|
|
dest[act] = tmp[idx];
|
|
++act;
|
|
}
|
|
}
|
|
return act;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Transform SRC into a form such that the result of strcmp
|
|
on two strings that have been transformed by strxfrm is
|
|
the same as the result of strcoll on the two strings before
|
|
their transformation. The transformed string is put in at
|
|
most N characters of DEST and its length is returned. */
|
|
size_t
|
|
STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n)
|
|
{
|
|
weight_t *forw = NULL;
|
|
weight_t *backw = NULL;
|
|
size_t pass;
|
|
size_t written;
|
|
|
|
/* If the current locale does not specify locale data we use normal
|
|
8-bit string comparison. */
|
|
if (collate_nrules == 0)
|
|
{
|
|
if (n != 0)
|
|
STPNCPY (dest, src, n);
|
|
|
|
return STRLEN (src);
|
|
}
|
|
|
|
/* Get full information about the string. This means we get
|
|
information for all passes in a special data structure. */
|
|
get_string (src, forw, backw);
|
|
|
|
/* Now we have all the information. In at most the given number of
|
|
passes we can finally decide about the order. */
|
|
written = 0;
|
|
for (pass = 0; pass < collate_nrules; ++pass)
|
|
{
|
|
int forward = (collate_rules[pass] & sort_forward) != 0;
|
|
const weight_t *run = forward ? forw : backw;
|
|
int idx = forward ? 0 : run->data[pass].number - 1;
|
|
|
|
do
|
|
{
|
|
int ignore = 0;
|
|
u_int32_t w;
|
|
|
|
/* Here we have to check for IGNORE entries. If these are
|
|
found we count them and go on witht he next value. */
|
|
while ((w = run->data[pass].value[idx]) == (u_int32_t) IGNORE_CHAR)
|
|
{
|
|
++ignore;
|
|
if ((forward && ++idx >= run->data[pass].number)
|
|
|| (!forward && --idx < 0))
|
|
{
|
|
weight_t *nextp = forward ? run->next : run->prev;
|
|
if (nextp == NULL)
|
|
{
|
|
w = 0;
|
|
break;
|
|
}
|
|
run = nextp;
|
|
idx = forward ? 0 : run->data[pass].number - 1;
|
|
}
|
|
}
|
|
|
|
/* Now we have information of the number of ignored weights
|
|
and the value of the next weight. We have to add 2
|
|
because 0 means EOS and 1 is the intermediate string end. */
|
|
if ((collate_rules[pass] & sort_position) != 0)
|
|
written = print_val (ignore + 2, dest, n, written);
|
|
|
|
if (w != 0)
|
|
written = print_val (w, dest, n, written);
|
|
|
|
/* We have to increment the index counters. */
|
|
if ((forward && ++idx >= run->data[pass].number)
|
|
|| (!forward && --idx < 0))
|
|
if (forward)
|
|
{
|
|
run = run->next;
|
|
idx = 0;
|
|
}
|
|
else
|
|
{
|
|
run = run->prev;
|
|
if (run != NULL)
|
|
idx = run->data[pass].number - 1;
|
|
}
|
|
}
|
|
while (run != NULL);
|
|
|
|
/* Write marker for end of word. */
|
|
if (pass + 1 < collate_nrules)
|
|
written = print_val (1, dest, n, written);
|
|
}
|
|
|
|
/* Terminate string. */
|
|
if (written < n)
|
|
dest[written] = L_('\0');
|
|
|
|
/* Return length without counting the terminating '\0'. */
|
|
return written;
|
|
}
|