+2013-06-07 Joseph Myers <joseph@codesourcery.com>
+
+ * bits/byteswap.h [__GNUC__ && !__GNUC_PREREQ (4, 3)]
+ (__bswap_32): Do not use "register".
+ * crypt/crypt.c (_ufc_doit_r): Likewise.
+ * debug/stpcpy_chk.c (__stpcpy_chk): Likewise.
+ * debug/wcscat_chk.c (__wcscat_chk): Likewise.
+ * gmon/gmon.c (__monstartup): Likewise.
+ * gmon/mcount.c (_MCOUNT_DECL(frompc, selfpc)): Likewise.
+ * hurd/hurdmalloc.c (more_memory): Likewise.
+ (malloc): Likewise.
+ (free): Likewise.
+ (realloc): Likewise.
+ (malloc_fork_prepare): Likewise.
+ (malloc_fork_parent): Likewise.
+ (malloc_fork_child): Likewise.
+ * include/rpc/auth_des.h (xdr_authdes_verf): Likewise.
+ (_svcauth_des): Likewise.
+ * inet/inet_lnaof.c (inet_lnaof): Likewise.
+ * inet/inet_net.c (inet_network): Likewise.
+ * inet/inet_netof.c (inet_netof): Likewise.
+ * inet/rcmd.c (__validuser2_sa): Likewise.
+ * io/fts.c (fts_open): Likewise.
+ (fts_load): Likewise.
+ (fts_close): Likewise.
+ (fts_read): Likewise.
+ (fts_children): Likewise.
+ (fts_build): Likewise.
+ (fts_stat): Likewise.
+ (fts_sort): Likewise.
+ (fts_alloc): Likewise.
+ (fts_lfree): Likewise.
+ * libio/fileops.c (_IO_new_file_xsputn): Likewise.
+ (_IO_file_xsgetn): Likewise.
+ (_IO_file_xsgetn_mmap): Likewise.
+ * libio/iofopncook.c (_IO_cookie_read): Likewise.
+ (_IO_cookie_write): Likewise.
+ * libio/oldfileops.c (_IO_old_file_xsputn): Likewise.
+ * libio/wfileops.c (_IO_wfile_xsputn): Likewise.
+ * mach/msgserver.c (__mach_msg_server_timeout): Likewise.
+ * malloc/obstack.c (_obstack_begin): Likewise.
+ (_obstack_begin_1): Likewise.
+ (_obstack_newchunk): Likewise.
+ (_obstack_allocated_p): Likewise.
+ (obstack_free): Likewise.
+ (_obstack_memory_used): Likewise.
+ * misc/getttyent.c (getttynam): Likewise.
+ (getttyent): Likewise.
+ (skip): Likewise.
+ (value): Likewise.
+ * misc/getusershell.c (initshells): Likewise.
+ * misc/syslog.c (__vsyslog_chk): Likewise.
+ * misc/ttyslot.c (ttyslot): Likewise.
+ * nis/nis_hash.c (__nis_hash): Likewise.
+ * posix/fnmatch_loop.c (FCT): Likewise.
+ * posix/getconf.c (print_all): Likewise.
+ (main): Likewise.
+ * posix/getopt.c (exchange): Likewise.
+ * posix/glob.c (globfree): Likewise.
+ (prefix_array): Likewise.
+ (__glob_pattern_type): Likewise.
+ * resolv/arpa/nameser.h (NS_GET16): Likewise.
+ (NS_GET32): Likewise.
+ (NS_PUT16): Likewise.
+ (NS_PUT32): Likewise.
+ * resolv/gethnamaddr.c (getanswer): Likewise.
+ (gethostbyname2): Likewise.
+ (gethostbyaddr): Likewise.
+ (_gethtent): Likewise.
+ (_gethtbyname2): Likewise.
+ (_gethtbyaddr): Likewise.
+ * resolv/ns_print.c (dst_s_get_int16): Likewise.
+ * resolv/nss_dns/dns-host.c (getanswer_r): Likewise.
+ * resolv/res_init.c (__res_vinit): Likewise.
+ (net_mask): Likewise.
+ * resolv/res_mkquery.c (outchar): Likewise.
+ (PRINT): Likewise.
+ * stdio-common/printf_fp.c (outchar): Likewise.
+ (PRINT): Likewise.
+ * stdio-common/printf_fphex.c (outchar): Likewise.
+ (PRINT): Likewise.
+ * stdio-common/printf_size.c (outchar): Likewise.
+ (PRINT): Likewise.
+ * stdio-common/test_rdwr.c (main): Likewise.
+ * stdio-common/tfformat.c (matches): Likewise.
+ * stdio-common/vfprintf.c (outchar): Likewise.
+ (printf_unknown): Likewise.
+ (buffered_vfprintf): Likewise.
+ * stdio-common/vfscanf.c (_IO_vfscanf_internal): Likewise.
+ * stdio-common/xbug.c (AppendToBuffer): Likewise.
+ (ReadFile): Likewise.
+ * stdlib/qsort.c (SWAP): Likewise.
+ (_quicksort): Likewise.
+ * stdlib/setenv.c (__add_to_environ): Likewise.
+ * stdlib/strtod_l.c (____STRTOF_INTERNAL): Likewise.
+ * stdlib/strtol_l.c (__strtol_l): Likewise.
+ * stdlib/tst-strtod.c (main): Likewise.
+ * stdlib/tst-strtol.c (main): Likewise.
+ * stdlib/tst-strtoll.c (main): Likewise.
+ * string/bits/string2.h (__strcmp_cc): Likewise.
+ (__strcmp_cg): Likewise.
+ (__strcspn_c1): Likewise.
+ (__strcspn_c2): Likewise.
+ (__strcspn_c3): Likewise.
+ (__strspn_c1): Likewise.
+ (__strspn_c2): Likewise.
+ (__strspn_c3): Likewise.
+ (__strsep_1c): Likewise.
+ (__strsep_2c): Likewise.
+ (__strsep_3c): Likewise.
+ * string/memccpy.c (__memccpy): Likewise.
+ * string/stpcpy.c (__stpcpy): Likewise.
+ * string/strcmp.c (strcmp): Likewise.
+ * string/strrchr.c (strrchr): Likewise.
+ * sysdeps/generic/sigset-cvt-mask.h (sigset_get_old_mask):
+ Likewise.
+ * sysdeps/mach/hurd/getcwd.c
+ (_hurd_canonicalize_directory_name_internal): Likewise.
+ * sysdeps/mach/i386/sysdep.h (SNARF_ARGS): Likewise.
+ * sysdeps/powerpc/powerpc32/power6/wcschr.c (wcschr): Likewise.
+ * sysdeps/powerpc/powerpc32/power6/wcsrchr.c (wcsrchr): Likewise.
+ * sysdeps/x86/bits/byteswap-16.h [__GNUC__] (__bswap_16):
+ Likewise, in both definitions.
+ * sysdeps/x86/bits/byteswap.h (__bswap_32): Likewise, in multiple
+ definitions.
+ [__GNUC_PREREQ (2, 0) && !__GNUC_PREREQ (4, 3) && __WORDSIZE ==
+ 64] (__bswap_64): Likewise.
+ * time/test_time.c (main): Likewise.
+ * time/tzfile.c (__tzfile_read): Likewise.
+ (__tzfile_compute): Likewise.
+ * time/tzset.c (__tzset_parse_tz): Likewise.
+ (tzset_internal): Likewise.
+ (compute_change): Likewise.
+ * wcsmbs/wcscat.c (__wcscat): Likewise.
+ * wcsmbs/wcschr.c (wcschr): Likewise.
+ * wcsmbs/wcschrnul.c (__wcschrnul): Likewise.
+ * wcsmbs/wcscspn.c (wcscspn): Likewise.
+ * wcsmbs/wcspbrk.c (wcspbrk): Likewise.
+ * wcsmbs/wcsrchr.c (wcsrchr): Likewise.
+ * wcsmbs/wcsspn.c (wcsspn): Likewise.
+ * wcsmbs/wcsstr.c (wcsstr): Likewise.
+ * wcsmbs/wmemchr.c (wmemchr): Likewise.
+ * wcsmbs/wmemcmp.c (WMEMCMP): Likewise.
+ * wcsmbs/wmemset.c (wmemset): Likewise.
+
2013-06-06 Joseph Myers <joseph@codesourcery.com>
* scripts/config.guess: Update to version 2013-05-16.
# else
# define __bswap_32(x) \
(__extension__ \
- ({ register unsigned int __bsx = (x); __bswap_constant_32 (__bsx); }))
+ ({ unsigned int __bsx = (x); __bswap_constant_32 (__bsx); }))
# endif
#else
static __inline unsigned int
{
int i;
long64 l, r, s, *k;
- register long64 *sb01 = (long64*)__data->sb0;
- register long64 *sb23 = (long64*)__data->sb2;
+ long64 *sb01 = (long64*)__data->sb0;
+ long64 *sb23 = (long64*)__data->sb2;
l = (((long64)res[0]) << 32) | ((long64)res[1]);
r = (((long64)res[2]) << 32) | ((long64)res[3]);
const char *src;
size_t destlen;
{
- register char *d = dest;
- register const char *s = src;
+ char *d = dest;
+ const char *s = src;
do
{
wchar_t *
__wcscat_chk (wchar_t *dest, const wchar_t *src, size_t destlen)
{
- register wchar_t *s1 = dest;
- register const wchar_t *s2 = src;
+ wchar_t *s1 = dest;
+ const wchar_t *s2 = src;
wchar_t c;
/* Find the end of the string. */
u_long lowpc;
u_long highpc;
{
- register int o;
+ int o;
char *cp;
struct gmonparam *p = &_gmonparam;
*/
_MCOUNT_DECL(frompc, selfpc) /* _mcount; may be static, inline, etc */
{
- register ARCINDEX *frompcindex;
- register struct tostruct *top, *prevtop;
- register struct gmonparam *p;
- register ARCINDEX toindex;
+ ARCINDEX *frompcindex;
+ struct tostruct *top, *prevtop;
+ struct gmonparam *p;
+ ARCINDEX toindex;
int i;
p = &_gmonparam;
static void
more_memory(int size, free_list_t fl)
{
- register int amount;
- register int n;
+ int amount;
+ int n;
vm_address_t where;
- register header_t h;
+ header_t h;
kern_return_t r;
if (size <= vm_page_size) {
/* Declaration changed to standard one for GNU. */
void *
malloc(size)
- register size_t size;
+ size_t size;
{
- register int i, n;
- register free_list_t fl;
- register header_t h;
+ int i, n;
+ free_list_t fl;
+ header_t h;
if ((int) size < 0) /* sanity check */
return 0;
free(base)
void *base;
{
- register header_t h;
- register free_list_t fl;
- register int i;
+ header_t h;
+ free_list_t fl;
+ int i;
if (base == 0)
return;
void *old_base;
size_t new_size;
{
- register header_t h;
- register free_list_t fl;
- register int i;
+ header_t h;
+ free_list_t fl;
+ int i;
unsigned int old_size;
char *new_base;
void
print_malloc_free_list()
{
- register int i, size;
- register free_list_t fl;
- register int n;
- register header_t h;
+ int i, size;
+ free_list_t fl;
+ int n;
+ header_t h;
int total_used = 0;
int total_free = 0;
* malloc critical section.
*/
{
- register int i;
+ int i;
for (i = 0; i < NBUCKETS; i++) {
spin_lock(&malloc_free_list[i].lock);
* Called in the parent process after a fork() to resume normal operation.
*/
{
- register int i;
+ int i;
for (i = NBUCKETS-1; i >= 0; i--) {
spin_unlock(&malloc_free_list[i].lock);
* Called in the child process after a fork() to resume normal operation.
*/
{
- register int i;
+ int i;
for (i = NBUCKETS-1; i >= 0; i--) {
spin_unlock(&malloc_free_list[i].lock);
libc_hidden_proto (rtime)
extern bool_t xdr_authdes_cred (XDR *xdrs, struct authdes_cred *cred);
-extern bool_t xdr_authdes_verf (register XDR *xdrs,
- register struct authdes_verf *verf);
+extern bool_t xdr_authdes_verf (XDR *xdrs,
+ struct authdes_verf *verf);
struct svc_req;
struct rpc_msg;
-extern enum auth_stat _svcauth_des (register struct svc_req *rqst,
- register struct rpc_msg *msg);
+extern enum auth_stat _svcauth_des (struct svc_req *rqst,
+ struct rpc_msg *msg);
#define DECLARE_NSS_PROTOTYPES(service) \
inet_lnaof(in)
struct in_addr in;
{
- register u_int32_t i = ntohl(in.s_addr);
+ u_int32_t i = ntohl(in.s_addr);
if (IN_CLASSA(i))
return ((i)&IN_CLASSA_HOST);
*/
u_int32_t
inet_network(cp)
- register const char *cp;
+ const char *cp;
{
- register u_int32_t val, base, n, i;
- register char c;
+ u_int32_t val, base, n, i;
+ char c;
u_int32_t parts[4], *pp = parts;
int digit;
inet_netof(in)
struct in_addr in;
{
- register u_int32_t i = ntohl(in.s_addr);
+ u_int32_t i = ntohl(in.s_addr);
if (IN_CLASSA(i))
return (((i)&IN_CLASSA_NET) >> IN_CLASSA_NSHIFT);
size_t ralen;
const char *luser, *ruser, *rhost;
{
- register const char *user;
- register char *p;
+ const char *user;
+ char *p;
int hcheck, ucheck;
char *buf = NULL;
size_t bufsize = 0;
FTS *
fts_open(argv, options, compar)
char * const *argv;
- register int options;
+ int options;
int (*compar) (const FTSENT **, const FTSENT **);
{
- register FTS *sp;
- register FTSENT *p, *root;
- register int nitems;
+ FTS *sp;
+ FTSENT *p, *root;
+ int nitems;
FTSENT *parent = NULL;
FTSENT *tmp;
internal_function
fts_load(sp, p)
FTS *sp;
- register FTSENT *p;
+ FTSENT *p;
{
- register int len;
- register char *cp;
+ int len;
+ char *cp;
/*
* Load the stream structure for the next traversal. Since we don't
fts_close(sp)
FTS *sp;
{
- register FTSENT *freep, *p;
+ FTSENT *freep, *p;
int saved_errno;
/*
FTSENT *
fts_read(sp)
- register FTS *sp;
+ FTS *sp;
{
- register FTSENT *p, *tmp;
- register int instr;
- register char *t;
+ FTSENT *p, *tmp;
+ int instr;
+ char *t;
int saved_errno;
/* If finished or unrecoverable error, return NULL. */
FTSENT *
fts_children(sp, instr)
- register FTS *sp;
+ FTS *sp;
int instr;
{
- register FTSENT *p;
+ FTSENT *p;
int fd;
if (instr != 0 && instr != FTS_NAMEONLY) {
static FTSENT *
internal_function
fts_build(sp, type)
- register FTS *sp;
+ FTS *sp;
int type;
{
- register struct dirent *dp;
- register FTSENT *p, *head;
- register int nitems;
+ struct dirent *dp;
+ FTSENT *p, *head;
+ int nitems;
FTSENT *cur, *tail;
DIR *dirp;
void *oldaddr;
internal_function
fts_stat(sp, p, follow)
FTS *sp;
- register FTSENT *p;
+ FTSENT *p;
int follow;
{
- register FTSENT *t;
- register dev_t dev;
- register ino_t ino;
+ FTSENT *t;
+ dev_t dev;
+ ino_t ino;
struct stat *sbp, sb;
int saved_errno;
fts_sort(sp, head, nitems)
FTS *sp;
FTSENT *head;
- register int nitems;
+ int nitems;
{
- register FTSENT **ap, *p;
+ FTSENT **ap, *p;
/*
* Construct an array of pointers to the structures and call qsort(3).
const char *name;
size_t namelen;
{
- register FTSENT *p;
+ FTSENT *p;
size_t len;
/*
static void
internal_function
fts_lfree(head)
- register FTSENT *head;
+ FTSENT *head;
{
- register FTSENT *p;
+ FTSENT *p;
/* Free a linked list of structures. */
while ((p = head)) {
const void *data;
_IO_size_t n;
{
- register const char *s = (const char *) data;
+ const char *s = (const char *) data;
_IO_size_t to_do = n;
int must_flush = 0;
_IO_size_t count = 0;
count = f->_IO_buf_end - f->_IO_write_ptr;
if (count >= n)
{
- register const char *p;
+ const char *p;
for (p = s + n; p > s; )
{
if (*--p == '\n')
void *data;
_IO_size_t n;
{
- register _IO_size_t want, have;
- register _IO_ssize_t count;
- register char *s = data;
+ _IO_size_t want, have;
+ _IO_ssize_t count;
+ char *s = data;
want = n;
void *data;
_IO_size_t n;
{
- register _IO_size_t have;
+ _IO_size_t have;
char *read_ptr = fp->_IO_read_ptr;
- register char *s = (char *) data;
+ char *s = (char *) data;
have = fp->_IO_read_end - fp->_IO_read_ptr;
#include <shlib-compat.h>
/* Prototyped for local functions. */
-static _IO_ssize_t _IO_cookie_read (register _IO_FILE* fp, void* buf,
+static _IO_ssize_t _IO_cookie_read (_IO_FILE* fp, void* buf,
_IO_ssize_t size);
-static _IO_ssize_t _IO_cookie_write (register _IO_FILE* fp,
+static _IO_ssize_t _IO_cookie_write (_IO_FILE* fp,
const void* buf, _IO_ssize_t size);
static _IO_off64_t _IO_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir);
static _IO_off64_t _IO_cookie_seekoff (_IO_FILE *fp, _IO_off64_t offset,
const void *data;
_IO_size_t n;
{
- register const char *s = (char *) data;
+ const char *s = (char *) data;
_IO_size_t to_do = n;
int must_flush = 0;
_IO_size_t count = 0;
count = f->_IO_buf_end - f->_IO_write_ptr;
if (count >= n)
{
- register const char *p;
+ const char *p;
for (p = s + n; p > s; )
{
if (*--p == '\n')
}
else
{
- register char *p = f->_IO_write_ptr;
- register int i = (int) count;
+ char *p = f->_IO_write_ptr;
+ int i = (int) count;
while (--i >= 0)
*p++ = *s++;
f->_IO_write_ptr = p;
const void *data;
_IO_size_t n;
{
- register const wchar_t *s = (const wchar_t *) data;
+ const wchar_t *s = (const wchar_t *) data;
_IO_size_t to_do = n;
int must_flush = 0;
_IO_size_t count;
count = f->_wide_data->_IO_buf_end - f->_wide_data->_IO_write_ptr;
if (count >= n)
{
- register const wchar_t *p;
+ const wchar_t *p;
for (p = s + n; p > s; )
{
if (*--p == L'\n')
}
else
{
- register wchar_t *p = f->_wide_data->_IO_write_ptr;
- register int i = (int) count;
+ wchar_t *p = f->_wide_data->_IO_write_ptr;
+ int i = (int) count;
while (--i >= 0)
*p++ = *s++;
f->_wide_data->_IO_write_ptr = p;
mach_msg_option_t option,
mach_msg_timeout_t timeout)
{
- register mig_reply_header_t *request, *reply;
- register mach_msg_return_t mr;
+ mig_reply_header_t *request, *reply;
+ mach_msg_return_t mr;
if (max_size == 0)
{
void *(*chunkfun) (long),
void (*freefun) (void *))
{
- register struct _obstack_chunk *chunk; /* points to new chunk */
+ struct _obstack_chunk *chunk; /* points to new chunk */
if (alignment == 0)
alignment = DEFAULT_ALIGNMENT;
void (*freefun) (void *, void *),
void *arg)
{
- register struct _obstack_chunk *chunk; /* points to new chunk */
+ struct _obstack_chunk *chunk; /* points to new chunk */
if (alignment == 0)
alignment = DEFAULT_ALIGNMENT;
void
_obstack_newchunk (struct obstack *h, int length)
{
- register struct _obstack_chunk *old_chunk = h->chunk;
- register struct _obstack_chunk *new_chunk;
- register long new_size;
- register long obj_size = h->next_free - h->object_base;
- register long i;
+ struct _obstack_chunk *old_chunk = h->chunk;
+ struct _obstack_chunk *new_chunk;
+ long new_size;
+ long obj_size = h->next_free - h->object_base;
+ long i;
long already;
char *object_base;
int
_obstack_allocated_p (struct obstack *h, void *obj)
{
- register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
- register struct _obstack_chunk *plp; /* point to previous chunk if any */
+ struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
+ struct _obstack_chunk *plp; /* point to previous chunk if any */
lp = (h)->chunk;
/* We use >= rather than > since the object cannot be exactly at
void
obstack_free (struct obstack *h, void *obj)
{
- register struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
- register struct _obstack_chunk *plp; /* point to previous chunk if any */
+ struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
+ struct _obstack_chunk *plp; /* point to previous chunk if any */
lp = h->chunk;
/* We use >= because there cannot be an object at the beginning of a chunk.
int
_obstack_memory_used (struct obstack *h)
{
- register struct _obstack_chunk* lp;
- register int nbytes = 0;
+ struct _obstack_chunk* lp;
+ int nbytes = 0;
for (lp = h->chunk; lp != 0; lp = lp->prev)
{
getttynam(tty)
const char *tty;
{
- register struct ttyent *t;
+ struct ttyent *t;
setttyent();
while ((t = getttyent()))
getttyent()
{
static struct ttyent tty;
- register int c;
- register char *p;
+ int c;
+ char *p;
#define MAXLINELENGTH 100
static char line[MAXLINELENGTH];
static char *
internal_function
skip(p)
- register char *p;
+ char *p;
{
- register char *t;
- register int c, q;
+ char *t;
+ int c, q;
for (q = 0, t = p; (c = *p) != '\0'; p++) {
if (c == '"') {
static char *
internal_function
value(p)
- register char *p;
+ char *p;
{
return ((p = index(p, '=')) ? ++p : NULL);
static char **
initshells()
{
- register char **sp, *cp;
- register FILE *fp;
+ char **sp, *cp;
+ FILE *fp;
struct stat64 statb;
size_t flen;
/* Output to stderr if requested. */
if (LogStat & LOG_PERROR) {
struct iovec iov[2];
- register struct iovec *v = iov;
+ struct iovec *v = iov;
v->iov_base = buf + msgoff;
v->iov_len = bufsize - msgoff;
int
ttyslot()
{
- register struct ttyent *ttyp;
- register int slot;
- register char *p;
+ struct ttyent *ttyp;
+ int slot;
+ char *p;
int cnt;
size_t buflen = __sysconf (_SC_TTY_NAME_MAX) + 1;
char *name;
* OZ's original sdbm hash
*/
uint32_t
-__nis_hash (const void *keyarg, register size_t len)
+__nis_hash (const void *keyarg, size_t len)
{
- register const u_char *key;
- register size_t loop;
- register uint32_t h;
+ const u_char *key;
+ size_t loop;
+ uint32_t h;
#define HASHC h = *key++ + 65599 * h
+2013-06-07 Joseph Myers <joseph@codesourcery.com>
+
+ * sysdeps/ia64/bits/byteswap-16.h [__GNUC__ && __GNUC__ >= 2]
+ (__bswap_16): Do not use "register".
+ * sysdeps/ia64/bits/byteswap.h [__GNUC__ && __GNUC__ >= 2]
+ (__bswap_32): Likewise.
+ [__GNUC__ && __GNUC__ >= 2] (__bswap_64): Likewise.
+
2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com>
* sysdeps/unix/sysv/linux/ia64/bits/siginfo.h (siginfo_t): Add
#if defined __GNUC__ && __GNUC__ >= 2
# define __bswap_16(x) \
(__extension__ \
- ({ register unsigned short int __v, __x = (unsigned short int) (x); \
+ ({ unsigned short int __v, __x = (unsigned short int) (x); \
if (__builtin_constant_p (x)) \
__v = __bswap_constant_16 (__x); \
else \
#if defined __GNUC__ && __GNUC__ >= 2
# define __bswap_32(x) \
(__extension__ \
- ({ register unsigned int __v, __x = (x); \
+ ({ unsigned int __v, __x = (x); \
if (__builtin_constant_p (x)) \
__v = __bswap_constant_32 (__x); \
else \
# define __bswap_64(x) \
(__extension__ \
- ({ register unsigned long int __v, __x = (x); \
+ ({ unsigned long int __v, __x = (x); \
if (__builtin_constant_p (x)) \
__v = __bswap_constant_64 (__x); \
else \
struct STRUCT *ends;
size_t alloca_used;
{
- register const CHAR *p = pattern, *n = string;
- register UCHAR c;
+ const CHAR *p = pattern, *n = string;
+ UCHAR c;
#ifdef _LIBC
# if WIDE_CHAR_VERSION
const char *collseq = (const char *)
/* Nonzero if the sense of the character class is inverted. */
const CHAR *p_init = p;
const CHAR *n_init = n;
- register int not;
+ int not;
CHAR cold;
UCHAR fn;
static void
print_all (const char *path)
{
- register const struct conf *c;
+ const struct conf *c;
size_t clen;
long int value;
char *cvalue;
int
main (int argc, char *argv[])
{
- register const struct conf *c;
+ const struct conf *c;
/* Set locale. Do not set LC_ALL because the other categories must
not be affected (according to POSIX.2). */
{
/* Bottom segment is the short one. */
int len = middle - bottom;
- register int i;
+ int i;
/* Swap it with the top part of the top segment. */
for (i = 0; i < len; i++)
{
/* Top segment is the short one. */
int len = top - middle;
- register int i;
+ int i;
/* Swap it with the bottom part of the bottom segment. */
for (i = 0; i < len; i++)
/* Free storage allocated in PGLOB by a previous `glob' call. */
void
globfree (pglob)
- register glob_t *pglob;
+ glob_t *pglob;
{
if (pglob->gl_pathv != NULL)
{
static int
prefix_array (const char *dirname, char **array, size_t n)
{
- register size_t i;
+ size_t i;
size_t dirlen = strlen (dirname);
#if defined __MSDOS__ || defined WINDOWS32
int sep_char = '/';
const char *pattern;
int quote;
{
- register const char *p;
+ const char *p;
int ret = 0;
for (p = pattern; *p != '\0'; ++p)
* Inline versions of get/put short/long. Pointer is advanced.
*/
#define NS_GET16(s, cp) do { \
- register const u_char *t_cp = (const u_char *)(cp); \
+ const u_char *t_cp = (const u_char *)(cp); \
(s) = ((u_int16_t)t_cp[0] << 8) \
| ((u_int16_t)t_cp[1]) \
; \
} while (0)
#define NS_GET32(l, cp) do { \
- register const u_char *t_cp = (const u_char *)(cp); \
+ const u_char *t_cp = (const u_char *)(cp); \
(l) = ((u_int32_t)t_cp[0] << 24) \
| ((u_int32_t)t_cp[1] << 16) \
| ((u_int32_t)t_cp[2] << 8) \
} while (0)
#define NS_PUT16(s, cp) do { \
- register u_int16_t t_s = (u_int16_t)(s); \
- register u_char *t_cp = (u_char *)(cp); \
+ u_int16_t t_s = (u_int16_t)(s); \
+ u_char *t_cp = (u_char *)(cp); \
*t_cp++ = t_s >> 8; \
*t_cp = t_s; \
(cp) += NS_INT16SZ; \
} while (0)
#define NS_PUT32(l, cp) do { \
- register u_int32_t t_l = (u_int32_t)(l); \
- register u_char *t_cp = (u_char *)(cp); \
+ u_int32_t t_l = (u_int32_t)(l); \
+ u_char *t_cp = (u_char *)(cp); \
*t_cp++ = t_l >> 24; \
*t_cp++ = t_l >> 16; \
*t_cp++ = t_l >> 8; \
static struct hostent *
getanswer (const querybuf *answer, int anslen, const char *qname, int qtype)
{
- register const HEADER *hp;
- register const u_char *cp;
- register int n;
+ const HEADER *hp;
+ const u_char *cp;
+ int n;
const u_char *eom, *erdata;
char *bp, **ap, **hap;
int type, class, buflen, ancount, qdcount;
continue;
}
if (!haveanswer) {
- register int nn;
+ int nn;
host.h_name = bp;
nn = strlen(bp) + 1; /* for the \0 */
u_char *ptr;
} buf;
querybuf *origbuf;
- register const char *cp;
+ const char *cp;
char *bp;
int n, size, type, len;
struct hostent *ret;
u_char *ptr;
} buf;
querybuf *orig_buf;
- register struct hostent *hp;
+ struct hostent *hp;
char qbuf[MAXDNAME+1], *qp = NULL;
#ifdef SUNSECURITY
- register struct hostent *rhp;
+ struct hostent *rhp;
char **haddr;
u_long old_options;
char hname2[MAXDNAME+1];
_gethtent()
{
char *p;
- register char *cp, **q;
+ char *cp, **q;
int af, len;
if (!hostf && !(hostf = fopen(_PATH_HOSTS, "rce" ))) {
const char *name;
int af;
{
- register struct hostent *p;
- register char **cp;
+ struct hostent *p;
+ char **cp;
_sethtent(0);
while ((p = _gethtent())) {
size_t len;
int af;
{
- register struct hostent *p;
+ struct hostent *p;
_sethtent(0);
while ((p = _gethtent()))
static u_int16_t
dst_s_get_int16(const u_char *buf)
{
- register u_int16_t a = 0;
+ u_int16_t a = 0;
a = ((u_int16_t)(buf[0] << 8)) | ((u_int16_t)(buf[1]));
return (a);
}
char *h_addr_ptrs[0];
} *host_data;
int linebuflen;
- register const HEADER *hp;
+ const HEADER *hp;
const u_char *end_of_message, *cp;
int n, ancount, qdcount;
int haveanswer, had_error;
}
if (!haveanswer)
{
- register int nn;
+ int nn;
/* We compose a single hostent out of the entire chain of
entries, so the TTL of the hostent is essentially the lowest
/* This function has to be reachable by res_data.c but not publically. */
int
__res_vinit(res_state statp, int preinit) {
- register FILE *fp;
- register char *cp, **pp;
- register int n;
+ FILE *fp;
+ char *cp, **pp;
+ int n;
char buf[BUFSIZ];
int nserv = 0; /* number of nameserver records read from file */
#ifdef _LIBC
net_mask(in) /* XXX - should really use system's version of this */
struct in_addr in;
{
- register u_int32_t i = ntohl(in.s_addr);
+ u_int32_t i = ntohl(in.s_addr);
if (IN_CLASSA(i))
return (htonl(IN_CLASSA_NET));
u_char *buf, /* buffer to put query */
int buflen) /* size of buffer */
{
- register HEADER *hp;
- register u_char *cp;
- register int n;
+ HEADER *hp;
+ u_char *cp;
+ int n;
u_char *dnptrs[20], **dpp, **lastdnptr;
#ifdef DEBUG
#define outchar(ch) \
do \
{ \
- register const int outc = (ch); \
+ const int outc = (ch); \
if (putc (outc, fp) == EOF) \
{ \
if (buffer_malloced) \
#define PRINT(ptr, wptr, len) \
do \
{ \
- register size_t outlen = (len); \
+ size_t outlen = (len); \
if (len > 20) \
{ \
if (PUT (fp, wide ? (const char *) wptr : ptr, outlen) != outlen) \
#define outchar(ch) \
do \
{ \
- register const int outc = (ch); \
+ const int outc = (ch); \
if (putc (outc, fp) == EOF) \
return -1; \
++done; \
#define PRINT(ptr, wptr, len) \
do \
{ \
- register size_t outlen = (len); \
+ size_t outlen = (len); \
if (wide) \
while (outlen-- > 0) \
outchar (*wptr++); \
#define outchar(ch) \
do \
{ \
- register const int outc = (ch); \
+ const int outc = (ch); \
if (putc (outc, fp) == EOF) \
return -1; \
++done; \
#define PRINT(ptr, wptr, len) \
do \
{ \
- register size_t outlen = (len); \
+ size_t outlen = (len); \
if (len > 20) \
{ \
if (PUT (fp, wide ? (const char *) wptr : ptr, outlen) != outlen) \
long int where = ftell (f);
if (where == (long int) replace_from)
{
- register size_t i;
+ size_t i;
for (i = replace_from; i < replace_to; ++i)
if (putc(replace[i], f) == EOF)
{
int required_precision = 13;
static int
-matches (register char *result, register const char *desired)
+matches (char *result, const char *desired)
{
int digits_seen = 0;
for (;; result++, desired++) {
#define outchar(Ch) \
do \
{ \
- register const INT_T outc = (Ch); \
+ const INT_T outc = (Ch); \
if (PUTC (outc, s) == EOF || done == INT_MAX) \
{ \
done = -1; \
CHAR_T work_buffer[MAX (sizeof (info->width), sizeof (info->prec)) * 3];
CHAR_T *const workend
= &work_buffer[sizeof (work_buffer) / sizeof (CHAR_T)];
- register CHAR_T *w;
+ CHAR_T *w;
outchar (L_('%'));
static int
internal_function
-buffered_vfprintf (register _IO_FILE *s, const CHAR_T *format,
+buffered_vfprintf (_IO_FILE *s, const CHAR_T *format,
_IO_va_list args)
{
CHAR_T buf[_IO_BUFSIZ];
struct helper_file helper;
- register _IO_FILE *hp = (_IO_FILE *) &helper._f;
+ _IO_FILE *hp = (_IO_FILE *) &helper._f;
int result, to_flush;
/* Orient the stream. */
#endif
{
va_list arg;
- register const CHAR_T *f = format;
- register UCHAR_T fc; /* Current character of the format. */
- register WINT_T done = 0; /* Assignments done. */
- register size_t read_in = 0; /* Chars read in. */
- register WINT_T c = 0; /* Last char read. */
- register int width; /* Maximum field width. */
- register int flags; /* Modifiers for current format element. */
+ const CHAR_T *f = format;
+ UCHAR_T fc; /* Current character of the format. */
+ WINT_T done = 0; /* Assignments done. */
+ size_t read_in = 0; /* Chars read in. */
+ WINT_T c = 0; /* Last char read. */
+ int width; /* Maximum field width. */
+ int flags; /* Modifiers for current format element. */
int errval = 0;
#ifndef COMPILE_WSCANF
__locale_t loc = _NL_CURRENT_LOCALE;
} Buffer;
void InitBuffer (Buffer *b);
-void AppendToBuffer (register Buffer *b, const char *str, register int len);
-void ReadFile (register Buffer *buffer, FILE *input);
+void AppendToBuffer (Buffer *b, const char *str, int len);
+void ReadFile (Buffer *buffer, FILE *input);
#define INIT_BUFFER_SIZE 10000
}
void AppendToBuffer(b, str, len)
- register Buffer *b;
+ Buffer *b;
const char *str;
- register int len;
+ int len;
{
while (b->used + len > b->room) {
b->buff = (char *)realloc(b->buff, 2*b->room*(sizeof(char)));
}
void ReadFile(buffer, input)
- register Buffer *buffer;
+ Buffer *buffer;
FILE *input;
{
char buf[BUFSIZ + 1];
- register int bytes;
+ int bytes;
buffer->used = 0;
while (!feof(input) && (bytes = fread(buf, 1, BUFSIZ, input)) > 0) {
#define SWAP(a, b, size) \
do \
{ \
- register size_t __size = (size); \
- register char *__a = (a), *__b = (b); \
+ size_t __size = (size); \
+ char *__a = (a), *__b = (b); \
do \
{ \
char __tmp = *__a; \
_quicksort (void *const pbase, size_t total_elems, size_t size,
__compar_d_fn_t cmp, void *arg)
{
- register char *base_ptr = (char *) pbase;
+ char *base_ptr = (char *) pbase;
const size_t max_thresh = MAX_THRESH * size;
char *const end_ptr = &base_ptr[size * (total_elems - 1)];
char *tmp_ptr = base_ptr;
char *thresh = min(end_ptr, base_ptr + max_thresh);
- register char *run_ptr;
+ char *run_ptr;
/* Find smallest element in first threshold and place it at the
array's beginning. This is the smallest array element,
const char *combined;
int replace;
{
- register char **ep;
- register size_t size;
+ char **ep;
+ size_t size;
const size_t namelen = strlen (name);
const size_t vallen = value != NULL ? strlen (value) + 1 : 0;
really integer digits or belong to the fractional part; i.e. we normalize
123e-2 to 1.23. */
{
- register intmax_t incr = (exponent < 0
- ? MAX (-(intmax_t) int_no, exponent)
- : MIN ((intmax_t) dig_no - (intmax_t) int_no,
- exponent));
+ intmax_t incr = (exponent < 0
+ ? MAX (-(intmax_t) int_no, exponent)
+ : MIN ((intmax_t) dig_no - (intmax_t) int_no, exponent));
int_no += incr;
exponent -= incr;
}
#define got_limb \
if (bits == 0) \
{ \
- register int cnt; \
+ int cnt; \
if (quot == 0) \
cnt = BITS_PER_MP_LIMB; \
else \
if (numsize < densize)
{
mp_size_t empty = densize - numsize;
- register int i;
+ int i;
if (bits <= 0)
exponent -= empty * BITS_PER_MP_LIMB;
used = MANT_DIG - bits;
if (used >= BITS_PER_MP_LIMB)
{
- register int i;
+ int i;
(void) __mpn_lshift (&retval[used
/ BITS_PER_MP_LIMB],
retval,
__locale_t loc;
{
int negative;
- register unsigned LONG int cutoff;
- register unsigned int cutlim;
- register unsigned LONG int i;
- register const STRING_TYPE *s;
- register UCHAR_TYPE c;
+ unsigned LONG int cutoff;
+ unsigned int cutlim;
+ unsigned LONG int i;
+ const STRING_TYPE *s;
+ UCHAR_TYPE c;
const STRING_TYPE *save, *end;
int overflow;
#ifndef USE_WIDE_CHAR
main (int argc, char ** argv)
{
char buf[100];
- register const struct ltest *lt;
+ const struct ltest *lt;
char *ep;
int status = 0;
int save_errno;
static void
expand (dst, c)
char *dst;
- register int c;
+ int c;
{
if (isprint (c))
{
int
main (void)
{
- register const struct ltest *lt;
+ const struct ltest *lt;
char *ep;
int status = 0;
int save_errno;
for (lt = tests; lt->str != NULL; ++lt)
{
- register long int l;
+ long int l;
errno = 0;
l = strtol (lt->str, &ep, lt->base);
for (++lt; lt->str != NULL; lt++)
{
- register unsigned long int ul;
+ unsigned long int ul;
errno = 0;
ul = strtoul (lt->str, &ep, lt->base);
int
main (void)
{
- register const struct ltest *lt;
+ const struct ltest *lt;
char *ep;
int status = 0;
int save_errno;
for (lt = tests; lt->str != NULL; ++lt)
{
- register long long int l;
+ long long int l;
errno = 0;
l = strtoll (lt->str, &ep, lt->base);
for (++lt; lt->str != NULL; lt++)
{
- register unsigned long long int ul;
+ unsigned long long int ul;
errno = 0;
ul = strtoull (lt->str, &ep, lt->base);
# endif
# define __strcmp_cc(s1, s2, l) \
- (__extension__ ({ register int __result = \
+ (__extension__ ({ int __result = \
(((const unsigned char *) (const char *) (s1))[0] \
- ((const unsigned char *) (const char *)(s2))[0]); \
if (l > 0 && __result == 0) \
# define __strcmp_cg(s1, s2, l1) \
(__extension__ ({ const unsigned char *__s2 = \
(const unsigned char *) (const char *) (s2); \
- register int __result = \
+ int __result = \
(((const unsigned char *) (const char *) (s1))[0] \
- __s2[0]); \
if (l1 > 0 && __result == 0) \
__STRING_INLINE size_t
__strcspn_c1 (const char *__s, int __reject)
{
- register size_t __result = 0;
+ size_t __result = 0;
while (__s[__result] != '\0' && __s[__result] != __reject)
++__result;
return __result;
__STRING_INLINE size_t
__strcspn_c2 (const char *__s, int __reject1, int __reject2)
{
- register size_t __result = 0;
+ size_t __result = 0;
while (__s[__result] != '\0' && __s[__result] != __reject1
&& __s[__result] != __reject2)
++__result;
__strcspn_c3 (const char *__s, int __reject1, int __reject2,
int __reject3)
{
- register size_t __result = 0;
+ size_t __result = 0;
while (__s[__result] != '\0' && __s[__result] != __reject1
&& __s[__result] != __reject2 && __s[__result] != __reject3)
++__result;
__STRING_INLINE size_t
__strspn_c1 (const char *__s, int __accept)
{
- register size_t __result = 0;
+ size_t __result = 0;
/* Please note that __accept never can be '\0'. */
while (__s[__result] == __accept)
++__result;
__STRING_INLINE size_t
__strspn_c2 (const char *__s, int __accept1, int __accept2)
{
- register size_t __result = 0;
+ size_t __result = 0;
/* Please note that __accept1 and __accept2 never can be '\0'. */
while (__s[__result] == __accept1 || __s[__result] == __accept2)
++__result;
__STRING_INLINE size_t
__strspn_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
{
- register size_t __result = 0;
+ size_t __result = 0;
/* Please note that __accept1 to __accept3 never can be '\0'. */
while (__s[__result] == __accept1 || __s[__result] == __accept2
|| __s[__result] == __accept3)
__STRING_INLINE char *
__strsep_1c (char **__s, char __reject)
{
- register char *__retval = *__s;
+ char *__retval = *__s;
if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL)
*(*__s)++ = '\0';
return __retval;
__STRING_INLINE char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
- register char *__retval = *__s;
+ char *__retval = *__s;
if (__retval != NULL)
{
- register char *__cp = __retval;
+ char *__cp = __retval;
while (1)
{
if (*__cp == '\0')
__STRING_INLINE char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
- register char *__retval = *__s;
+ char *__retval = *__s;
if (__retval != NULL)
{
- register char *__cp = __retval;
+ char *__cp = __retval;
while (1)
{
if (*__cp == '\0')
int c;
size_t n;
{
- register const char *s = src;
- register char *d = dest;
- register const char x = c;
- register size_t i = n;
+ const char *s = src;
+ char *d = dest;
+ const char x = c;
+ size_t i = n;
while (i-- > 0)
if ((*d++ = *s++) == x)
char *dest;
const char *src;
{
- register char *d = dest;
- register const char *s = src;
+ char *d = dest;
+ const char *s = src;
do
*d++ = *s;
const char *p1;
const char *p2;
{
- register const unsigned char *s1 = (const unsigned char *) p1;
- register const unsigned char *s2 = (const unsigned char *) p2;
+ const unsigned char *s1 = (const unsigned char *) p1;
+ const unsigned char *s2 = (const unsigned char *) p2;
unsigned char c1, c2;
do
char *
strrchr (const char *s, int c)
{
- register const char *found, *p;
+ const char *found, *p;
c = (unsigned char) c;
*set = (unsigned int) mask;
else
{
- register unsigned int __sig;
+ unsigned int __sig;
if (__sigemptyset (set) < 0)
return -1;
else
{
unsigned int mask = 0;
- register unsigned int sig;
+ unsigned int sig;
for (sig = 1; sig < NSIG && sig <= sizeof (mask) * 8; sig++)
if (__sigismember (set, sig))
mach_port_t rootid, thisid, rootdevid, thisdevid;
ino64_t rootino, thisino;
char *file_name;
- register char *file_namep;
+ char *file_namep;
file_t parent;
char *dirbuf = NULL;
unsigned int dirbufsize = 0;
#define SNARF_ARGS(entry_sp, argc, argv, envp) \
do \
{ \
- register char **p; \
+ char **p; \
argc = (int) *entry_sp; \
argv = (char **) (entry_sp + 1); \
p = argv; \
/* Find the first occurrence of WC in WCS. */
wchar_t *
wcschr (wcs, wc)
- register const wchar_t *wcs;
- register const wchar_t wc;
+ const wchar_t *wcs;
+ const wchar_t wc;
{
- register const wchar_t *wcs2 = wcs + 1;
+ const wchar_t *wcs2 = wcs + 1;
if (*wcs == wc)
return (wchar_t *) wcs;
/* Find the last occurrence of WC in WCS. */
wchar_t *
wcsrchr (wcs, wc)
- register const wchar_t *wcs;
- register const wchar_t wc;
+ const wchar_t *wcs;
+ const wchar_t wc;
{
- register const wchar_t *wcs2 = wcs + 1;
+ const wchar_t *wcs2 = wcs + 1;
const wchar_t *retval = NULL;
if (*wcs == wc)
# if __GNUC__ >= 2
# define __bswap_16(x) \
(__extension__ \
- ({ register unsigned short int __v, __x = (unsigned short int) (x); \
+ ({ unsigned short int __v, __x = (unsigned short int) (x); \
if (__builtin_constant_p (__x)) \
__v = __bswap_constant_16 (__x); \
else \
/* This is better than nothing. */
# define __bswap_16(x) \
(__extension__ \
- ({ register unsigned short int __x = (unsigned short int) (x); \
+ ({ unsigned short int __x = (unsigned short int) (x); \
__bswap_constant_16 (__x); }))
# endif
#else
`bswap' opcode. On i386 we have to use three instructions. */
# define __bswap_32(x) \
(__extension__ \
- ({ register unsigned int __v, __x = (x); \
+ ({ unsigned int __v, __x = (x); \
if (__builtin_constant_p (__x)) \
__v = __bswap_constant_32 (__x); \
else \
# else
# define __bswap_32(x) \
(__extension__ \
- ({ register unsigned int __v, __x = (x); \
+ ({ unsigned int __v, __x = (x); \
if (__builtin_constant_p (__x)) \
__v = __bswap_constant_32 (__x); \
else \
# else
# define __bswap_32(x) \
(__extension__ \
- ({ register unsigned int __x = (x); __bswap_constant_32 (__x); }))
+ ({ unsigned int __x = (x); __bswap_constant_32 (__x); }))
# endif
#else
static __inline unsigned int
# elif __WORDSIZE == 64
# define __bswap_64(x) \
(__extension__ \
- ({ register __uint64_t __v, __x = (x); \
+ ({ __uint64_t __v, __x = (x); \
if (__builtin_constant_p (__x)) \
__v = __bswap_constant_64 (__x); \
else \
main (int argc, char **argv)
{
time_t t;
- register struct tm *tp;
+ struct tm *tp;
struct tm tbuf;
int lose = 0;
{
static const char default_tzdir[] = TZDIR;
size_t num_isstd, num_isgmt;
- register FILE *f;
+ FILE *f;
struct tzhead tzhead;
size_t chars;
- register size_t i;
+ size_t i;
size_t total_size;
size_t types_idx;
size_t leaps_idx;
long int *leap_correct, int *leap_hit,
struct tm *tp)
{
- register size_t i;
+ size_t i;
if (use_localtime)
{
/* Figure out the standard <-> DST rules. */
for (unsigned int whichrule = 0; whichrule < 2; ++whichrule)
{
- register tz_rule *tzr = &tz_rules[whichrule];
+ tz_rule *tzr = &tz_rules[whichrule];
/* Ignore comma to support string following the incorrect
specification in early POSIX.1 printings. */
int explicit;
{
static int is_initialized;
- register const char *tz;
+ const char *tz;
if (is_initialized && !always)
return;
tz_rule *rule;
int year;
{
- register time_t t;
+ time_t t;
if (year != -1 && rule->computed_for == year)
/* Operations on times in 2 BC will be slower. Oh well. */
wchar_t *dest;
const wchar_t *src;
{
- register wchar_t *s1 = dest;
- register const wchar_t *s2 = src;
+ wchar_t *s1 = dest;
+ const wchar_t *s2 = src;
wchar_t c;
/* Find the end of the string. */
wchar_t *
wcschr (wcs, wc)
- register const wchar_t *wcs;
- register const wchar_t wc;
+ const wchar_t *wcs;
+ const wchar_t wc;
{
do
if (*wcs == wc)
/* Find the first occurrence of WC in WCS. */
wchar_t *
__wcschrnul (wcs, wc)
- register const wchar_t *wcs;
- register const wchar_t wc;
+ const wchar_t *wcs;
+ const wchar_t wc;
{
while (*wcs != L'\0')
if (*wcs == wc)
const wchar_t *wcs;
const wchar_t *reject;
{
- register size_t count = 0;
+ size_t count = 0;
while (*wcs != L'\0')
if (wcschr (reject, *wcs++) == NULL)
/* Find the first occurrence in WCS of any wide-character in ACCEPT. */
wchar_t *
wcspbrk (wcs, accept)
- register const wchar_t *wcs;
- register const wchar_t *accept;
+ const wchar_t *wcs;
+ const wchar_t *accept;
{
while (*wcs != L'\0')
if (wcschr (accept, *wcs) == NULL)
/* Find the last occurrence of WC in WCS. */
wchar_t *
wcsrchr (wcs, wc)
- register const wchar_t *wcs;
- register const wchar_t wc;
+ const wchar_t *wcs;
+ const wchar_t wc;
{
const wchar_t *retval = NULL;
const wchar_t *wcs;
const wchar_t *accept;
{
- register const wchar_t *p;
- register const wchar_t *a;
- register size_t count = 0;
+ const wchar_t *p;
+ const wchar_t *a;
+ size_t count = 0;
for (p = wcs; *p != L'\0'; ++p)
{
const wchar_t *haystack;
const wchar_t *needle;
{
- register wchar_t b, c;
+ wchar_t b, c;
if ((b = *needle) != L'\0')
{
for (;;)
{
- register wchar_t a;
- register const wchar_t *rhaystack, *rneedle;
+ wchar_t a;
+ const wchar_t *rhaystack, *rneedle;
do
{
wchar_t *
wmemchr (s, c, n)
- register const wchar_t *s;
- register wchar_t c;
- register size_t n;
+ const wchar_t *s;
+ wchar_t c;
+ size_t n;
{
/* For performance reasons unfold the loop four times. */
while (n >= 4)
const wchar_t *s2;
size_t n;
{
- register wchar_t c1;
- register wchar_t c2;
+ wchar_t c1;
+ wchar_t c2;
while (n >= 4)
{
wchar_t c;
size_t n;
{
- register wchar_t *wp = s;
+ wchar_t *wp = s;
while (n >= 4)
{
projects / external / glibc.git / commitdiff